From 24d15a619b90ea459d1675e803689296cdee8317 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 02:21:12 +0000 Subject: [PATCH 01/24] chore(Hexploration): Replace Grunt with the Rollup build tooling Version 1 was concatenated by Grunt and linted by JSHint with globals copied from ItsATrap. Version 2 uses the same pipeline as ConditionTracker and CombatEncounterDirector: Rollup bundles ES modules from src/ into Hexploration.js and a version snapshot folder, Prettier formats the output, and scripts handle version bumps and locale syncing. Node's built-in test runner replaces the lint step. Signed-off-by: Steve Roberts --- Hexploration/.gitattributes | 9 + Hexploration/.gitignore | 4 + Hexploration/.prettierignore | 2 + Hexploration/.prettierrc.json | 5 + Hexploration/Gruntfile.js | 61 --- Hexploration/package-lock.json | 509 ++++++++++++++++++ Hexploration/package.json | 22 +- Hexploration/rollup.config.js | 110 ++++ Hexploration/scripts/build.mjs | 82 +++ Hexploration/scripts/bump-version.mjs | 83 +++ Hexploration/scripts/sync-locales.mjs | 724 ++++++++++++++++++++++++++ 11 files changed, 1544 insertions(+), 67 deletions(-) create mode 100644 Hexploration/.gitattributes create mode 100644 Hexploration/.prettierignore create mode 100644 Hexploration/.prettierrc.json delete mode 100644 Hexploration/Gruntfile.js create mode 100644 Hexploration/package-lock.json create mode 100644 Hexploration/rollup.config.js create mode 100644 Hexploration/scripts/build.mjs create mode 100644 Hexploration/scripts/bump-version.mjs create mode 100644 Hexploration/scripts/sync-locales.mjs diff --git a/Hexploration/.gitattributes b/Hexploration/.gitattributes new file mode 100644 index 0000000000..3f638fbc97 --- /dev/null +++ b/Hexploration/.gitattributes @@ -0,0 +1,9 @@ +# Enforce LF line endings for all text files in this project +* text=auto eol=lf + +# Treat these as binary to avoid any line-ending normalisation +*.png binary +*.jpg binary +*.jpeg binary +*.gif binary +*.ico binary diff --git a/Hexploration/.gitignore b/Hexploration/.gitignore index 3c3629e647..a48cb1b60c 100644 --- a/Hexploration/.gitignore +++ b/Hexploration/.gitignore @@ -1 +1,5 @@ node_modules + +*.zip +*alpha* +*beta* diff --git a/Hexploration/.prettierignore b/Hexploration/.prettierignore new file mode 100644 index 0000000000..d5f19d89b3 --- /dev/null +++ b/Hexploration/.prettierignore @@ -0,0 +1,2 @@ +node_modules +package-lock.json diff --git a/Hexploration/.prettierrc.json b/Hexploration/.prettierrc.json new file mode 100644 index 0000000000..d440171380 --- /dev/null +++ b/Hexploration/.prettierrc.json @@ -0,0 +1,5 @@ +{ + "singleQuote": true, + "trailingComma": "es5", + "printWidth": 100 +} diff --git a/Hexploration/Gruntfile.js b/Hexploration/Gruntfile.js deleted file mode 100644 index a602f19af4..0000000000 --- a/Hexploration/Gruntfile.js +++ /dev/null @@ -1,61 +0,0 @@ -'use strict'; - -module.exports = function(grunt) { - grunt.initConfig({ - pkg: grunt.file.readJSON('script.json'), - concat: { - dist: { - src: [ - 'src/index.js', - 'src/Chat.js', - 'src/HexagonTile.js', - 'src/Locations.js', - 'src/Menus.js', - 'src/State.js', - 'src/main.js' - ], - dest: '<%= pkg.version %>/<%= pkg.script %>' - } - }, - jshint: { - dist: { - src: ['src/**/*.js'] - }, - options: { - esversion: 6, - loopfunc: true, - globals: { - DefaultTrapTheme: true, - D20TrapTheme: true, - D20TrapTheme4E: true, - ItsATrap: true, - ItsATrapCreationWizard: true, - LineOfSight: true, - TrapTheme: true - }, - strict: true - } - }, - 'string-replace': { - dist: { - files: { - '<%= pkg.version %>/<%= pkg.script %>': '<%= pkg.version %>/<%= pkg.script %>' - } - }, - options: { - replacements: [ - { - pattern: 'SCRIPT_VERSION', - replacement: '<%= pkg.version %>' - } - ] - } - } - }); - - grunt.loadNpmTasks('grunt-contrib-concat'); - grunt.loadNpmTasks('grunt-contrib-jshint'); - grunt.loadNpmTasks('grunt-string-replace'); - - grunt.registerTask('default', ['jshint', 'concat', 'string-replace']); -}; diff --git a/Hexploration/package-lock.json b/Hexploration/package-lock.json new file mode 100644 index 0000000000..8a0654e2f5 --- /dev/null +++ b/Hexploration/package-lock.json @@ -0,0 +1,509 @@ +{ + "name": "hexploration-roll20", + "version": "2.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "hexploration-roll20", + "version": "2.0.0", + "devDependencies": { + "prettier": "^3.5.3", + "rollup": "^4.34.8" + } + }, + "node_modules/@napi-rs/lzma-linux-x64-gnu": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz", + "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^22.20 || ^24.12 || >=25" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.66.0.tgz", + "integrity": "sha512-7y4XeoUHPecjfUDRmap8U0q6bjfLAPn7uOGT8BKyqy8uNDOjsGS8rlBhOx6sZLVwwjN6hapvGl2mW9/IS6UNww==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.66.0.tgz", + "integrity": "sha512-e8WugYZXpgqrlMXLCudYVRAxAcK7AIY36JxRDwFRD38L9q62G1VsEUW6ijXxzjxYjNB8i1zo3B/ycIQ/qjLC/Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.66.0.tgz", + "integrity": "sha512-6vkDCfyDjNLokh+Rt1D2KtNgFFMEPdkWha/mbtP4cSjh9xiN8T/JBS/A7nDYKjmMAXHrvR9J3AzUk2LtFbIBLg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.66.0.tgz", + "integrity": "sha512-/mzZAX0+Q6eXxvkR0HB0RZCCrsbmFD8DpsvCQoMYABDfq/DjqkbfytuJ7GvZ4AhR/Mgis2fXbZrGqfbcK2Z5fA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.66.0.tgz", + "integrity": "sha512-JQJx9E8tUjGqed1RevDmoHaS3V30ODdV8uyvGxlwd4K5se6bkPrMeltSybqAtpJ+ltDRfo7FORQaJG2Hd5nGog==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.66.0.tgz", + "integrity": "sha512-GEaUQQjMaG7X1304qMgqLjzCKv6CdDirzJSS+UqUs3xhJ9X2Kjzu0JDbLoUU42FWxwmZqz+SsgU1SlQv9GNRVA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.66.0.tgz", + "integrity": "sha512-DgmAU9N0NhDQDzHgFUocDio7zRO8jR/nY/obDGvCR8zbJ6J77Fg6X49yPuExJUpYPbC82EOaRhG969pWzUSnHQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.66.0.tgz", + "integrity": "sha512-zG09YZ+sk/HoHq+P9gYB0EseQ3M20RbDuKGWey6fbiMDV1LxfXvhgSW9jDaCcvFPMgfLXpimzXY+UYvA8R2mLQ==", + "cpu": [ + "arm" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.66.0.tgz", + "integrity": "sha512-vlArhgyXbcVc1D4WZPoiYuqJIaMiSHBj6etRXua0KlfjlZeuiQyVAPYi0/N49O4mSp3u1iGUBLEjNa8ec81XZg==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.66.0.tgz", + "integrity": "sha512-RxJZtk0G87YPotDaRDvRqStV8cbqLSC5TroHvQHHKsqBg0ok64RxKgtXeFsa7FBcy7mb4crBrG3xK8USWIqWNA==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.66.0.tgz", + "integrity": "sha512-qlGcw959PrLLkZhiBxF3OZ6SQvj+OKY85mCqGNgSRs4LZlDJ6ICqmz6UdxtINdhcXYwNIbZoapQVBAmZlD2hUQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.66.0.tgz", + "integrity": "sha512-TvTI/7Cy0WvRA1SXgwzu6bwXBnMpmeT/ln5q7WvSpqmXy1VbmEnY8HVIDQNBiaHJvoWqRr0M4FNo7qiqtyMaFw==", + "cpu": [ + "loong64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.66.0.tgz", + "integrity": "sha512-UZEDkSoDRZ50NyLj70nO6mpIK3dvs2cPTTvQb1bA/PBDmr9fvn5KiESuGfh6srd7Zi6Lt9Sv2sVrFr1QoHLvPQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.66.0.tgz", + "integrity": "sha512-VRbxTvagLh3HRcysx1CNq+HHcvJbSebNI6fCbk7jwmmWHkXjrSIV3igXBpRHUTFdg0pagWGu50xoSZXnrZHjVQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.66.0.tgz", + "integrity": "sha512-uWdJpvYqh0LE/i+YBL3sMX0a2kUkICENjmrPmyBmMOFc3jMrs6MSQH/pMD+VIpGEoUcr3XkHGLLfymzIqPSRRg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.66.0.tgz", + "integrity": "sha512-3FUd88pxgWAjK60OgCrika1AcNG+u8zaCdWjg4TlcZTDkt5TGyci8ZU64l3OJ9ax0MEjw3P80B/3PoSQDCLwJQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.66.0.tgz", + "integrity": "sha512-qT2rMmgyej62g5AdwktK+Bt2lBu497pzWZe12TTQ5JmZjOYPnEwcPEAOSLTBxBV+6gIES75rXm219v/QkT397A==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.66.0.tgz", + "integrity": "sha512-E46rnZgp7J84Qwe8RMlF+rgimnDo/9fuiGbUArGB0ZkMWf97O7yeSCfKls5x/YJOF0RcuSe9RctuKe1hlxICiA==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.66.0.tgz", + "integrity": "sha512-Uz1HiZe+qBzqgdPsON+z0wRx3WdATuyzwvGT6cr2VZVrqqko0ZJVfkrQJtwDMuDcAfXYdo7XucaxJ7lTLjEcgg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.66.0.tgz", + "integrity": "sha512-Ph7TX3Ex5qdfcb7Tc6eEPugVkRfJ501eTovO4T5029YObfpZ7dzn3RiwpFvGp50nk2QUhvBMZ0PFGlEj6pOYTg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.66.0.tgz", + "integrity": "sha512-nZYPEya7ZkeNxUEiF7qmNZbyLTyRN3MK5cO22KqsaoneUzXJuzBIQRw+7BEQy9LGj2O5vrCE9V3EpK06FYo1tQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.66.0.tgz", + "integrity": "sha512-u7aTfS3R6C4hRsqXSzaO6qLZYLVuMkHMvcWlux4IM8IJif1VCl2cgPBSo5gSNoFoStQypQP+qwq8W1IyFBf1QQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.66.0.tgz", + "integrity": "sha512-e+i9ueHrH1Bafb0cf0woAIVJbYcoC8vRaD+vz+Xi8w6jz9cYJSV3vyKO6ELGSZ6g4W4MJOm2WPLN4/nQf77h7w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.66.0.tgz", + "integrity": "sha512-KfTCbrtr2zXTqH2E1F+uYlFTrYibxHKqPAHobpd8Kfg49cEHmuHebOidCTDRgqG1suaPFX7oejFQeGE71zWKfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.66.0.tgz", + "integrity": "sha512-xA+neBh1bqkqaS3b48T2UHZnDsTIpb9B0h+TdBzynjF/ymCpYndhfY10RqW0qSKB1HqqQA83mINVhAdwA+mETg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/prettier": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.10.tgz", + "integrity": "sha512-skGHTH1Yb9QvaTC4hWnRTzEYtCpApF0UMBPz+t/0ZPzP8ihefo/btKd+QA7pUE0fEwA1SbS/NmhyEcstdXOIdA==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/rollup": { + "version": "4.66.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.66.0.tgz", + "integrity": "sha512-Onq6/qO4ARhxIs+jYiHE0pYehadLyMECAiGEqQ+0/aWND3+2PmifJIIqBLYtuBODqHTlOUEQFtIVPyCy0Lck7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@napi-rs/lzma-linux-x64-gnu": "1.5.1", + "@rollup/rollup-android-arm-eabi": "4.66.0", + "@rollup/rollup-android-arm64": "4.66.0", + "@rollup/rollup-darwin-arm64": "4.66.0", + "@rollup/rollup-darwin-x64": "4.66.0", + "@rollup/rollup-freebsd-arm64": "4.66.0", + "@rollup/rollup-freebsd-x64": "4.66.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.66.0", + "@rollup/rollup-linux-arm-musleabihf": "4.66.0", + "@rollup/rollup-linux-arm64-gnu": "4.66.0", + "@rollup/rollup-linux-arm64-musl": "4.66.0", + "@rollup/rollup-linux-loong64-gnu": "4.66.0", + "@rollup/rollup-linux-loong64-musl": "4.66.0", + "@rollup/rollup-linux-ppc64-gnu": "4.66.0", + "@rollup/rollup-linux-ppc64-musl": "4.66.0", + "@rollup/rollup-linux-riscv64-gnu": "4.66.0", + "@rollup/rollup-linux-riscv64-musl": "4.66.0", + "@rollup/rollup-linux-s390x-gnu": "4.66.0", + "@rollup/rollup-linux-x64-gnu": "4.66.0", + "@rollup/rollup-linux-x64-musl": "4.66.0", + "@rollup/rollup-openbsd-x64": "4.66.0", + "@rollup/rollup-openharmony-arm64": "4.66.0", + "@rollup/rollup-win32-arm64-msvc": "4.66.0", + "@rollup/rollup-win32-ia32-msvc": "4.66.0", + "@rollup/rollup-win32-x64-gnu": "4.66.0", + "@rollup/rollup-win32-x64-msvc": "4.66.0", + "fsevents": "~2.3.2" + } + } + } +} diff --git a/Hexploration/package.json b/Hexploration/package.json index 41a0a1679e..27ab95a42c 100644 --- a/Hexploration/package.json +++ b/Hexploration/package.json @@ -1,10 +1,20 @@ { - "name": "Hexploration", - "description": "See script.json", + "name": "hexploration-roll20", + "version": "2.0.0", + "description": "Roll20 API Mod that covers hex maps with hexes that are revealed as tokens explore.", + "private": true, + "type": "module", + "scripts": { + "build": "node scripts/build.mjs", + "set-version": "node scripts/bump-version.mjs", + "watch": "node scripts/build.mjs --watch", + "test": "node --test \"tests/*.test.mjs\"", + "format": "prettier --write \"Hexploration.js\" \"rollup.config.js\" \"src/**/*.js\" \"tests/**/*.mjs\" \"*.md\" \"scripts/**/*.mjs\"", + "sync-locales": "node scripts/sync-locales.mjs", + "regenerate-locales": "node scripts/sync-locales.mjs --regenerate" + }, "devDependencies": { - "grunt": "^1.0.1", - "grunt-contrib-concat": "^1.0.1", - "grunt-contrib-jshint": "^1.1.0", - "grunt-string-replace": "^1.3.0" + "prettier": "^3.5.3", + "rollup": "^4.34.8" } } diff --git a/Hexploration/rollup.config.js b/Hexploration/rollup.config.js new file mode 100644 index 0000000000..4c4b446a15 --- /dev/null +++ b/Hexploration/rollup.config.js @@ -0,0 +1,110 @@ +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { format as prettierFormat, resolveConfig } from 'prettier'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = path.dirname(__filename); + +const scriptJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'script.json'), 'utf8')); +const buildTimestamp = new Date().toISOString(); +const scriptName = scriptJson.name; +const scriptFile = scriptJson.script; +const buildVersion = scriptJson.version; + +const banner = [ + '/**', + ' * NOTE: GENERATED FILE - DO NOT EDIT DIRECTLY.', + ' * NOTE: Source files live under src/ and are bundled with `npm run build`.', + ' * ------------------------------------------------', + ` * Name: ${scriptName}`, + ` * Script: ${scriptFile}`, + ` * Version: ${buildVersion}`, + ` * Built: ${buildTimestamp}`, + ' */', +].join('\n'); + +/** + * Formats generated JavaScript chunks using the project's .prettierrc.json config. + * + * @returns {import("rollup").Plugin} Rollup output plugin. + */ +function formatOutputPlugin() { + return { + name: 'format-output', + /** + * Formats each emitted chunk with Prettier, resolving options from + * .prettierrc.json so the config file is the single source of truth. + * + * @param {import("rollup").NormalizedOutputOptions} options Finalized output options. + * @param {import("rollup").OutputBundle} bundle Emitted output bundle. + * @returns {Promise} + */ + async generateBundle(options, bundle) { + for (const output of Object.values(bundle)) { + if (output.type !== 'chunk') { + continue; + } + + const fileConfig = (await resolveConfig(options.file)) ?? {}; + output.code = await prettierFormat(output.code, { + ...fileConfig, + parser: 'babel', + }); + } + }, + }; +} + +// The IIFE binding is named HexplorationMod so the public API can be published +// as globalThis.Hexploration without a lexical name clash. +const iifeName = scriptName.replace(/[^a-zA-Z0-9]/g, '') + 'Mod'; + +/** @type {import("rollup").RollupOptions} */ +export default { + input: path.join(__dirname, 'src', 'index.js'), + plugins: [ + { + name: 'inject-build-metadata', + /** + * Replaces metadata placeholders in constants.js with build-time values. + * + * @param {string} code Module source code. + * @param {string} id Absolute module id. + * @returns {{code: string, map: null} | null} + */ + transform(code, id) { + if (!id.endsWith(path.join('src', 'constants.js'))) { + return null; + } + + return { + code: code + .replaceAll('__SCRIPT_NAME__', scriptName) + .replaceAll('__SCRIPT_FILE__', scriptFile) + .replaceAll('__BUILD_VERSION__', buildVersion) + .replaceAll('__BUILD_DATE__', buildTimestamp), + map: null, + }; + }, + }, + ], + output: [ + { + file: path.join(__dirname, scriptFile), + format: 'es', + banner, + intro: `const ${iifeName} = (() => {\n 'use strict';`, + outro: '})();', + plugins: [formatOutputPlugin()], + }, + { + file: path.join(__dirname, buildVersion, scriptFile), + format: 'es', + banner, + intro: `const ${iifeName} = (() => {\n 'use strict';`, + outro: '})();', + plugins: [formatOutputPlugin()], + }, + ], +}; diff --git a/Hexploration/scripts/build.mjs b/Hexploration/scripts/build.mjs new file mode 100644 index 0000000000..dc4dd586f4 --- /dev/null +++ b/Hexploration/scripts/build.mjs @@ -0,0 +1,82 @@ +/** + * Builds Hexploration.js from src/ using Rollup. + * + * Version bumping is handled here (not via a package.json prebuild hook) so + * that an explicit version can be passed cleanly through npm run build. + * + * Usage: + * npm run build → auto-bump patch version, then build + * npm run build -- 1.1.0 → set version to 1.1.0, then build + * npm run build -- 1.1.0-alpha.1 → enter prerelease cycle, then build + * npm run build -- --watch → watch mode (no version bump) + * npm run build -- --no-bump → build without changing the version + * node scripts/build.mjs → same as npm run build (auto-bump) + * node scripts/build.mjs 1.1.0 → same as npm run build -- 1.1.0 + */ + +import { spawnSync } from 'node:child_process'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import { rollup, watch as rollupWatch } from 'rollup'; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); +const rootDir = path.join(__dirname, '..'); + +const isWatch = process.argv.includes('--watch'); +const noBump = process.argv.includes('--no-bump'); +// Pick the first argument that doesn't start with '--' as an explicit version. +const versionArg = process.argv.slice(2).find((a) => !a.startsWith('--')); + +async function loadRollupConfig() { + // Load config lazily after any version bump and bypass ESM cache so + // rollup.config.js re-reads script.json with the latest version. + const configPath = path.join(rootDir, 'rollup.config.js'); + const configUrl = pathToFileURL(configPath); + configUrl.searchParams.set('t', Date.now().toString()); + const mod = await import(configUrl.href); + return mod.default; +} + +// Bump (or set) the version before every non-watch, non-no-bump build. +if (!isWatch && !noBump) { + const bumpArgs = versionArg ? [versionArg] : []; + const result = spawnSync(process.execPath, ['scripts/bump-version.mjs', ...bumpArgs], { + cwd: rootDir, + stdio: 'inherit', + }); + if (result.status !== 0) { + process.exit(result.status ?? 1); + } +} + +async function build() { + const config = await loadRollupConfig(); + const bundle = await rollup(config); + for (const output of config.output) { + await bundle.write(output); + console.log(`Built: ${path.relative(rootDir, output.file)}`); + } + await bundle.close(); +} + +if (isWatch) { + const config = await loadRollupConfig(); + const watcher = rollupWatch(config.output.map((output) => ({ ...config, output }))); + + watcher.on('event', (event) => { + if (event.code === 'BUNDLE_END') { + console.log(`Rebuilt at ${new Date().toLocaleTimeString()}`); + event.result?.close(); + } + if (event.code === 'ERROR') { + console.error('Build error:', event.error.message); + } + }); + + console.log('Watching for changes...'); +} else { + build().catch((err) => { + console.error('Build failed:', err.message); + process.exit(1); + }); +} diff --git a/Hexploration/scripts/bump-version.mjs b/Hexploration/scripts/bump-version.mjs new file mode 100644 index 0000000000..be579509f7 --- /dev/null +++ b/Hexploration/scripts/bump-version.mjs @@ -0,0 +1,83 @@ +/** + * Increments the version in script.json and package.json. + * + * Auto-bump behaviour (no argument): + * - Stable release (e.g. 1.0.0) → increments patch: 1.0.1 + * - Prerelease with number → increments prerelease: 1.0.0-alpha.3 → 1.0.0-alpha.4 + * - Prerelease without number → adds .1: 1.0.0-alpha → 1.0.0-alpha.1 + * + * Explicit version (node scripts/bump-version.mjs ): + * - Sets exactly the given version string. + * - Use this to enter a prerelease cycle: node scripts/bump-version.mjs 1.1.0-alpha.1 + * - Use this to cut a release: node scripts/bump-version.mjs 1.1.0 + * + * When building prerelease versions (alpha/beta), always pass an explicit version + * rather than relying on auto-bump — otherwise each `npm run build` will keep + * incrementing the prerelease counter instead of cutting the final release. + * To promote a prerelease to a stable release, set the version explicitly: + * npm run build -- 1.0.0 + */ + +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); +const scriptJsonPath = path.join(__dirname, '..', 'script.json'); +const packageJsonPath = path.join(__dirname, '..', 'package.json'); + +const scriptJson = JSON.parse(fs.readFileSync(scriptJsonPath, 'utf8')); +const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')); + +const explicitVersion = process.argv[2]; +const currentVersion = scriptJson.version; +let nextVersion; + +if (explicitVersion) { + nextVersion = explicitVersion; +} else { + const current = currentVersion; + const dashIdx = current.indexOf('-'); + + if (dashIdx === -1) { + // Stable: 1.0.0 → 1.0.1 + const [major, minor, patch] = current.split('.').map(Number); + if (!Number.isFinite(patch)) { + console.error( + `ERROR: Cannot auto-bump malformed version "${current}". Use an explicit version.` + ); + process.exit(1); + } + nextVersion = `${major}.${minor}.${patch + 1}`; + } else { + // Prerelease: 1.0.0-alpha.3 → 1.0.0-alpha.4 / 1.0.0-alpha → 1.0.0-alpha.1 + const semver = current.slice(0, dashIdx); + const prerelease = current.slice(dashIdx + 1); + const trailingNumber = prerelease.match(/^(.*?)(\d+)$/); + if (trailingNumber) { + nextVersion = `${semver}-${trailingNumber[1]}${Number(trailingNumber[2]) + 1}`; + } else { + nextVersion = `${semver}-${prerelease}.1`; + } + } +} + +const isPrerelease = (version) => version.includes('-'); + +// Append current stable version to history only when the version actually +// changes (oldest-first, matching Roll20 corpus convention), deduplicate, then +// keep the last 5. Prerelease versions are intentionally skipped. +const historySeed = (scriptJson.previousversions || []).filter((v) => !isPrerelease(v)); +const shouldAppendCurrentStable = !isPrerelease(currentVersion) && currentVersion !== nextVersion; +const nextHistory = shouldAppendCurrentStable + ? [...new Set([...historySeed, currentVersion])].slice(-5) + : [...new Set(historySeed)].slice(-5); + +scriptJson.previousversions = nextHistory; +scriptJson.version = nextVersion; +packageJson.version = nextVersion; + +fs.writeFileSync(scriptJsonPath, JSON.stringify(scriptJson, null, 2) + '\n'); +fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n'); + +console.log(`Version set to ${nextVersion}`); diff --git a/Hexploration/scripts/sync-locales.mjs b/Hexploration/scripts/sync-locales.mjs new file mode 100644 index 0000000000..1176b2aad6 --- /dev/null +++ b/Hexploration/scripts/sync-locales.mjs @@ -0,0 +1,724 @@ +import console from 'node:console'; +import { readdirSync, statSync, writeFileSync } from 'node:fs'; +import https from 'node:https'; +import { dirname, resolve } from 'node:path'; +import process from 'node:process'; +import { createInterface } from 'node:readline/promises'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import prettier from 'prettier'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); +const LOCALE_DIR = resolve(__dirname, '../src/locales/locale'); +const SOURCE_LOCALE = 'en-US'; +const GOOGLE_TRANSLATE_HOST = 'translate.googleapis.com'; +const GOOGLE_TRANSLATE_PATH = '/translate_a/single?client=gtx'; + +/** + * @typedef {{ timeoutMs: number, maxRetries: number, retryDelayMs: number, interRequestDelayMs: number }} TranslateConfig + */ + +/** @type {TranslateConfig} */ +const SYNC_CONFIG = { + timeoutMs: 30000, + maxRetries: 2, + retryDelayMs: 8000, + interRequestDelayMs: 2000, +}; + +/** @type {TranslateConfig} */ +const REGENERATE_CONFIG = { + timeoutMs: 60000, + maxRetries: 4, + retryDelayMs: 10000, + interRequestDelayMs: 3000, +}; + +const PLACEHOLDER_PATTERN = /(\{[^{}]+\}|<[^&]+>|--[a-zA-Z0-9_-]+)/g; + +/** + * Loads a locale module from disk and returns its translation object. + * + * @param {string} localeCode Locale code to load from `src/locales/locale`. + * @returns {Promise>} Parsed translation object exported by the locale module. + */ +async function loadLocale(localeCode) { + const filePath = resolve(LOCALE_DIR, `${localeCode}.js`); + const moduleUrl = pathToFileURL(filePath).href; + const loaded = await import(moduleUrl); + return loaded.default; +} + +/** + * Replaces templated tokens with stable placeholders before translation. + * + * @param {string} text Source string that may include placeholders like `{name}`. + * @returns {{ masked: string, placeholders: string[] }} Masked string and placeholder list for later restoration. + */ +function maskPlaceholders(text) { + const placeholders = []; + const masked = text.replaceAll(PLACEHOLDER_PATTERN, (match) => { + const token = `__HEX_PLACEHOLDER_${placeholders.length}__`; + placeholders.push(match); + return token; + }); + return { masked, placeholders }; +} + +/** + * Restores templated tokens after translation has completed. + * + * @param {string} text Translated string containing placeholder tokens. + * @param {string[]} placeholders Original placeholders captured before translation. + * @returns {string} Restored string with original placeholders reinserted. + */ +function unmaskPlaceholders(text, placeholders) { + return placeholders.reduce( + (restored, placeholder, index) => + restored + .replaceAll(`__HEX_PLACEHOLDER_${index}__`, placeholder) + .replaceAll(`__HEX_PLACEHOLDER_${index}__`, placeholder), + text + ); +} + +/** + * Fetches translated payload JSON from Google Translate. + * + * @param {string} pathnameWithQuery Request path and query string for the fixed translate host. + * @param {number} timeoutMs Request timeout in milliseconds. + * @returns {Promise} Parsed JSON payload from the translate endpoint. + */ +function fetchTranslatePayload(pathnameWithQuery, timeoutMs) { + return new Promise((resolvePayload, rejectPayload) => { + const request = https.request( + { + hostname: GOOGLE_TRANSLATE_HOST, + method: 'GET', + path: pathnameWithQuery, + }, + (response) => { + const statusCode = response.statusCode ?? 0; + let body = ''; + response.setEncoding('utf8'); + response.on('data', (chunk) => { + body += chunk; + }); + response.on('end', () => { + if (statusCode < 200 || statusCode >= 300) { + rejectPayload(new Error(`HTTP ${statusCode}`)); + return; + } + try { + resolvePayload(JSON.parse(body)); + } catch (error) { + rejectPayload(error); + } + }); + } + ); + + request.setTimeout(timeoutMs, () => { + request.destroy(new Error('Request timed out')); + }); + request.on('error', (error) => rejectPayload(error)); + request.end(); + }); +} + +/** + * Translates a single English string into a target locale with retry logic. + * + * @param {string} text English source text to translate. + * @param {string} targetLocale Destination locale code. + * @param {Map} cache In-memory cache for locale/text translation results. + * @param {TranslateConfig} config Translation configuration. + * @param {number} [attempt=0] Current retry attempt number. + * @returns {Promise} Translated string (or original text if all retries fail). + */ +async function translateSingle(text, targetLocale, cache, config, attempt = 0) { + if (!text.trim()) { + return text; + } + + const cacheKey = `${targetLocale}::${text}`; + if (cache.has(cacheKey)) { + return cache.get(cacheKey); + } + + const { masked, placeholders } = maskPlaceholders(text); + const query = `&sl=en&tl=${encodeURIComponent(targetLocale)}&dt=t&q=${encodeURIComponent(masked)}`; + const requestPath = `${GOOGLE_TRANSLATE_PATH}${query}`; + + // Add inter-request delay to avoid rate limiting. + await new Promise((resolve) => setTimeout(resolve, config.interRequestDelayMs)); + + try { + const payload = await fetchTranslatePayload(requestPath, config.timeoutMs); + const translatedMasked = Array.isArray(payload?.[0]) + ? payload[0].map((part) => part?.[0] || '').join('') + : text; + + const translated = unmaskPlaceholders(translatedMasked, placeholders); + cache.set(cacheKey, translated); + return translated; + } catch (error) { + if (attempt < config.maxRetries && error.message.includes('timed out')) { + const delayMs = config.retryDelayMs * Math.pow(2, attempt); + await new Promise((resolve) => setTimeout(resolve, delayMs)); + return translateSingle(text, targetLocale, cache, config, attempt + 1); + } + + if (attempt === config.maxRetries) { + console.error( + `[sync-locales] Translation failed for ${targetLocale} after ${config.maxRetries} retries: ${error.message}` + ); + } + cache.set(cacheKey, text); + return text; + } +} + +/** + * Creates a mutable translation placeholder that is finalized later. + * + * @param {string} sourceValue English source value that needs translation. + * @param {Array<{ set: (value: string) => void, text: string }>} translationTasks Task list used to backfill translated values. + * @returns {{ readonly value: string }} Deferred wrapper whose `value` is set after translation tasks complete. + */ +function createDeferredTranslation(sourceValue, translationTasks) { + let translatedValue = sourceValue; + translationTasks.push({ + text: sourceValue, + set: (value) => { + translatedValue = value; + }, + }); + return { + get value() { + return translatedValue; + }, + }; +} + +/** + * Counts the number of strings that need translation in a locale. + * + * @param {unknown} sourceValue Source locale node from `en-US`. + * @param {unknown} targetValue Target locale node at the same path. + * @param {boolean} [forceRetranslate=false] Whether to count already-translated strings. + * @returns {number} Count of strings needing translation. + */ +function countTranslationNeeds(sourceValue, targetValue, forceRetranslate = false) { + if (typeof sourceValue === 'string') { + return forceRetranslate || typeof targetValue !== 'string' || targetValue === sourceValue + ? 1 + : 0; + } + + if (Array.isArray(sourceValue)) { + const targetArray = Array.isArray(targetValue) ? targetValue : []; + return sourceValue.reduce( + (sum, item, index) => sum + countTranslationNeeds(item, targetArray[index], forceRetranslate), + 0 + ); + } + + if (sourceValue && typeof sourceValue === 'object') { + const targetObj = + targetValue && typeof targetValue === 'object' && !Array.isArray(targetValue) + ? /** @type {Record} */ (targetValue) + : {}; + return Object.keys(/** @type {Record} */ (sourceValue)).reduce( + (sum, key) => + sum + + countTranslationNeeds( + /** @type {Record} */ (sourceValue)[key], + targetObj[key], + forceRetranslate + ), + 0 + ); + } + + return 0; +} + +/** + * Synchronizes array entries recursively against source locale structure. + * + * @param {unknown[]} sourceArray Source array from `en-US`. + * @param {unknown} targetValue Current locale value for the same key path. + * @param {{ missing: number, translated: number }} stats Mutable counters for reporting sync actions. + * @param {Array<{ set: (value: string) => void, text: string }>} translationTasks Deferred translation tasks collected during traversal. + * @param {(sourceValue: unknown, targetValue: unknown, stats: { missing: number, translated: number }, translationTasks: Array<{ set: (value: string) => void, text: string }>) => unknown} syncEntry Recursive sync function used for nested values. + * @returns {unknown[]} Synchronized array preserving source structure. + */ +function syncArray(sourceArray, targetValue, stats, translationTasks, syncEntry) { + const targetArray = Array.isArray(targetValue) ? targetValue : []; + const synced = []; + + for (let index = 0; index < sourceArray.length; index += 1) { + if (index >= targetArray.length) { + stats.missing += 1; + } + + synced.push(syncEntry(sourceArray[index], targetArray[index], stats, translationTasks)); + } + + return synced; +} + +/** + * Synchronizes object keys recursively against the source schema. + * Keys present in the target but absent from the source are pruned (counted in stats.pruned). + * + * @param {Record} sourceObject Source object from `en-US`. + * @param {unknown} targetValue Current locale value for the same object path. + * @param {{ missing: number, translated: number, pruned: number }} stats Mutable counters for reporting sync actions. + * @param {Array<{ set: (value: string) => void, text: string }>} translationTasks Deferred translation tasks collected during traversal. + * @param {(sourceValue: unknown, targetValue: unknown, stats: { missing: number, translated: number, pruned: number }, translationTasks: Array<{ set: (value: string) => void, text: string }>) => unknown} syncEntry Recursive sync function used for nested values. + * @returns {Record} Synchronized object with schema-only keys retained. + */ +function syncObject(sourceObject, targetValue, stats, translationTasks, syncEntry) { + const targetObject = + targetValue && typeof targetValue === 'object' && !Array.isArray(targetValue) + ? /** @type {Record} */ (targetValue) + : {}; + const synced = {}; + + for (const key of Object.keys(sourceObject)) { + if (!(key in targetObject)) { + stats.missing += 1; + } + + synced[key] = syncEntry(sourceObject[key], targetObject[key], stats, translationTasks); + } + + for (const key of Object.keys(targetObject)) { + if (!(key in synced)) { + stats.pruned += 1; + } + } + + return synced; +} + +/** + * Synchronizes a single string value against the English source string. + * + * @param {unknown} sourceValue Source locale value expected to be a string. + * @param {unknown} targetValue Target locale value to compare. + * @param {{ missing: number, translated: number, forceRetranslate: boolean }} stats Mutable counters for reporting sync actions. + * @param {Array<{ set: (value: string) => void, text: string }>} translationTasks Deferred translation tasks collected during traversal. + * @returns {unknown} Existing localized string or deferred translated value wrapper. + */ +function syncStringValue(sourceValue, targetValue, stats, translationTasks) { + if (typeof targetValue !== 'string') { + stats.missing += 1; + stats.translated += 1; + return createDeferredTranslation(sourceValue, translationTasks); + } + + if (stats.forceRetranslate || targetValue === sourceValue) { + stats.translated += 1; + return createDeferredTranslation(sourceValue, translationTasks); + } + + return targetValue; +} + +/** + * Recursively synchronizes any translation node (string, array, object, or primitive). + * + * @param {unknown} sourceValue Source locale node from `en-US`. + * @param {unknown} targetValue Target locale node at the same path. + * @param {{ missing: number, translated: number }} stats Mutable counters for reporting sync actions. + * @param {Array<{ set: (value: string) => void, text: string }>} translationTasks Deferred translation tasks collected during traversal. + * @returns {unknown} Synchronized node value. + */ +function syncValue(sourceValue, targetValue, stats, translationTasks) { + if (typeof sourceValue === 'string') { + return syncStringValue(sourceValue, targetValue, stats, translationTasks); + } + + if (Array.isArray(sourceValue)) { + return syncArray(sourceValue, targetValue, stats, translationTasks, syncValue); + } + + if (sourceValue && typeof sourceValue === 'object') { + return syncObject( + /** @type {Record} */ (sourceValue), + targetValue, + stats, + translationTasks, + syncValue + ); + } + + return targetValue ?? sourceValue; +} + +/** + * Resolves deferred translation placeholders into plain serializable values. + * + * @param {unknown} value Node value that may contain deferred translation wrappers. + * @returns {unknown} Fully materialized value safe for JSON serialization. + */ +function finalizeValue(value) { + if (Array.isArray(value)) { + return value.map((entry) => finalizeValue(entry)); + } + + if (value && typeof value === 'object') { + if ('value' in value && Object.keys(value).length === 1) { + return value.value; + } + + const finalized = {}; + for (const [key, entryValue] of Object.entries(value)) { + finalized[key] = finalizeValue(entryValue); + } + return finalized; + } + + return value; +} + +/** + * Writes a locale translation object to its locale module file and formats it with Prettier. + * + * @param {string} localeCode Locale code for the output file name. + * @param {Record} localeData Synchronized translation data to persist. + * @returns {Promise} Resolves after the file has been written and formatted. + */ +async function writeLocale(localeCode, localeData) { + const filePath = resolve(LOCALE_DIR, `${localeCode}.js`); + const content = `const TRANSLATION = ${JSON.stringify(localeData, null, 2)};\n\nexport default TRANSLATION;\n`; + writeFileSync(filePath, content, 'utf8'); + const formatted = await prettier.format(content, { filepath: filePath }); + writeFileSync(filePath, formatted, 'utf8'); +} + +/** + * Processes translation tasks for a single locale and writes the result to disk. + * + * @param {string} localeCode Locale code to process. + * @param {Record} source Source locale data from `en-US`. + * @param {Record} localeData Current locale data. + * @param {Map} cache In-memory cache for translation results. + * @param {TranslateConfig} config Translation configuration. + * @param {boolean} forceRetranslate Whether to re-translate already-translated strings. + * @returns {Promise} + */ +async function processLocale(localeCode, source, localeData, cache, config, forceRetranslate) { + const stats = { missing: 0, translated: 0, pruned: 0, forceRetranslate }; + const translationTasks = []; + const syncedDraft = syncValue(source, localeData, stats, translationTasks); + + if (translationTasks.length === 0 && stats.pruned === 0) { + console.info(`[sync-locales] ${localeCode}: up to date`); + return; + } + + const uniqueTexts = [...new Set(translationTasks.map((task) => task.text))]; + const translatedByText = new Map(); + + for (const text of uniqueTexts) { + const translated = await translateSingle(text, localeCode, cache, config); + translatedByText.set(text, translated); + } + + for (const task of translationTasks) { + task.set(translatedByText.get(task.text) ?? task.text); + } + + const synced = finalizeValue(syncedDraft); + await writeLocale(localeCode, synced); + + const prunedNote = stats.pruned > 0 ? `, pruned ${stats.pruned}` : ''; + console.info( + `[sync-locales] ${localeCode}: missing ${stats.missing}, translated ${stats.translated}${prunedNote}` + ); +} + +/** + * Synchronizes all non-English locale files against `en-US`. + * Processes locales in order of most strings needing translation first, + * then oldest by last-modified date, so interrupted runs make the most progress. + * + * @param {string} [localeFilter] Optional locale code to limit sync to a single locale. + * @returns {Promise} Resolves after all targeted locale files have been synchronized and written. + */ +export async function syncLocales(localeFilter) { + const files = getLocaleCodes(); + + if (localeFilter === SOURCE_LOCALE) { + console.error( + `[sync-locales] ${SOURCE_LOCALE} is the source locale and cannot be synchronized.` + ); + process.exitCode = 1; + return; + } + + const source = await loadLocale(SOURCE_LOCALE); + let targetLocaleCodes = files.filter((code) => code !== SOURCE_LOCALE); + + if (localeFilter) { + targetLocaleCodes = targetLocaleCodes.filter((code) => code === localeFilter); + if (targetLocaleCodes.length === 0) { + console.error(`[sync-locales] No locale found matching: ${localeFilter}`); + process.exitCode = 1; + return; + } + } + + // Pre-scan all locales to determine priority ordering without making any HTTP requests. + const localeMetadata = await Promise.all( + targetLocaleCodes.map(async (localeCode) => { + const filePath = resolve(LOCALE_DIR, `${localeCode}.js`); + const [localeData, { mtimeMs }] = [await loadLocale(localeCode), statSync(filePath)]; + const needsTranslation = countTranslationNeeds(source, localeData); + return { localeCode, localeData, mtimeMs, needsTranslation }; + }) + ); + + // Sort: most strings needing translation first, then oldest file as tiebreaker. + localeMetadata.sort((a, b) => { + if (b.needsTranslation !== a.needsTranslation) { + return b.needsTranslation - a.needsTranslation; + } + return a.mtimeMs - b.mtimeMs; + }); + + const cache = new Map(); + + for (const { localeCode, localeData } of localeMetadata) { + await processLocale(localeCode, source, localeData, cache, SYNC_CONFIG, false); + } +} + +/** + * Regenerates translations for all (or a specific) locale, re-translating every string + * regardless of whether it already has a translation. Uses longer timeouts. + * + * @param {string} [localeFilter] Optional locale code to limit regeneration to a single locale. + * @returns {Promise} Resolves after all targeted locale files have been regenerated. + */ +export async function regenerateLocales(localeFilter) { + const files = readdirSync(LOCALE_DIR) + .filter((file) => file.endsWith('.js')) + .map((file) => file.replace(/\.js$/u, '')); + + if (localeFilter === SOURCE_LOCALE) { + console.error( + `[sync-locales] ${SOURCE_LOCALE} is the source locale and cannot be regenerated.` + ); + process.exitCode = 1; + return; + } + + const source = await loadLocale(SOURCE_LOCALE); + let targetLocaleCodes = files.filter((code) => code !== SOURCE_LOCALE); + + if (localeFilter) { + targetLocaleCodes = targetLocaleCodes.filter((code) => code === localeFilter); + if (targetLocaleCodes.length === 0) { + console.error(`[sync-locales] No locale found matching: ${localeFilter}`); + process.exitCode = 1; + return; + } + } + + const cache = new Map(); + + for (const localeCode of targetLocaleCodes) { + const localeData = await loadLocale(localeCode); + await processLocale(localeCode, source, localeData, cache, REGENERATE_CONFIG, true); + } +} + +/** + * Parses CLI locale filter for regenerate mode. + * Supports: --locale=, --locale , or a positional locale argument. + * + * @param {string[]} args CLI arguments excluding node and script paths. + * @returns {string | undefined} Parsed locale filter. + */ +function parseLocaleFilter(args) { + const isFlag = (arg) => arg.startsWith('-'); + const localeEq = args.find((arg) => arg.startsWith('--locale='))?.split('=')[1]; + const localeFlagIndex = args.indexOf('--locale'); + const localeNext = + localeFlagIndex !== -1 && args[localeFlagIndex + 1] && !isFlag(args[localeFlagIndex + 1]) + ? args[localeFlagIndex + 1] + : undefined; + const positional = args.find((arg) => arg !== '--regenerate' && !isFlag(arg)); + + const candidates = [localeEq, localeNext, positional].filter( + (value, index, values) => + typeof value === 'string' && value.length > 0 && values.indexOf(value) === index + ); + + if (localeFlagIndex !== -1 && !localeNext && !localeEq) { + console.error('[sync-locales] Missing locale value after --locale.'); + process.exitCode = 1; + return undefined; + } + + if (candidates.length > 1) { + console.error( + `[sync-locales] Conflicting locale values provided: ${candidates.join(', ')}. Use a single locale.` + ); + process.exitCode = 1; + return undefined; + } + + return candidates[0]; +} + +/** + * Collects locale codes from the locale directory (without `.js` extension). + * + * @returns {string[]} Locale codes discovered under `src/locales/locale`. + */ +function getLocaleCodes() { + return readdirSync(LOCALE_DIR) + .filter((file) => file.endsWith('.js')) + .map((file) => file.replace(/\.js$/u, '')); +} + +/** + * Builds a sync timing estimate used for pre-run warnings. + * + * Estimated formula: + * - minimum: 4 minutes × locale count + * - maximum: 7 minutes × locales needing translation + * + * @param {string} [localeFilter] Optional locale code to limit estimate scope. + * @returns {Promise<{ totalLocales: number, localesNeedingTranslation: number, estimatedMinMinutes: number, estimatedMaxMinutes: number } | null>} + */ +async function estimateSyncTiming(localeFilter) { + const files = getLocaleCodes(); + const source = await loadLocale(SOURCE_LOCALE); + let targetLocaleCodes = files.filter((code) => code !== SOURCE_LOCALE); + + if (localeFilter) { + if (localeFilter === SOURCE_LOCALE) { + console.error( + `[sync-locales] ${SOURCE_LOCALE} is the source locale and cannot be synchronized.` + ); + process.exitCode = 1; + return null; + } + + targetLocaleCodes = targetLocaleCodes.filter((code) => code === localeFilter); + if (targetLocaleCodes.length === 0) { + console.error(`[sync-locales] No locale found matching: ${localeFilter}`); + process.exitCode = 1; + return null; + } + } + + const localeMetadata = await Promise.all( + targetLocaleCodes.map(async (localeCode) => { + const localeData = await loadLocale(localeCode); + const needsTranslation = countTranslationNeeds(source, localeData); + return { localeCode, needsTranslation }; + }) + ); + + const localesNeedingTranslation = localeMetadata.filter( + ({ needsTranslation }) => needsTranslation > 0 + ).length; + + return { + totalLocales: targetLocaleCodes.length, + localesNeedingTranslation, + estimatedMinMinutes: targetLocaleCodes.length * 4, + estimatedMaxMinutes: localesNeedingTranslation * 7, + }; +} + +/** + * Prompts the user to confirm whether the run should proceed. + * + * @param {string[]} args CLI arguments excluding node and script paths. + * @param {string} message Prompt message shown before confirmation. + * @returns {Promise} True when user confirms, otherwise false. + */ +async function confirmProceed(args, message) { + if (args.includes('--yes') || args.includes('-y')) { + return true; + } + + if (!process.stdin.isTTY || !process.stdout.isTTY) { + console.warn( + '[sync-locales] Non-interactive terminal detected; proceeding without confirmation.' + ); + return true; + } + + const rl = createInterface({ input: process.stdin, output: process.stdout }); + try { + const answer = await rl.question(`${message}\n[sync-locales] Proceed? (y/N): `); + return ['y', 'yes'].includes(answer.trim().toLowerCase()); + } finally { + rl.close(); + } +} + +/** + * If this module is executed directly, run syncLocales or regenerateLocales based on CLI flags. + * Flags: + * --regenerate Force re-translation of all strings (uses longer timeouts). + * --locale= Limit regeneration to a single locale (only valid with --regenerate). + * --yes / -y Skip the confirmation prompt. + */ +if (process.argv[1] === fileURLToPath(import.meta.url)) { + const args = process.argv.slice(2); + const isRegenerate = args.includes('--regenerate'); + const localeFilter = parseLocaleFilter(args); + + if (process.exitCode) { + process.exit(process.exitCode); + } + + if (isRegenerate) { + const localeCodes = getLocaleCodes().filter((code) => code !== SOURCE_LOCALE); + const targetCount = localeFilter ? 1 : localeCodes.length; + const targetLabel = localeFilter ? `${localeFilter}` : `${targetCount} locales`; + const totalMin = targetCount * 30; + const totalMax = targetCount * 60; + + const shouldProceed = await confirmProceed( + args, + `[sync-locales] Regenerate mode selected for ${targetLabel}. This can take 30-60 minutes per locale (about ${totalMin}-${totalMax} minutes total).` + ); + + if (!shouldProceed) { + console.info('[sync-locales] Cancelled by user.'); + process.exit(0); + } + } else { + const syncEstimate = await estimateSyncTiming(localeFilter); + if (!syncEstimate) { + process.exit(process.exitCode || 1); + } + const shouldProceed = await confirmProceed( + args, + `[sync-locales] Sync mode selected. This usually takes several minutes. Estimated minimum: about ${syncEstimate.estimatedMinMinutes} minutes (4 × ${syncEstimate.totalLocales} locales). Estimated maximum: about ${syncEstimate.estimatedMaxMinutes} minutes (7 × ${syncEstimate.localesNeedingTranslation} locales needing translation).` + ); + + if (!shouldProceed) { + console.info('[sync-locales] Cancelled by user.'); + process.exit(0); + } + } + + if (isRegenerate) { + await regenerateLocales(localeFilter); + } else { + await syncLocales(localeFilter); + } +} From 72a453ff85a0497065eff2d6c184a149ff04a682 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 02:21:26 +0000 Subject: [PATCH 02/24] feat(Hexploration): Rewrite for Jumpgate and Legacy games Version 1 stopped working in Jumpgate: shapes drawn there are pathv2 objects, which it looked up as Legacy paths, and its hex sizes were measured from the Legacy grid. It also relied on four unsupported helper mods. The rewrite is self-contained and split into ES modules: - Reads and draws both path and pathv2, choosing by the game engine. - Uses exact hex geometry: Legacy keeps v1's spacing so old maps stay aligned; Jumpgate uses the client's regular 70 px hexes and the page grid offset set by the map alignment tool. - Draws hexes on the foreground layer when available, in batches so large fills do not trip the API watchdog. - Reveals along a token's whole route and under large tokens, with line of sight, a glimpse mode and per-hex reveal limits. Only player tokens reveal by default, so GM-moved monsters no longer uncover the map. - Hides player-visible names, bars and auras of tokens under covered hexes, because Roll20 draws them above the foreground layer. - Adds hidden locations, named hexes, reveal and conceal, undo, reset, rescan for copied pages, grid calibration, page overrides and a status card. - Restricts every command to GMs, escapes chat output, and keeps the v1 commands and migrates v1 state. - Adds Help and Command Deck handouts and 24 languages. Locales not yet translated fall back to English. Signed-off-by: Steve Roberts --- Hexploration/src/Chat.js | 280 ++++++- Hexploration/src/HexagonTile.js | 393 --------- Hexploration/src/Locations.js | 264 ++++-- Hexploration/src/Menus.js | 245 ------ Hexploration/src/State.js | 819 ++++++++++++++----- Hexploration/src/commands.js | 983 +++++++++++++++++++++++ Hexploration/src/constants.js | 138 ++++ Hexploration/src/context.js | 42 + Hexploration/src/cover.js | 145 ++++ Hexploration/src/grid.js | 529 ++++++++++++ Hexploration/src/hexes.js | 545 +++++++++++++ Hexploration/src/i18n.js | 123 +++ Hexploration/src/index.js | 222 ++++- Hexploration/src/journals.js | 225 ++++++ Hexploration/src/locales/index.js | 61 ++ Hexploration/src/locales/locale/af.js | 374 +++++++++ Hexploration/src/locales/locale/ca.js | 380 +++++++++ Hexploration/src/locales/locale/cs.js | 379 +++++++++ Hexploration/src/locales/locale/da.js | 377 +++++++++ Hexploration/src/locales/locale/de.js | 1 + Hexploration/src/locales/locale/el.js | 1 + Hexploration/src/locales/locale/en-US.js | 366 +++++++++ Hexploration/src/locales/locale/es.js | 1 + Hexploration/src/locales/locale/fi.js | 1 + Hexploration/src/locales/locale/fr.js | 1 + Hexploration/src/locales/locale/he.js | 1 + Hexploration/src/locales/locale/hu.js | 1 + Hexploration/src/locales/locale/it.js | 1 + Hexploration/src/locales/locale/ja.js | 1 + Hexploration/src/locales/locale/ko.js | 1 + Hexploration/src/locales/locale/nl.js | 1 + Hexploration/src/locales/locale/pl.js | 1 + Hexploration/src/locales/locale/pt-BR.js | 1 + Hexploration/src/locales/locale/pt-PT.js | 1 + Hexploration/src/locales/locale/ru.js | 1 + Hexploration/src/locales/locale/sv.js | 1 + Hexploration/src/locales/locale/tr.js | 1 + Hexploration/src/locales/locale/uk.js | 1 + Hexploration/src/locales/locale/zh-TW.js | 363 +++++++++ Hexploration/src/locales/metadata.js | 245 ++++++ Hexploration/src/main.js | 342 -------- Hexploration/src/paths.js | 210 +++++ Hexploration/src/polygon.js | 366 +++++++++ Hexploration/src/reveal.js | 332 ++++++++ Hexploration/src/utils.js | 222 +++++ 45 files changed, 7705 insertions(+), 1283 deletions(-) delete mode 100644 Hexploration/src/HexagonTile.js delete mode 100644 Hexploration/src/Menus.js create mode 100644 Hexploration/src/commands.js create mode 100644 Hexploration/src/constants.js create mode 100644 Hexploration/src/context.js create mode 100644 Hexploration/src/cover.js create mode 100644 Hexploration/src/grid.js create mode 100644 Hexploration/src/hexes.js create mode 100644 Hexploration/src/i18n.js create mode 100644 Hexploration/src/journals.js create mode 100644 Hexploration/src/locales/index.js create mode 100644 Hexploration/src/locales/locale/af.js create mode 100644 Hexploration/src/locales/locale/ca.js create mode 100644 Hexploration/src/locales/locale/cs.js create mode 100644 Hexploration/src/locales/locale/da.js create mode 100644 Hexploration/src/locales/locale/de.js create mode 100644 Hexploration/src/locales/locale/el.js create mode 100644 Hexploration/src/locales/locale/en-US.js create mode 100644 Hexploration/src/locales/locale/es.js create mode 100644 Hexploration/src/locales/locale/fi.js create mode 100644 Hexploration/src/locales/locale/fr.js create mode 100644 Hexploration/src/locales/locale/he.js create mode 100644 Hexploration/src/locales/locale/hu.js create mode 100644 Hexploration/src/locales/locale/it.js create mode 100644 Hexploration/src/locales/locale/ja.js create mode 100644 Hexploration/src/locales/locale/ko.js create mode 100644 Hexploration/src/locales/locale/nl.js create mode 100644 Hexploration/src/locales/locale/pl.js create mode 100644 Hexploration/src/locales/locale/pt-BR.js create mode 100644 Hexploration/src/locales/locale/pt-PT.js create mode 100644 Hexploration/src/locales/locale/ru.js create mode 100644 Hexploration/src/locales/locale/sv.js create mode 100644 Hexploration/src/locales/locale/tr.js create mode 100644 Hexploration/src/locales/locale/uk.js create mode 100644 Hexploration/src/locales/locale/zh-TW.js create mode 100644 Hexploration/src/locales/metadata.js delete mode 100644 Hexploration/src/main.js create mode 100644 Hexploration/src/paths.js create mode 100644 Hexploration/src/polygon.js create mode 100644 Hexploration/src/reveal.js create mode 100644 Hexploration/src/utils.js diff --git a/Hexploration/src/Chat.js b/Hexploration/src/Chat.js index b109af95a2..2100727a6c 100644 --- a/Hexploration/src/Chat.js +++ b/Hexploration/src/Chat.js @@ -1,43 +1,251 @@ -/** - * This module provides the script's interface for broadcasting/whispering - * messages in the chat. - */ -(() => { - 'use strict'; +import { + COLOR_ACCENT, + COLOR_BORDER, + COLOR_BUTTON_BG, + COLOR_BUTTON_TEXT, + COLOR_CARD_BG_BOTTOM, + COLOR_CARD_BG_TOP, + COLOR_ERROR_BG, + COLOR_ERROR_BORDER, + COLOR_ERROR_TEXT, + COLOR_HEADER_BG, + COLOR_HEADER_TEXT, + COLOR_MUTED, + COLOR_TEXT, + COLOR_WARNING_BG, + COLOR_WARNING_BORDER, + COLOR_WARNING_TEXT, + SCRIPT_NAME, +} from './constants.js'; +import { escapeHtml } from './utils.js'; - const CHAT_NAME = 'Hexploration'; +const CHAT_CARD_STYLE = [ + 'width:100%', + 'border-radius:4px', + 'box-shadow:1px 1px 3px rgba(0,0,0,0.4)', + 'text-align:left', + 'margin:2px auto', + `border:1px solid ${COLOR_BORDER}`, + `color:${COLOR_TEXT}`, + `background-image:-webkit-linear-gradient(135deg,${COLOR_CARD_BG_TOP} 0%,${COLOR_CARD_BG_BOTTOM} 100%)`, + `background-color:${COLOR_CARD_BG_BOTTOM}`, + 'overflow:hidden', +].join(';'); - /** - * Displays a message in the chat that is visible to everyone. - * @param {string} msg - */ - function broadcast(msg) { - sendChat(CHAT_NAME, msg); - } +const CHAT_HEADER_STYLE = [ + `background:${COLOR_HEADER_BG}`, + `color:${COLOR_HEADER_TEXT}`, + 'padding:4px 8px', + `border-bottom:2px solid ${COLOR_ACCENT}`, + 'font-variant:small-caps', + 'font-weight:bold', + 'font-size:1.05em', + 'text-align:center', + 'letter-spacing:0.05em', +].join(';'); - /** - * Reports an error. - * @param {Error} err - */ - function error(err) { - whisper('Error: ' + err.message); - log('Hexploration ERROR: ' + err.message); - log(err.stack); - } +const CHAT_CONTENT_STYLE = 'padding:5px 8px;line-height:1.5'; + +const BUTTON_STYLE = [ + `background:${COLOR_BUTTON_BG}`, + `color:${COLOR_BUTTON_TEXT}`, + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', +].join(';'); + +const BUTTON_SECONDARY_STYLE = [ + 'background:#2c4034', + `color:${COLOR_TEXT}`, + 'border:1px solid #4d6b56', + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', +].join(';'); - /** - * Whispers a message to the GM. - * @param {string} msg - */ - function whisper(msg) { - sendChat(CHAT_NAME, `/w gm ${msg}`); +const SECTION_LABEL_STYLE = [ + `color:${COLOR_MUTED}`, + 'font-size:0.8em', + 'text-transform:uppercase', + 'letter-spacing:0.08em', + 'margin-top:4px', + 'margin-bottom:2px', +].join(';'); + +const DIVIDER_STYLE = `border:none;border-top:1px solid ${COLOR_BORDER};margin:4px 0`; + +/** + * Returns the whisper target for a player, falling back to all GMs. + * + * Double quotes are stripped so the name is safe inside /w "name". + * + * @param {string} [playerId] Roll20 player ID. + * @returns {string} Whisper target text. + */ +function whisperTarget(playerId) { + const player = playerId ? getObj('player', playerId) : null; + if (!player) { + return 'gm'; } + return `"${String(player.get('displayname') || playerId).replaceAll('"', '')}"`; +} - _.extend(Hexploration, { - _chat: { - broadcast, - error, - whisper - } +/** + * Sends a styled card whispered to a player, or to every GM when no player is given. + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} title Card header text. + * @param {string|string[]} content HTML body content. + * @returns {void} + */ +export function whisper(playerId, title, content) { + const body = Array.isArray(content) ? content.join('') : content; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${buildCard(title, body)}`, null, { + noarchive: true, }); -})(); +} + +/** + * Sends a styled card to everyone. + * + * @param {string} title Card header text. + * @param {string} body HTML body content. + * @returns {void} + */ +export function broadcast(title, body) { + sendChat(SCRIPT_NAME, buildCard(title, body)); +} + +/** + * Sends a warning whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message Warning text. + * @returns {void} + */ +export function whisperWarning(playerId, message) { + const style = [ + `background:${COLOR_WARNING_BG}`, + `color:${COLOR_WARNING_TEXT}`, + `border:1px solid ${COLOR_WARNING_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const html = `
${escapeHtml(message)}
`; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); +} + +/** + * Sends an error whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message What went wrong. + * @param {string} [hint] How to fix it. + * @returns {void} + */ +export function whisperError(playerId, message, hint) { + const style = [ + `background:${COLOR_ERROR_BG}`, + `color:${COLOR_ERROR_TEXT}`, + `border:1px solid ${COLOR_ERROR_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const hintHtml = hint + ? `
${escapeHtml(hint)}
` + : ''; + const html = `
${escapeHtml(message)}${hintHtml}
`; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); +} + +/** + * Builds a styled chat card. + * + * @param {string} title Header text (escaped). + * @param {string} body Body HTML (trusted). + * @returns {string} HTML string. + */ +export function buildCard(title, body) { + return [ + `
`, + `
${escapeHtml(title)}
`, + `
${body}
`, + '
', + ].join(''); +} + +/** + * Builds a primary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ +export function buildButton(label, command) { + return `${escapeHtml(label)}`; +} + +/** + * Builds a secondary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ +export function buildSecondaryButton(label, command) { + return `${escapeHtml(label)}`; +} + +/** + * Builds a section label. + * + * @param {string} text Label text. + * @returns {string} HTML string. + */ +export function buildSectionLabel(text) { + return `
${escapeHtml(text)}
`; +} + +/** + * Builds a horizontal divider. + * + * @returns {string} HTML string. + */ +export function buildDivider() { + return `
`; +} + +/** + * Builds a label/value row. The value may be trusted HTML (e.g. a button). + * + * @param {string} label Label text (escaped). + * @param {string} valueHtml Value HTML. + * @returns {string} HTML string. + */ +export function buildRow(label, valueHtml) { + return [ + '', + ``, + ``, + '
${escapeHtml(label)}${valueHtml}
', + ].join(''); +} + +/** + * Builds a small colour swatch with its value. + * + * @param {string} color CSS colour. + * @returns {string} HTML string. + */ +export function buildSwatch(color) { + const safe = escapeHtml(color); + return ` ${safe}`; +} diff --git a/Hexploration/src/HexagonTile.js b/Hexploration/src/HexagonTile.js deleted file mode 100644 index af215522eb..0000000000 --- a/Hexploration/src/HexagonTile.js +++ /dev/null @@ -1,393 +0,0 @@ -(() => { - 'use strict'; - - /** - * The number of radians in a circle. - */ - const TAU = Math.PI*2; - - /** - * Distance between two adjacent unit hexes in a vertical hex arrangement. - */ - const UNIT_PIXELS_SIDE_V_DIST = 75.198561984460; - const UNIT_PIXELS_DIAG_V_DIST = 76.799271007752; - const UNIT_PIXELS_DIAG_V_DX = 37.599280992230; - const UNIT_PIXELS_DIAG_V_DY = 66.965827824268; - const UNIT_PIXELS_V_START_X = 75/2; - const UNIT_PIXELS_V_START_Y = 88/2; - - /** - * Distance between two adjacent unit hexes in a horizontal hex arrangement. - */ - const UNIT_PIXELS_SIDE_H_DIST = 79.688789983504; - const UNIT_PIXELS_DIAG_H_DIST = 80.185196764184; - const UNIT_PIXELS_DIAG_H_DX = 69.585127490377; - const UNIT_PIXELS_DIAG_H_DY = 39.844394991752; - const UNIT_PIXELS_H_START_X = 94/2; - const UNIT_PIXELS_H_START_Y = 81/2; - - /** - * A Hexagon sized for a page, with no particular center point. - * This effectively defines a whole grid of hexes and its geometric properties - * rather than just one hex. - */ - class HexagonTile { - - /** - * The x increment between two columns of this kind of tile. - * @type {number} - */ - get dx() { - if(!this._dx) { - if(this.isVertical) - this._dx = UNIT_PIXELS_SIDE_V_DIST; - else - this._dx = UNIT_PIXELS_DIAG_H_DX; - this._dx *= this.scale; - } - return this._dx; - } - - /** - * The y increment between two rows of this kind of tile. - * @type {number} - */ - get dy() { - if(!this._dy) { - if(this.isVertical) - this._dy = UNIT_PIXELS_DIAG_V_DY; - else - this._dy = UNIT_PIXELS_SIDE_H_DIST; - this._dy *= this.scale; - } - return this._dy; - } - - /** - * True if this hex tile is oriented horizontally. - * @type {boolean} - */ - get isHorizontal() { - return !this._isVertical; - } - - /** - * True if this hex tile is oriented vertically. - * @type {boolean} - */ - get isVertical() { - return this._isVertical; - } - - /** - * The page that this tile describes the hex grid for. - * @type {Page} - */ - get page() { - return this._page; - } - - /** - * The radius of the concentric circle whose circumference touches all - * of this hex's vertices. - * @type {number} - */ - get radius() { - if(!this._radius) { - if(this._isVertical) - this._radius = UNIT_PIXELS_V_START_Y; - else - this._radius = UNIT_PIXELS_H_START_X; - this._radius *= this.scale; - } - return this._radius; - } - - /** - * The page's unit scale. - * @type {number} - */ - get scale() { - return this._scale; - } - - /** - * Gets the x offset for the first column of tiles. - * @type {number} - */ - get startX() { - if(!this._startX) { - if(this.isVertical) - this._startX = UNIT_PIXELS_V_START_X; - else - this._startX = UNIT_PIXELS_H_START_X; - this._startX *= this.scale; - } - return this._startX; - } - - /** - * Gets the y offset for the first row of tiles. - */ - get startY() { - if(!this._startY) { - if(this.isVertical) - this._startY = UNIT_PIXELS_V_START_Y; - else - this._startY = UNIT_PIXELS_H_START_Y; - this._startY *= this.scale; - } - return this._startY; - } - - /** - * The vertices for this tile, with the center at the origin. - * @type {vec3[]} - */ - get vertices() { - if(!this._vertices) { - this._vertices = []; - let angle = 0; - if(this.isVertical) - angle = TAU/12; - - // Rotate the radius in 60 degree increments to get all the vertices - // for the hexagon. - let pt0 = [this.radius, 0, 1]; - while(angle < TAU) { - let rotation = MatrixMath.rotate(angle); - let pt = MatrixMath.multiply(rotation, pt0); - this._vertices.push(pt); - angle += TAU/6; - } - } - return this._vertices; - } - - /** - * @param {Page} page - */ - constructor(page) { - let gridType = page.get('grid_type'); - if(gridType !== 'hex' && gridType !== 'hexr') - throw new Error( - `Cannot create HexagonTile for page with grid type ${gridType}.`); - - this._page = page; - this._isVertical = page.get('grid_type') === 'hex'; - this._scale = page.get('snapping_increment'); - } - - /** - * Gets the positions of the hexes surrounding some particular hex. - * @param {int} row - * @param {int} column - * @return {tuple[]} - */ - getAdjacentHexes(row, column) { - if(this.isVertical) { - return [ - [row, column + 1], - [row - 1, (row % 2) === 1 ? column + 1 : column], - [row - 1, (row % 2) === 1 ? column : column - 1], - [row, column - 1], - [row + 1, (row % 2) === 1 ? column + 1 : column], - [row + 1, (row % 2) === 1 ? column : column - 1] - ]; - } - else { - return [ - [(column % 2) === 1 ? row + 1 : row, column - 1], - [(column % 2) === 1 ? row : row - 1, column - 1], - [row-1, column], - [(column % 2) === 1 ? row + 1 : row, column + 1], - [(column % 2) === 1 ? row : row - 1, column + 1], - [row+1, column] - ]; - } - } - - /** - * Gets the X, Y center coordinates for a hex tile at a particular row - * and column. - * @param {int} row - * @param {int} column - * @return {vec2} - */ - getCoordinates(row, column) { - let x = column * this.dx + this.startX; - if(this.isVertical && (row % 2) === 1) - x += this.startX; - - let y = row * this.dy + this.startY; - if(this.isHorizontal && (column % 2) === 1) - y += this.startY; - - return [x, y]; - } - - /** - * Converts row/column coordinates to Qbert style XYZ coordinates. This - * helps to simplify some hex math problems by thinking of the hexes as - * cubes stacked like in Qbert. - * @param {int} row - * @param {int} column - * @return {vec3} - */ - _getCubicCoords(row, column) { - // When arranged on a Qbert plane, the x,y,z coordinates of each cube - // should add up to 0. We'll also assume that Z decreases monotonically - // as the Qbert cubes descend. In a vertical arrangement, - let x, y, z; - if(this.isHorizontal) { - z = -column; - x = Math.floor(column/2) - row; - y = -(x + z); - } - else { - z = -row; - x = Math.floor((row+1)/2) + column; - y = -(x + z); - } - - return [x, y, z]; - } - - /** - * Gets the distance between two hexes. - * @param {vec2} p1 - * @param {vec2} p2 - */ - getDistance(p1, p2) { - let cubic1 = this._getCubicCoords(...p1); - let cubic2 = this._getCubicCoords(...p2); - - let dx = Math.abs(cubic1[0] - cubic2[0]); - let dy = Math.abs(cubic1[1] - cubic2[1]); - let dz = Math.abs(cubic1[2] - cubic2[2]); - return Math.max(dx, dy, dz); - } - - /** - * Produces a PathMath Polygon for this tile located at some row and column. - * @param {int} row - * @param {int} column - * @return {PathMath.Polygon} - */ - getHexagon(row, column) { - let center = this.getCoordinates(row, column); - let translation = MatrixMath.translate(center); - let verts = _.map(this.vertices, v => { - return MatrixMath.multiply(translation, v); - }); - return new PathMath.Polygon(verts); - } - - /** - * Gets the row,column coordinates for the tiles nearby some - * row,column position. - * @param {int} row - * @param {int} column - * @param {uint} distance - * @return {tuple[]} - */ - getNearbyHexes(row, column, distance) { - if(distance === 0) - return []; - - let set = new Set(); - - // Use a queue to explore all adjacent hexes out to the desired distance. - let workQueue = [[row, column, distance]]; - while(workQueue.length > 0) { - let [row, column, distance] = workQueue.shift(); - - // Get the positions of adjacent hexes. - let adjHexes = this.getAdjacentHexes(row, column); - - // Add the adjacent hexes to our set and explore them if they're not - // explored and we still have distance left. - _.each(adjHexes, hex => { - let [nextRow, nextColumn] = hex; - let key = `${nextRow},${nextColumn}`; - if(!set.has(key) && distance > 1) - workQueue.push([nextRow, nextColumn, distance - 1]); - set.add(key); - }); - } - - // Transform the set into a list of tuples. - let list = []; - set.forEach(elem => { - let parts = elem.split(','); - let row = parseInt(parts[0]); - let col = parseInt(parts[1]); - list.push([row, col]); - }); - - // Sort by increasing distance. - list = _.sortBy(list, elem => { - return this.getDistance([row, column], elem); - }); - return list; - } - - /** - * Gets the row and column (rounded down) for some X, Y center coordinates. - * @param {number} x - * @param {number} y - * @return {vec2} - */ - getRowColumn(x, y) { - let column = (x - this.startX)/this.dx; - let row = (y - this.startY)/this.dy; - - if(this.isVertical && (Math.round(row) % 2) === 1) - column -= 0.5; - - if(this.isHorizontal && (Math.round(column) % 2) === 1) - row -= 0.5; - - return [Math.round(row), Math.round(column)]; - } - - /** - * Gets the coordinates for the hexes in between two pairs of hex - * coordinates, not including these two hexes. - * @param {vec2} p1 - * @param {vec2} p2 - * @return {vec2[]} - */ - getTweenHexes(p1, p2) { - let xy1 = this.getCoordinates(...p1); - let xy2 = this.getCoordinates(...p2); - - let u = VecMath.sub(xy2, xy1); - let dist = VecMath.length(u); - let uHat = VecMath.normalize(u); - let scale = UNIT_PIXELS_SIDE_V_DIST*this.scale; - let dxy = VecMath.scale(uHat, scale); - - let curXY = VecMath.add(xy1, dxy); - let curDist = scale; - let result = []; - while(curDist < dist - scale/4) { - let hex = this.getRowColumn(...curXY); - - // Skip if this hex is the start or end hex. - let [row, col] = hex; - if(!((row === p1[0] && col === p1[1]) || - (row === p2[0] && col === p2[1]))) - result.push(hex); - - curXY = VecMath.add(curXY, dxy); - curDist += scale; - } - return result; - } - } - - _.extend(Hexploration, { - HexagonTile - }); -})(); diff --git a/Hexploration/src/Locations.js b/Hexploration/src/Locations.js index 1fb30a3c20..53ea86051c 100644 --- a/Hexploration/src/Locations.js +++ b/Hexploration/src/Locations.js @@ -1,76 +1,216 @@ -(() => { - 'use strict'; +// Named hexes and hidden location tokens. +// +// A hex can carry a name (shown to the GM as a label on the GM layer) and an +// icon (a token hidden on the GM layer). Both are announced when the hex is +// revealed, and the icon is moved back to the token layer. - /** - * Gets the objects representing locations on a page. - * @param {Page} page - * @return {Graphic[]} - */ - function getMarkers(page) { - return findObjs({ - _type: 'graphic', - _pageid: page.get('_id'), - 'status_white-tower': true - }); +import { LAYER_GM, LAYER_TOKEN, LOCATION_MARKER, MAX_NAME_LENGTH } from './constants.js'; +import { hexKey, hexToPixel, pixelToHex } from './grid.js'; +import { + getConfig, + getHex, + getPageHexes, + getPendingLocations, + setPendingLocation, +} from './state.js'; +import { tokenHasMarker, toText } from './utils.js'; + +/** + * Returns the token attached to a hex as its icon, if it still exists. + * + * @param {object} hex Hex record. + * @returns {object|null} Roll20 graphic. + */ +export function getHexIcon(hex) { + return hex.iconId ? getObj('graphic', hex.iconId) || null : null; +} + +/** + * Returns the name announced when a hex is discovered: the icon's name, or + * the hex's own name. + * + * @param {object} hex Hex record. + * @returns {string} Discovery name (empty when the hex is unnamed). + */ +export function getDiscoveryName(hex) { + const icon = getHexIcon(hex); + return toText(icon?.get('name')) || toText(hex.name); +} + +/** + * Removes a hex's GM-layer name label. + * + * @param {object} hex Hex record. + * @returns {void} + */ +export function removeLabel(hex) { + if (hex.nameId) { + getObj('text', hex.nameId)?.remove(); + delete hex.nameId; + } +} + +/** + * Sets or clears a hex's name and redraws its GM-layer label. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record. + * @param {string} name New name (empty to clear). + * @returns {void} + */ +export function setHexName(ctx, hex, name) { + removeLabel(hex); + const clean = toText(name).slice(0, MAX_NAME_LENGTH); + if (!clean) { + delete hex.name; + return; + } + hex.name = clean; + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + const label = createObj('text', { + _pageid: ctx.pageId, + layer: LAYER_GM, + left: x, + top: y, + text: clean, + color: getConfig().labelColor, + }); + if (label) { + hex.nameId = label.get('_id'); } +} - /** - * Sets the icon and name for a hex. - * @param {Path} path - * The path representing the hex. - * @param {Graphic} icon - * The icon containing the graphic and name for the hex when it is - * revealed. - */ - function setHexIcon(path, icon) { - let pageHex = Hexploration._state.getPageHexByPath(path); - if(!pageHex) - throw new Error('Could not find PageHex data for path ' + path.get('_id')); +/** + * Attaches a token to a hex as its hidden icon. + * + * @param {object} hex Hex record. + * @param {object} token Roll20 graphic. + * @returns {string} The token's layer before it was hidden (for undo). + */ +export function attachIcon(hex, token) { + const previousLayer = token.get('layer'); + hex.iconId = token.get('_id'); + token.set('layer', LAYER_GM); + setPendingLocation(hex.iconId, null); + return previousLayer; +} - pageHex.iconId = icon.get('_id'); - icon.set('layer', 'gmlayer'); +/** + * Detaches a hex's icon and returns it to the token layer. + * + * @param {object} hex Hex record. + * @param {boolean} [show=true] Move the icon back to the token layer. + * @returns {void} + */ +export function detachIcon(hex, show = true) { + const icon = getHexIcon(hex); + if (icon && show) { + icon.set('layer', LAYER_TOKEN); } + delete hex.iconId; +} - /** - * Sets the name for a hex, without assigning it an icon. - * @param {Path} path - * The Path representing the hex. - * @param {string} name - */ - function setHexName(path, name) { - let config = Hexploration._state.getConfig(); +/** + * Returns the hex records on a page keyed by the ID of their icon. + * + * @param {string} pageId Page ID. + * @returns {Map} Map of icon ID to hex record. + */ +function hexesByIcon(pageId) { + const map = new Map(); + for (const hex of getPageHexes(pageId)) { + if (hex.iconId) { + map.set(hex.iconId, hex); + } + } + return map; +} - let pageHex = Hexploration._state.getPageHexByPath(path); - if(!pageHex) - throw new Error('Could not find PageHex data for path ' + path.get('_id')); +/** + * Returns location tokens waiting for a hex on a page, keyed by hex cell: + * tokens marked with `mark`, plus (as in v1) tokens with the white-tower + * status marker. Tokens already attached to a hex are ignored. + * + * @param {object} ctx Page context. + * @returns {Map} Map of "row,col" to Roll20 graphic. + */ +export function findLocationTokens(ctx) { + const attached = hexesByIcon(ctx.pageId); + const tokens = new Map(); + const consider = (token) => { + if (!token || attached.has(token.get('_id'))) { + return; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + tokens.set(hexKey(row, col), token); + }; - // Remove the previous name. - if(pageHex.nameId) { - let namePath = getObj('text', pageHex.nameId); - namePath.remove(); - pageHex.nameId = undefined; + for (const tokenId of getPendingLocations(ctx.pageId)) { + const token = getObj('graphic', tokenId); + if (token) { + consider(token); + } else { + setPendingLocation(tokenId, null); + } + } + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId })) { + if (tokenHasMarker(token, LOCATION_MARKER)) { + consider(token); } + } + return tokens; +} - // Set the new name and create a text object for it. - pageHex.name = name; - if(pageHex.name) { - let namePath = createObj('text', { - _pageid: path.get('_pageid'), - layer: 'gmlayer', - left: path.get('left'), - top: path.get('top'), - text: name, - color: config.labelColor - }); - pageHex.nameId = namePath.get('_id'); +/** + * Marks tokens as hidden locations. A token already under a hex is attached + * immediately; otherwise it waits for the next fill that covers it. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {{attached: number, pending: number}} Counts. + */ +export function markLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + let attachedCount = 0; + let pendingCount = 0; + for (const token of tokens) { + if (attached.has(token.get('_id'))) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + attachIcon(hex, token); + attachedCount++; + } else { + setPendingLocation(token.get('_id'), ctx.pageId); + pendingCount++; } } + return { attached: attachedCount, pending: pendingCount }; +} - _.extend(Hexploration, { - _locations: { - getMarkers, - setHexIcon, - setHexName +/** + * Stops tokens being hidden locations. Attached tokens return to the token layer. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number} Number of tokens unmarked. + */ +export function unmarkLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + const pending = new Set(getPendingLocations(ctx.pageId)); + let count = 0; + for (const token of tokens) { + const id = token.get('_id'); + const hex = attached.get(id); + if (hex) { + detachIcon(hex); + count++; + } else if (pending.has(id)) { + setPendingLocation(id, null); + count++; } - }); -})(); + } + return count; +} diff --git a/Hexploration/src/Menus.js b/Hexploration/src/Menus.js deleted file mode 100644 index 12bed82368..0000000000 --- a/Hexploration/src/Menus.js +++ /dev/null @@ -1,245 +0,0 @@ -(() => { - 'use strict'; - - const CMD_MODIFY_CONFIG = '!hexploration_configModifyProperty'; - const CMD_MODIFY_HEX = '!hexploration_hexModifyProperty'; - - const MENU_CSS = { - 'optionsTable': { - 'width': '100%' - }, - 'menu': { - 'background': '#fff', - 'border': 'solid 1px #000', - 'border-radius': '5px', - 'font-weight': 'bold', - 'margin-bottom': '1em', - 'overflow': 'hidden' - }, - 'menuBody': { - 'padding': '5px', - 'text-align': 'center' - }, - 'menuHeader': { - 'background': '#000', - 'color': '#fff', - 'text-align': 'center' - } - }; - - /** - * Get the menu data for the current configuration properties. - */ - function _getConfigProps() { - let config = Hexploration._state.getState().config; - return [ - { - id: 'color', - name: 'Hex Color', - desc: 'The fill and stroke colors for the hexes.', - value: `
Label
`, - properties: [ - { - id: 'fillColor', - name: 'Fill Color', - desc: 'The hex fill color.' - }, - { - id: 'strokeColor', - name: 'Border Color', - desc: 'The hex border color.' - }, - { - id: 'labelColor', - name: 'Label Color', - desc: 'The label color' - } - ] - }, - { - id: 'strokeWidth', - name: 'Border Width', - desc: 'The width of the hexes\' border outlines.', - value: config.strokeWidth || '0' - }, - { - id: 'maxDistance', - name: 'Hex Reveal Distance', - desc: 'Hexes being drawn will only be revealed if you are within this distance, in hex units.', - value: (() => { - if(config.maxDistance >= 0) - return '' + config.maxDistance; - else - return '-'; - })() - }, - { - id: 'revealDistance', - name: 'Line of Sight', - desc: 'When you move, hexes this many units from your position will be revealed.', - value: config.revealDistance || '0' - } - ]; - } - - /** - * Modifies the persisted data for a hex with the given parameters. - * @param {Path} path - * The Path representing the hex. - * @param {string[]} argv - * The first element is the name of the property. - * The rest of the elements are the parameters used to modify it. - */ - function _modifyHex(path, argv) { - let prop = argv[0]; - let params = argv.slice(1); - - if(prop === 'name') { - Hexploration._locations.setHexName(path, params[0]); - } - } - - /** - * Modifies a configuration with the given parameters. - * @param {string[]} argv - * The first element is the name of the configuration property. - * The rest of the elements are the parameters used to modify it. - */ - function _modifyConfig(argv) { - let config = Hexploration._state.getConfig(); - let prop = argv[0]; - let params = argv.slice(1); - - if(prop === 'color') { - config.fillColor = params[0] || 'black'; - config.strokeColor = params[1] || 'transparent'; - config.labelColor = params[2] || 'white'; - } - if(prop === 'strokeWidth') - config.strokeWidth = parseInt(params[0]) || 0; - if(prop === 'maxDistance') { - let value = parseInt(params[0]); - if(value >= 0) - config.maxDistance = value; - else - config.maxDistance = undefined; - } - if(prop === 'revealDistance') - config.revealDistance = parseInt(params[0]) || 0; - - showMain(); - } - - /** - * Displays a stylized announcement in the chat that - */ - function showDiscovery(name, imgsrc) { - let menu = new HtmlBuilder('.menu'); - menu.append('.menuHeader', 'Discovered Location'); - if(imgsrc) - menu.append('.menuBody', `

${name}

`); - else - menu.append('.menuBody', `

${name}

`); - Hexploration._chat.broadcast(menu.toString(MENU_CSS)); - } - - /** - * Shows the script's main menu. - */ - function showMain() { - let content = new HtmlBuilder('div'); - - content.append('h4', 'Configs'); - let configProps = _getConfigProps(); - let table = content.append('table', undefined, { - style: { - 'margin-left': 'auto', - 'margin-right': 'auto' - } - }); - _.each(configProps, prop => { - let tr = table.append('tr', undefined, { - title: prop.desc - }); - - let params = []; - let paramProperties = prop.properties || [prop]; - _.each(paramProperties, item => { - let options = ''; - if(item.options) - options = '|' + item.options.join('|'); - params.push(`?{${item.name}: ${item.desc} ${options}}`); - }); - - tr.append('td', `[${prop.name}](${CMD_MODIFY_CONFIG} ${prop.id}&&${params.join('&&')})`, { - style: { 'font-size': '0.8em' } - }); - - tr.append('td', `${prop.value || ''}`, { - style: { 'font-size': '0.8em' } - }); - }); - - content.append('h4', 'Actions', { - style: { 'margin-top': '1em' } - }); - content.append('div', `[Fill Polygon](${Hexploration.CMD_FILL})`, { - title: 'Fill the selected polygons with hexes.' - }); - content.append('div', `[Inverse Fill](${Hexploration.CMD_FILL_INVERSE})`, { - title: 'Fill the whole page with hexes, except within the selected polygons.' - }); - content.append('div', `[Name Hex](${CMD_MODIFY_HEX} name&&?{Pick name})`, { - title: 'Set a name for a hex. When the hex is revealed, ' + - 'it will declare in the chat that is was discovered.' - }); - - _showMenu('Hexploration Menu', content); - } - - /** - * Displays a stylized menu in the chat, whispered to the GM. - * @param {string} title - * The title displayed in the menu header. - * @param {string} content - * The menu's HTML contents. - */ - function _showMenu(title, content) { - let menu = new HtmlBuilder('.menu'); - menu.append('.menuHeader', title); - menu.append('.menuBody', content); - Hexploration._chat.whisper(menu.toString(MENU_CSS)); - } - - on('chat:message', msg => { - try { - if(msg.type !== 'api') - return; - - let argv = msg.content.split(' '); - if(argv[0] === CMD_MODIFY_CONFIG) { - let params = msg.content.replace(CMD_MODIFY_CONFIG + ' ', '').split('&&'); - _modifyConfig(params); - } - if(argv[0] === CMD_MODIFY_HEX) { - if(msg.selected && msg.selected.length === 1) { - let path = getObj('path', msg.selected[0]._id); - let params = msg.content.replace(CMD_MODIFY_HEX + ' ', '').split('&&'); - _modifyHex(path, params); - } - else - throw new Error('You must select one hex to be named.'); - } - } - catch(err) { - Hexploration._chat.error(err); - } - }); - - _.extend(Hexploration, { - _menus: { - showDiscovery, - showMain - } - }); -})(); diff --git a/Hexploration/src/State.js b/Hexploration/src/State.js index 8374f8795a..9eac115e5c 100644 --- a/Hexploration/src/State.js +++ b/Hexploration/src/State.js @@ -1,221 +1,632 @@ -(() => { - 'use strict'; - - /** - * The global configurations object for this script. - * @typedef {object} HexplorationConfig - * @property {string} fillColor - * The fill color for hexes. - * @property {string} labelColor - * The color for name labels. - * @property {uint} revealDistance - * When a token moves, hexes within this distance are revealed. - * @property {string} strokeColor - * The stroke color for hexes. - * @property {uint} strokeWidth - * The stroke width for hexes. - */ - - /** - * The script's persisted state object. - * @typedef {object} HexplorationState - * @property {map} pageHexes - * A mapping of Page IDs to , pairs to PageHexes - * containing the persisted information about a hex. - * @property {map>} - * A mapping of Path IDs representing hexes to their - * [page ID, ,] keys into pageHexes. - * @property {HexplorationConfig} config - */ - - /** - * Persisted information about a hex. - * @typedef {object} PageHex - * @property {string} id - * The ID of the hex's Path. - * @property {string} [name] - * The name of the hex. If a named hex is revealed, then its - * discovery will be announced in the chat. - * @property {string} [nameId] - * The ID for the Path labelling the named hex on the GM layer. - * @property {number} [maxDistance] - * The maximum distance a character can be away from the hex to - * reveal it. - */ - - /** - * The first element is the hex's page ID. - * The second element is the , string for the hex. - * @typedef {tuple} PageHexKey - */ - - /** - * Deletes the persisted hex at some grid location on some page. - * No effect if a hex doesn't exist at that location. - * @param {(Page|string)} page - * The Page or its ID. - * @param {int} row - * @param {int} column - */ - function deleteHex(page, row, column) { - let oldHex = Hexploration._state.getPageHex(page, row, column); - if(oldHex) { - let hexPath = getObj('path', oldHex.id); - if(hexPath) { - Hexploration._state.deletePath(hexPath); - hexPath.remove(); +import { + ANNOUNCE_OPTIONS, + DEFAULT_CONFIG, + HEX_LAYER_OPTIONS, + MAX_REVEAL_DISTANCE, + MAX_STROKE_WIDTH, + PAGE_SETTING_KEYS, + REVEAL_BY_OPTIONS, + REVEAL_MODE_OPTIONS, + SCHEMA_VERSION, + SCRIPT_VERSION, + STATE_KEY, +} from './constants.js'; +import { parseHexKey } from './grid.js'; +import { normalizeLocale } from './i18n.js'; +import { clamp, isRecord, isValidColor, parseBoolean, parseStrictInt, toText } from './utils.js'; + +// --------------------------------------------------------------------------- +// Config validation (pure) +// --------------------------------------------------------------------------- + +/** + * Validates one configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Result; `value` is the normalised value when valid. + */ +export function validateConfigValue(key, raw) { + const ok = (value) => ({ valid: true, value }); + const bad = { valid: false }; + + switch (key) { + case 'language': { + const lang = normalizeLocale(raw); + return lang ? ok(lang) : bad; + } + case 'hexLayer': + return HEX_LAYER_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealBy': + return REVEAL_BY_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealMode': + return REVEAL_MODE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'announce': + return ANNOUNCE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'fillColor': + case 'strokeColor': + case 'labelColor': + case 'glimpseColor': + return isValidColor(raw) ? ok(toText(raw)) : bad; + case 'strokeWidth': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 ? bad : ok(clamp(n, 0, MAX_STROKE_WIDTH)); + } + case 'revealDistance': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'maxDistance': { + if (raw === null || raw === undefined || ['', '-', 'none', 'off'].includes(toText(raw))) { + return ok(null); + } + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'lineOfSight': + case 'revealPath': + case 'pingDiscoveries': + case 'hideCoveredTokens': { + const b = parseBoolean(raw); + return b === null ? bad : ok(b); + } + default: + return bad; + } +} + +/** + * Merges a possibly incomplete or invalid config with defaults. + * + * @param {object} config Config to merge. + * @param {object} [defaults] Defaults to fall back on. + * @returns {object} Complete config. + */ +export function mergeConfig(config, defaults = DEFAULT_CONFIG) { + const c = isRecord(config) ? config : {}; + const merged = {}; + for (const key of Object.keys(DEFAULT_CONFIG)) { + const result = key in c ? validateConfigValue(key, c[key]) : { valid: false }; + merged[key] = result.valid ? result.value : defaults[key]; + } + return merged; +} + +/** + * Keeps only valid per-page overrides. + * + * @param {object} settings Raw page settings. + * @returns {object} Clean page settings. + */ +function mergePageSettings(settings) { + const clean = {}; + if (!isRecord(settings)) { + return clean; + } + for (const key of PAGE_SETTING_KEYS) { + if (key in settings) { + const result = validateConfigValue(key, settings[key]); + if (result.valid) { + clean[key] = result.value; + } + } + } + return clean; +} + +// --------------------------------------------------------------------------- +// State shape and migration (pure) +// --------------------------------------------------------------------------- + +/** + * Creates an empty v2 state object. + * + * @returns {object} Fresh state. + */ +export function createDefaultState() { + return { + schemaVersion: SCHEMA_VERSION, + version: SCRIPT_VERSION, + config: { ...DEFAULT_CONFIG }, + pages: {}, + pendingLocations: {}, + lastFill: null, + coveredTokens: {}, + notices: {}, + }; +} + +/** + * Normalises one stored hex record. + * + * @param {string} key "row,col" key. + * @param {object} raw Stored record. + * @returns {object|null} Clean hex record, or null when unusable. + */ +function normaliseHex(key, raw) { + const coords = parseHexKey(key); + if (!coords || !isRecord(raw) || !toText(raw.id)) { + return null; + } + const hex = { + id: toText(raw.id), + type: raw.type === 'pathv2' ? 'pathv2' : raw.type === 'path' ? 'path' : null, + row: coords[0], + col: coords[1], + }; + if (toText(raw.name)) { + hex.name = toText(raw.name); + } + if (toText(raw.nameId)) { + hex.nameId = toText(raw.nameId); + } + if (toText(raw.iconId)) { + hex.iconId = toText(raw.iconId); + } + const maxDistance = validateConfigValue('maxDistance', raw.maxDistance); + if (maxDistance.valid && maxDistance.value !== null) { + hex.maxDistance = maxDistance.value; + } + if (raw.glimpsed === true) { + hex.glimpsed = true; + } + return hex; +} + +/** + * Normalises a page's stored data. + * + * @param {object} raw Stored page data. + * @returns {object} Clean page data. + */ +function normalisePage(raw) { + const page = { hexes: {}, settings: {}, calibration: null }; + if (!isRecord(raw)) { + return page; + } + if (isRecord(raw.hexes)) { + for (const [key, value] of Object.entries(raw.hexes)) { + const hex = normaliseHex(key, value); + if (hex) { + page.hexes[`${hex.row},${hex.col}`] = hex; } } } + page.settings = mergePageSettings(raw.settings); + if (isRecord(raw.calibration)) { + const cal = {}; + for (const k of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(raw.calibration[k])) { + cal[k] = raw.calibration[k]; + } + } + page.calibration = Object.keys(cal).length === 4 ? cal : null; + } + return page; +} - /** - * Remove the hex data about some path from the state. - * @param {Path} path - */ - function deletePath(path) { - let myState = getState(); - let id = path.get('_id'); - let key = getPageHexKey(path); - if(key) { - let [pageId, rowColumn] = key; - let pageHex = myState.pageHexes[pageId][rowColumn]; - - if(pageHex) { - // If the hex was named, delete the label for its name. - if(pageHex.nameId) { - let namePath = getObj('text', pageHex.nameId); - namePath.remove(); - } +/** + * Converts any stored state (v1, v2 or damaged) into a clean v2 state. + * + * v1 stored hexes in `pageHexes[pageId]["row,col"]` with a parallel `hexIdMap`, + * and a flat config. Its defaults differed (no reveal distance), so missing + * v1 values fall back to v1 behaviour rather than the new defaults. + * + * @param {*} raw Stored state. + * @returns {{state: object, migratedFrom: number|null}} Clean state and the + * schema it was migrated from (null when no migration was needed). + */ +export function migrateState(raw) { + const fresh = createDefaultState(); + if (!isRecord(raw)) { + return { state: fresh, migratedFrom: null }; + } + + if (isRecord(raw.pageHexes) && !isRecord(raw.pages)) { + const v1Defaults = { ...DEFAULT_CONFIG, revealDistance: 0, strokeWidth: 0 }; + fresh.config = mergeConfig(raw.config, v1Defaults); + for (const [pageId, hexes] of Object.entries(raw.pageHexes)) { + const page = normalisePage({ hexes }); + if (Object.keys(page.hexes).length > 0) { + fresh.pages[pageId] = page; } + } + return { state: fresh, migratedFrom: 1 }; + } - delete myState.pageHexes[pageId][rowColumn]; - delete myState.hexIdMap[id]; + fresh.config = mergeConfig(raw.config); + if (isRecord(raw.pages)) { + for (const [pageId, page] of Object.entries(raw.pages)) { + fresh.pages[pageId] = normalisePage(page); + } + } + if (isRecord(raw.pendingLocations)) { + for (const [tokenId, pageId] of Object.entries(raw.pendingLocations)) { + if (toText(pageId)) { + fresh.pendingLocations[tokenId] = toText(pageId); + } + } + } + if (isRecord(raw.lastFill)) { + fresh.lastFill = raw.lastFill; + } + if (isRecord(raw.coveredTokens)) { + for (const [tokenId, entry] of Object.entries(raw.coveredTokens)) { + if (isRecord(entry) && toText(entry.pageId) && isRecord(entry.saved)) { + fresh.coveredTokens[tokenId] = { pageId: toText(entry.pageId), saved: { ...entry.saved } }; + } } } + if (isRecord(raw.notices)) { + fresh.notices = { ...raw.notices }; + } + return { state: fresh, migratedFrom: null }; +} + +// --------------------------------------------------------------------------- +// Persistent state access (Roll20) +// --------------------------------------------------------------------------- + +let pathIndex = null; +let lastMigration = null; - /** - * Returns the configs object. - * @return {HexplorationConfig} - */ - function getConfig() { - return getState().config; +/** + * Loads, migrates and validates the persistent state. Call once on ready. + * + * @returns {number|null} The schema migrated from, or null. + */ +export function initialiseState() { + const { state: clean, migratedFrom } = migrateState(state[STATE_KEY]); + clean.version = SCRIPT_VERSION; + state[STATE_KEY] = clean; + pathIndex = null; + lastMigration = migratedFrom; + return migratedFrom; +} + +/** + * Returns the schema version the state was migrated from on startup. + * + * @returns {number|null} Schema version, or null when no migration ran. + */ +export function getLastMigration() { + return lastMigration; +} + +/** + * Returns the persistent state, creating it when missing. + * + * @returns {object} State branch. + */ +export function getState() { + if (!isRecord(state[STATE_KEY]) || state[STATE_KEY].schemaVersion !== SCHEMA_VERSION) { + initialiseState(); } + return state[STATE_KEY]; +} - /** - * Gets the persisted state for this script. - * @return {HexplorationState} - */ - function getState() { - if(!state.Hexploration) { - state.Hexploration = { - // Persists hexes by their Page ID, then by their ,. - pageHexes: {}, +/** + * Returns the global configuration. + * + * @returns {object} Config. + */ +export function getConfig() { + return getState().config; +} - // Maps hex Path IDs to their keys in pageHexes. - hexIdMap: {} - }; +/** + * Sets one global configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ +export function setConfigValue(key, raw) { + if (!(key in DEFAULT_CONFIG)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getState().config[key] = result.value; + } + return result; +} + +/** + * Imports Roll20 One-Click useroptions into the persisted config. + * + * @returns {void} + */ +export function applyGlobalConfig() { + if (typeof globalconfig === 'undefined' || !isRecord(globalconfig)) { + return; + } + const branch = globalconfig[STATE_KEY.toLowerCase()] || globalconfig[STATE_KEY]; + if (!isRecord(branch)) { + return; + } + const options = isRecord(branch.useroptions) ? branch.useroptions : branch; + const s = getState(); + // useroptions only change when the GM edits them, so remember what was last + // applied and only re-apply on change; otherwise chat changes would be + // overwritten on every restart. + const applied = isRecord(s.notices.useroptions) ? s.notices.useroptions : {}; + for (const key of ['hexLayer', 'revealBy', 'language']) { + if (key in options && options[key] !== applied[key]) { + setConfigValue(key, options[key]); + applied[key] = options[key]; } - _.defaults(state.Hexploration, { - config: {} - }); - _.defaults(state.Hexploration.config, { - fillColor: '#FFFF88', - labelColor: '#333333', - strokeColor: '#DDDD88', - strokeWidth: 0, - revealDistance: 0 - }); - return state.Hexploration; - } - - /** - * Gets the hex data at some grid location on some page. If the hex data - * couldn't be found, undefined is returned. - * @param {(Page|string)} page - * The Page or its ID. - * @param {int} row - * @param {int} column - * @return {PageHex} - */ - function getPageHex(page, row, column) { - let myState = getState(); - - let pageId = page; - if(!_.isString(page)) - pageId = page.get('_id'); - - let pageHexes = myState.pageHexes[pageId]; - if(pageHexes) { - let key = row + "," + column; - return pageHexes[key]; + } + s.notices.useroptions = applied; +} + +/** + * Returns a page's stored data. + * + * @param {string} pageId Page ID. + * @param {boolean} [create=false] Create the record when missing. + * @returns {object|null} Page data. + */ +export function getPageData(pageId, create = false) { + const s = getState(); + if (!s.pages[pageId] && create) { + s.pages[pageId] = { hexes: {}, settings: {}, calibration: null }; + } + return s.pages[pageId] || null; +} + +/** + * Returns the IDs of every page with stored data. + * + * @returns {string[]} Page IDs. + */ +export function getPageIds() { + return Object.keys(getState().pages); +} + +/** + * Removes a page's stored data entirely. + * + * @param {string} pageId Page ID. + * @returns {void} + */ +export function deletePageData(pageId) { + const s = getState(); + const page = s.pages[pageId]; + if (page && pathIndex) { + for (const hex of Object.values(page.hexes)) { + pathIndex.delete(hex.id); } } + delete s.pages[pageId]; +} + +/** + * Returns the settings in force on a page: global config plus page overrides. + * + * @param {string} pageId Page ID. + * @returns {object} Effective settings. + */ +export function getPageSettings(pageId) { + const page = getPageData(pageId); + return { ...getConfig(), ...(page ? page.settings : {}) }; +} + +/** + * Sets a per-page override. + * + * @param {string} pageId Page ID. + * @param {string} key Setting key (must be in PAGE_SETTING_KEYS). + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ +export function setPageSetting(pageId, key, raw) { + if (!PAGE_SETTING_KEYS.includes(key)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getPageData(pageId, true).settings[key] = result.value; + } + return result; +} + +/** + * Clears all per-page overrides. + * + * @param {string} pageId Page ID. + * @returns {void} + */ +export function clearPageSettings(pageId) { + const page = getPageData(pageId); + if (page) { + page.settings = {}; + } +} - /** - * Gets the PageHex object for the hexes represented by the given Path. - * @param {Path} path - * @return {PageHex} - */ - function getPageHexByPath(path) { - let [pageId, rowColumnKey] = getPageHexKey(path); - let [row, column] = rowColumnKey.split(','); - return getPageHex(pageId, row, column); - } - - /** - * Gets the key to a page hex object in the state, given some path. - * This key consists of a page ID, a row, and a column. If the key - * could not be found, undefined is returned. - * @param {Path} path - * @return {PageHexKey} - */ - function getPageHexKey(path) { - let myState = getState(); - let id = path.get('_id'); - return myState.hexIdMap[id]; - } - - /** - * Checks if a hex has been persisted. - */ - function hasPageHex(page, row, column) { - return !!getPageHex(page, row, column); - } - - /** - * Persists data about some hex. - * @param {Page} page - * @param {Path} hexPath - * @param {number} row - * @param {number} column - * @return {PageHex} - */ - function persistHex(page, hexPath, row, column) { - let myState = getState(); - let pageId = page.get('_id'); - - if(!myState.pageHexes[pageId]) - myState.pageHexes[pageId] = {}; - - let key = row + "," + column; - let id = hexPath.get('_id'); - - myState.pageHexes[pageId][key] = { id }; - myState.hexIdMap[id] = [pageId, key]; - - return myState.pageHexes[pageId][key]; - } - - _.extend(Hexploration, { - _state: { - deleteHex, - deletePath, - getConfig, - getPageHex, - getPageHexByPath, - getState, - hasPageHex, - persistHex +/** + * Stores or clears a page's grid calibration. + * + * @param {string} pageId Page ID. + * @param {object|null} calibration Calibration, or null to clear. + * @returns {void} + */ +export function setCalibration(pageId, calibration) { + getPageData(pageId, true).calibration = calibration ? { ...calibration } : null; +} + +// --------------------------------------------------------------------------- +// Hex records +// --------------------------------------------------------------------------- + +/** + * Builds the in-memory path ID index on first use. + * + * @returns {Map} Map of path ID to [pageId, key]. + */ +function getIndex() { + if (!pathIndex) { + pathIndex = new Map(); + for (const [pageId, page] of Object.entries(getState().pages)) { + for (const [key, hex] of Object.entries(page.hexes)) { + pathIndex.set(hex.id, [pageId, key]); + } } - }); -})(); + } + return pathIndex; +} + +/** + * Returns a hex record. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} Hex record. + */ +export function getHex(pageId, key) { + return getPageData(pageId)?.hexes[key] || null; +} + +/** + * Returns every hex record on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Hex records. + */ +export function getPageHexes(pageId) { + const page = getPageData(pageId); + return page ? Object.values(page.hexes) : []; +} + +/** + * Returns the hex record drawn by a path, with its page. + * + * @param {string} pathId Path object ID. + * @returns {{pageId: string, key: string, hex: object}|null} Lookup result. + */ +export function getHexByPathId(pathId) { + const entry = getIndex().get(pathId); + if (!entry) { + return null; + } + const [pageId, key] = entry; + const hex = getHex(pageId, key); + return hex ? { pageId, key, hex } : null; +} + +/** + * Stores a hex record, replacing any record at the same cell. + * + * @param {string} pageId Page ID. + * @param {object} hex Hex record with row and col. + * @returns {object} The stored record. + */ +export function putHex(pageId, hex) { + const key = `${hex.row},${hex.col}`; + const page = getPageData(pageId, true); + const old = page.hexes[key]; + if (old && old.id !== hex.id) { + getIndex().delete(old.id); + } + page.hexes[key] = hex; + getIndex().set(hex.id, [pageId, key]); + return hex; +} + +/** + * Removes a hex record (not its Roll20 objects). + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} The removed record. + */ +export function deleteHexRecord(pageId, key) { + const page = getPageData(pageId); + const hex = page?.hexes[key]; + if (!hex) { + return null; + } + delete page.hexes[key]; + getIndex().delete(hex.id); + return hex; +} + +// --------------------------------------------------------------------------- +// Pending locations and undo +// --------------------------------------------------------------------------- + +/** + * Returns pending location token IDs on a page (tokens marked as locations + * before the area under them was filled). + * + * @param {string} pageId Page ID. + * @returns {string[]} Token IDs. + */ +export function getPendingLocations(pageId) { + return Object.entries(getState().pendingLocations) + .filter(([, page]) => page === pageId) + .map(([tokenId]) => tokenId); +} + +/** + * Adds or removes a pending location. + * + * @param {string} tokenId Token ID. + * @param {string|null} pageId Page ID, or null to remove. + * @returns {void} + */ +export function setPendingLocation(tokenId, pageId) { + const pending = getState().pendingLocations; + if (pageId) { + pending[tokenId] = pageId; + } else { + delete pending[tokenId]; + } +} + +/** + * Returns the record of the last fill, used by undo. + * + * @returns {object|null} Last fill record. + */ +export function getLastFill() { + return getState().lastFill; +} + +/** + * Stores or clears the record of the last fill. + * + * @param {object|null} record Fill record. + * @returns {void} + */ +export function setLastFill(record) { + getState().lastFill = record; +} + +/** + * Returns the saved player-visible properties of tokens hidden under hexes. + * + * @returns {object} Map of token ID to { pageId, saved }. + */ +export function getCoveredTokens() { + return getState().coveredTokens; +} + +/** + * Returns whether a one-time notice has been shown, and marks it shown. + * + * @param {string} key Notice key. + * @returns {boolean} True the first time it is called for a key. + */ +export function takeNotice(key) { + const notices = getState().notices; + if (notices[key]) { + return false; + } + notices[key] = true; + return true; +} diff --git a/Hexploration/src/commands.js b/Hexploration/src/commands.js new file mode 100644 index 0000000000..6511f04df6 --- /dev/null +++ b/Hexploration/src/commands.js @@ -0,0 +1,983 @@ +import { + buildButton, + buildDivider, + buildRow, + buildSecondaryButton, + buildSectionLabel, + buildSwatch, + whisper, + whisperError, + whisperWarning, +} from './chat.js'; +import { + ANNOUNCE_OPTIONS, + COMMAND, + DEFAULT_CONFIG, + HANDOUT_DECK_NAME, + HANDOUT_HELP_NAME, + HEX_LAYER_OPTIONS, + LAYER_TOKEN, + LEGACY_ARG_SEPARATOR, + LEGACY_COMMANDS, + PAGE_SETTING_KEYS, + REVEAL_BY_OPTIONS, + REVEAL_MODE_OPTIONS, + SCRIPT_NAME, + SCRIPT_VERSION, +} from './constants.js'; +import { getPageContext } from './context.js'; +import { refreshPage, restoreAll } from './cover.js'; +import { hexesUnderToken, hexKey } from './grid.js'; +import { + calibratePage, + cellsInPaths, + cellsOutsidePaths, + clearPage, + consumeSourcePaths, + fillCells, + rescanPage, + resetCalibration, + undoLastFill, +} from './hexes.js'; +import { LOCALE_LABELS, SUPPORTED_LOCALES, t } from './i18n.js'; +import { installHandouts } from './journals.js'; +import { markLocations, setHexName, unmarkLocations } from './locations.js'; +import { getHexLayer, isPathObject } from './paths.js'; +import { revealAroundToken, revealHex, revealPage } from './reveal.js'; +import { + clearPageSettings, + getConfig, + getHex, + getHexByPathId, + getLastFill, + getPageData, + getPageHexes, + getPageIds, + getPageSettings, + getPendingLocations, + setConfigValue, + setPageSetting, +} from './state.js'; +import { escapeHtml, getPlayerPageId, isJumpgate, toText } from './utils.js'; + +// Settings shown in the menu, in order, with how to prompt for them. +const SETTING_ROWS = [ + { key: 'hexLayer', options: HEX_LAYER_OPTIONS }, + { key: 'fillColor', color: true }, + { key: 'strokeColor', color: true }, + { key: 'labelColor', color: true }, + { key: 'glimpseColor', color: true }, + { key: 'strokeWidth' }, + { key: 'maxDistance' }, + { key: 'revealDistance' }, + { key: 'lineOfSight', options: ['on', 'off'] }, + { key: 'revealPath', options: ['on', 'off'] }, + { key: 'revealBy', options: REVEAL_BY_OPTIONS }, + { key: 'revealMode', options: REVEAL_MODE_OPTIONS }, + { key: 'announce', options: ANNOUNCE_OPTIONS }, + { key: 'pingDiscoveries', options: ['on', 'off'] }, + { key: 'hideCoveredTokens', options: ['on', 'off'] }, + { key: 'language' }, +]; + +/** + * Returns the active locale. + * + * @returns {string} Locale code. + */ +function lang() { + return getConfig().language; +} + +/** + * Translates a key in the active locale. + * + * @param {string} key Translation key. + * @param {object} [vars] Interpolation variables. + * @returns {string} Translated text. + */ +function tr(key, vars) { + return t(key, lang(), vars); +} + +/** + * Whispers a translated error with its hint. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `errors.` (the hint lives under `hints.`). + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ +function fail(playerId, key, vars) { + const hint = t(`hints.${key}`, lang(), vars); + whisperError(playerId, tr(`errors.${key}`, vars), hint === `hints.${key}` ? '' : hint); +} + +/** + * Whispers a short translated confirmation. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `messages.`. + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ +function done(playerId, key, vars) { + whisper(playerId, SCRIPT_NAME, `
${escapeHtml(tr(`messages.${key}`, vars))}
`); +} + +/** + * Formats a setting value for display. + * + * @param {string} key Setting key. + * @param {*} value Setting value. + * @returns {string} Display text. + */ +function formatValue(key, value) { + if (typeof value === 'boolean') { + return tr(value ? 'values.on' : 'values.off'); + } + if (value === null || value === undefined) { + return tr('values.none'); + } + if (key === 'language') { + return LOCALE_LABELS[value] || value; + } + if (['hexLayer', 'revealBy', 'revealMode', 'announce'].includes(key)) { + return tr(`values.${key}.${value}`); + } + return String(value); +} + +/** + * Builds a Roll20 query prompting for a setting's new value. + * + * @param {object} row Setting row definition. + * @param {*} current Current value. + * @returns {string} Query text. + */ +function settingQuery(row, current) { + const label = tr(`settings.${row.key}.label`).replaceAll(/[|}]/g, ''); + if (row.options) { + return `?{${label}|${row.options.join('|')}}`; + } + if (row.key === 'language') { + return `?{${label}|${SUPPORTED_LOCALES.join('|')}}`; + } + const shown = current === null || current === undefined ? '' : String(current); + return `?{${label}|${shown.replaceAll(/[|}]/g, '')}}`; +} + +// --------------------------------------------------------------------------- +// Selection and page helpers +// --------------------------------------------------------------------------- + +/** + * Sorts the selection into drawn shapes, hexes and tokens. + * + * @param {object} msg Chat message. + * @returns {{paths: object[], hexes: object[], tokens: object[], pageId: string|null}} Selection. + */ +function readSelection(msg) { + const selection = { paths: [], hexes: [], tokens: [], pageId: null }; + for (const sel of msg.selected || []) { + const obj = getObj(sel._type, sel._id); + if (!obj) { + continue; + } + selection.pageId = selection.pageId || obj.get('_pageid'); + if (isPathObject(obj)) { + const found = getHexByPathId(sel._id); + if (found) { + selection.hexes.push(found); + } else { + selection.paths.push(obj); + } + } else if (sel._type === 'graphic' && obj.get('_subtype') === 'token') { + selection.tokens.push(obj); + } + } + return selection; +} + +/** + * Returns the context for the selection's page, or the GM's current page. + * Whispers an error when the page cannot be used. + * + * @param {object} msg Chat message. + * @param {object} selection Selection from readSelection. + * @returns {object|null} Page context. + */ +function pageContextFor(msg, selection) { + const ctx = getPageContext(selection.pageId || getPlayerPageId(msg.playerid)); + if (!ctx.ok) { + fail(msg.playerid, ctx.reason); + return null; + } + return ctx; +} + +/** + * Returns the cells under the selected tokens. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number[][]} Array of [row, col]. + */ +function cellsUnderTokens(ctx, tokens) { + return tokens.flatMap((token) => + hexesUnderToken( + ctx.grid, + Number(token.get('left')), + Number(token.get('top')), + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); +} + +/** + * Reports the end of a fill. + * + * @param {string} playerId Player ID. + * @param {object} summary Fill summary. + * @returns {void} + */ +function reportFill(playerId, summary) { + done(playerId, 'filled', summary); + if (summary.fellBack) { + whisperWarning(playerId, tr('warnings.foregroundUnavailable')); + } + if (summary.failed > 0) { + whisperWarning(playerId, tr('warnings.someFailed', { count: summary.failed })); + } +} + +/** + * Starts a fill and reports its outcome. + * + * @param {object} msg Chat message. + * @param {object} ctx Page context. + * @param {number[][]} allCells Cells to cover (duplicates are ignored). + * @param {object[]} sources Saved source polygons. + * @param {string} kind Fill kind. + * @returns {void} + */ +function startFill(msg, ctx, allCells, sources, kind) { + const seen = new Set(); + const cells = allCells.filter(([r, c]) => { + const key = hexKey(r, c); + return seen.has(key) ? false : seen.add(key); + }); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const result = fillCells(ctx, cells, { + sources, + kind, + onDone: (summary) => { + refreshPage(ctx.pageId); + reportFill(msg.playerid, summary); + }, + }); + if (!result.started) { + fail(msg.playerid, result.reason, { count: cells.length }); + } +} + +// --------------------------------------------------------------------------- +// Command handlers +// --------------------------------------------------------------------------- + +/** + * `fill` and `fill inverse`: cover the selected polygons (or everything + * outside them) with hexes. + * + * @param {object} msg Chat message. + * @param {boolean} inverse Fill outside the polygons. + * @returns {void} + */ +function commandFill(msg, inverse) { + const selection = readSelection(msg); + if (selection.paths.length === 0) { + fail(msg.playerid, 'noPolygons'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = inverse + ? cellsOutsidePaths(ctx, selection.paths) + : cellsInPaths(ctx, selection.paths); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, inverse ? 'fillInverse' : 'fill'); +} + +/** + * `conceal`: cover the cells under the selected polygons and tokens again. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function commandConceal(msg) { + const selection = readSelection(msg); + if (selection.paths.length === 0 && selection.tokens.length === 0) { + fail(msg.playerid, 'nothingToConceal'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = [...cellsInPaths(ctx, selection.paths), ...cellsUnderTokens(ctx, selection.tokens)]; + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, 'conceal'); +} + +/** + * `reveal`: reveal the selected hexes and the hexes under selected polygons + * and tokens. `reveal page` reveals everything on the page silently. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ +function commandReveal(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + + if (args[0] === 'page') { + revealPage(ctx, (count) => done(msg.playerid, 'revealedPage', { count })); + return; + } + + const keys = new Set(selection.hexes.filter((h) => h.pageId === ctx.pageId).map((h) => h.key)); + for (const [r, c] of [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]) { + keys.add(hexKey(r, c)); + } + if (keys.size === 0) { + fail(msg.playerid, 'nothingToReveal'); + return; + } + consumeSourcePaths(selection.paths); + const settings = getPageSettings(ctx.pageId); + let count = 0; + for (const key of keys) { + if (revealHex(ctx, key, settings)) { + count++; + } + } + refreshPage(ctx.pageId); + done(msg.playerid, 'revealed', { count }); +} + +/** + * `explore`: reveal around the selected tokens as if they had just moved + * there. Useful after moving tokens with other mods. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function commandExplore(msg) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const count = selection.tokens.reduce( + (sum, token) => sum + revealAroundToken(token, null, true), + 0 + ); + refreshPage(selection.pageId); + done(msg.playerid, 'revealed', { count }); +} + +/** + * `reset page [confirm]`: remove every hex on the page. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ +function commandReset(msg, args) { + if (args[0] !== 'page') { + fail(msg.playerid, 'unknownCommand', { command: `reset ${args.join(' ')}` }); + return; + } + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const count = getPageHexes(ctx.pageId).length; + if (args[1] !== 'confirm') { + whisper(msg.playerid, tr('titles.confirm'), [ + `
${escapeHtml(tr('messages.confirmReset', { count, page: ctx.page.get('name') }))}
`, + `
${buildButton(tr('buttons.confirmReset'), `${COMMAND} reset page confirm`)}
`, + ]); + return; + } + clearPage(ctx, (removed) => { + refreshPage(ctx.pageId); + done(msg.playerid, 'resetPage', { count: removed }); + }); +} + +/** + * `undo`: reverse the last fill. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function commandUndo(msg) { + const result = undoLastFill(); + if (!result.ok) { + fail(msg.playerid, result.reason); + return; + } + refreshPage(result.pageId); + done(msg.playerid, 'undone', result); +} + +/** + * `name `: name the selected hexes (or the hexes under selected tokens). + * An empty name clears it. + * + * @param {object} msg Chat message. + * @param {string} rawName Name text. + * @returns {void} + */ +function commandName(msg, rawName) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const keys = new Set(selection.hexes.map((h) => h.key)); + for (const token of selection.tokens) { + const [r, c] = cellsUnderTokens(ctx, [token])[0]; + keys.add(hexKey(r, c)); + } + const hexes = [...keys].map((key) => getHex(ctx.pageId, key)).filter(Boolean); + if (hexes.length === 0) { + fail(msg.playerid, 'noHexes'); + return; + } + for (const hex of hexes) { + setHexName(ctx, hex, rawName); + } + done(msg.playerid, toText(rawName) ? 'named' : 'unnamed', { + count: hexes.length, + name: toText(rawName), + }); +} + +/** + * `mark` / `unmark`: turn the selected tokens into hidden locations, or back. + * + * @param {object} msg Chat message. + * @param {boolean} mark True to mark, false to unmark. + * @returns {void} + */ +function commandMark(msg, mark) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (mark) { + done(msg.playerid, 'marked', markLocations(ctx, selection.tokens)); + } else { + done(msg.playerid, 'unmarked', { count: unmarkLocations(ctx, selection.tokens) }); + } +} + +/** + * `set [key] [value]`: change a global setting, or show the settings card. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ +function commandSet(msg, args) { + const [key, ...rest] = args; + if (!key) { + showSettings(msg.playerid); + return; + } + if (!(key in DEFAULT_CONFIG)) { + fail(msg.playerid, 'unknownSetting', { key }); + return; + } + const raw = rest.join(' '); + if (key === 'language' && !raw) { + showLanguages(msg.playerid); + return; + } + const result = setConfigValue(key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + if (key === 'language') { + installHandouts(); + } + if (key === 'hideCoveredTokens') { + if (result.value) { + getPageIds().forEach(refreshPage); + } else { + restoreAll(); + } + } + done(msg.playerid, 'settingChanged', { + setting: tr(`settings.${key}.label`), + value: formatValue(key, result.value), + }); + showSettings(msg.playerid); +} + +/** + * `page [set | clear]`: per-page overrides. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ +function commandPage(msg, args) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const [action, key, ...rest] = args; + if (action === 'set') { + if (!PAGE_SETTING_KEYS.includes(key)) { + fail(msg.playerid, 'unknownPageSetting', { + key: key || '', + keys: PAGE_SETTING_KEYS.join(', '), + }); + return; + } + const raw = rest.join(' '); + const result = setPageSetting(ctx.pageId, key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + } else if (action === 'clear') { + clearPageSettings(ctx.pageId); + } else if (action) { + fail(msg.playerid, 'unknownCommand', { command: `page ${args.join(' ')}` }); + return; + } + showPageSettings(msg.playerid, ctx); +} + +/** + * `rescan`: rebuild the page's hex list from the objects on it. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function commandRescan(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (ctx) { + const counts = rescanPage(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'rescanned', counts); + } +} + +/** + * `calibrate [reset]`: line the grid up with tokens snapped to hex centres. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ +function commandCalibrate(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (args[0] === 'reset') { + const counts = resetCalibration(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrationReset', counts); + return; + } + if (selection.tokens.length === 0) { + fail(msg.playerid, 'calibrateNeedsTokens'); + return; + } + const result = calibratePage(ctx, selection.tokens); + if (!result.ok) { + fail(msg.playerid, 'calibrateFailed'); + return; + } + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrated', { + ...result.counts, + colStep: result.calibration.colStep.toFixed(2), + rowStep: result.calibration.rowStep.toFixed(2), + }); +} + +/** + * `journal rebuild`: recreate the help and Command Deck handouts. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function commandJournal(msg) { + installHandouts(); + done(msg.playerid, 'journalRebuilt', { help: HANDOUT_HELP_NAME, deck: HANDOUT_DECK_NAME }); +} + +// --------------------------------------------------------------------------- +// Cards +// --------------------------------------------------------------------------- + +/** + * Whispers the main menu. + * + * @param {string|null} playerId Player ID (null for every GM). + * @returns {void} + */ +export function showMainMenu(playerId) { + const b = (key, cmd) => buildButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + const s = (key, cmd) => buildSecondaryButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + whisper(playerId, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, [ + buildSectionLabel(tr('menu.draw')), + `
${b('fill', 'fill')}${b('fillInverse', 'fill inverse')}${s('undo', 'undo')}
`, + buildSectionLabel(tr('menu.reveal')), + `
${b('reveal', 'reveal')}${b('conceal', 'conceal')}${b('explore', 'explore')}
`, + `
${s('revealPage', 'reveal page')}${s('resetPage', 'reset page')}
`, + buildSectionLabel(tr('menu.locations')), + `
${b('mark', 'mark')}${s('unmark', 'unmark')}${b('name', `name ?{${tr('prompts.name')}}`)}
`, + buildSectionLabel(tr('menu.tools')), + `
${s('settings', 'set')}${s('pageSettings', 'page')}${s('status', 'status')}
`, + `
${s('rescan', 'rescan')}${s('calibrate', 'calibrate')}${s('help', 'help')}
`, + ]); +} + +/** + * Whispers the global settings card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ +function showSettings(playerId) { + const config = getConfig(); + const rows = SETTING_ROWS.map((row) => { + const value = config[row.key]; + const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} set ${row.key} ${settingQuery(row, value)}` + ); + return buildRow(tr(`settings.${row.key}.label`), `${shown} ${button}`); + }); + whisper(playerId, tr('titles.settings'), [ + ...rows, + buildDivider(), + `
${escapeHtml(tr('menu.layerInUse', { layer: tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) }))}
`, + `
${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
`, + ]); +} + +/** + * Whispers the list of languages. + * + * @param {string} playerId Player ID. + * @returns {void} + */ +function showLanguages(playerId) { + const buttons = SUPPORTED_LOCALES.map((code) => + buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + ); + whisper(playerId, tr('titles.languages'), `
${buttons.join('')}
`); +} + +/** + * Whispers a page's settings and overrides. + * + * @param {string} playerId Player ID. + * @param {object} ctx Page context. + * @returns {void} + */ +function showPageSettings(playerId, ctx) { + const overrides = getPageData(ctx.pageId)?.settings || {}; + const effective = getPageSettings(ctx.pageId); + const rows = PAGE_SETTING_KEYS.map((key) => { + const row = SETTING_ROWS.find((r) => r.key === key); + const marker = key in overrides ? ' ★' : ''; + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} page set ${key} ${settingQuery(row, effective[key])}` + ); + return buildRow( + `${tr(`settings.${key}.label`)}${marker}`, + `${escapeHtml(formatValue(key, effective[key]))} ${button}` + ); + }); + whisper(playerId, tr('titles.pageSettings', { page: ctx.page.get('name') }), [ + `
${escapeHtml(tr('menu.pageSettingsHelp'))}
`, + ...rows, + `
${buildSecondaryButton(tr('buttons.clearOverrides'), `${COMMAND} page clear`)}${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
`, + ]); +} + +/** + * Whispers the status of the current page. + * + * @param {object} msg Chat message. + * @returns {void} + */ +function showStatus(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const hexes = getPageHexes(ctx.pageId); + const data = getPageData(ctx.pageId); + const last = getLastFill(); + const row = (key, value) => buildRow(tr(`status.${key}`), escapeHtml(String(value))); + whisper(msg.playerid, tr('titles.status', { page: ctx.page.get('name') }), [ + row('engine', isJumpgate() ? 'Jumpgate' : 'Legacy'), + row('grid', tr(`values.orientation.${ctx.grid.orientation}`)), + row('layer', tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`)), + row('hexes', hexes.length), + row('named', hexes.filter((h) => h.name).length), + row('icons', hexes.filter((h) => h.iconId).length), + row('glimpsed', hexes.filter((h) => h.glimpsed).length), + row('pending', getPendingLocations(ctx.pageId).length), + row('calibrated', tr(data?.calibration ? 'values.on' : 'values.off')), + row('overrides', Object.keys(data?.settings || {}).length), + row('undo', last ? tr(`values.fillKind.${last.kind}`) : tr('values.none')), + ]); +} + +/** + * Whispers the help card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ +function showHelp(playerId) { + const lines = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ]; + const html = lines + .map( + ([cmd, key]) => + `
${escapeHtml(`${COMMAND} ${cmd}`.trim())}
${escapeHtml(tr(`help.${key}`))}
` + ) + .join(''); + whisper(playerId, tr('titles.help'), [ + html, + buildDivider(), + `
${escapeHtml(tr('help.handout', { name: HANDOUT_HELP_NAME }))}
`, + ]); +} + +// --------------------------------------------------------------------------- +// Routing +// --------------------------------------------------------------------------- + +/** + * Routes a parsed command. + * + * @param {object} msg Chat message. + * @param {string} sub Subcommand. + * @param {string[]} args Arguments. + * @param {string} rest Raw text after the subcommand. + * @returns {void} + */ +function routeCommand(msg, sub, args, rest) { + switch (sub) { + case '': + case 'menu': + showMainMenu(msg.playerid); + return; + case 'help': + showHelp(msg.playerid); + return; + case 'fill': + commandFill(msg, args[0] === 'inverse'); + return; + case 'conceal': + case 'hide': + commandConceal(msg); + return; + case 'reveal': + commandReveal(msg, args); + return; + case 'explore': + commandExplore(msg); + return; + case 'reset': + commandReset(msg, args); + return; + case 'undo': + commandUndo(msg); + return; + case 'name': + commandName(msg, rest); + return; + case 'mark': + commandMark(msg, true); + return; + case 'unmark': + commandMark(msg, false); + return; + case 'set': + case 'config': + commandSet(msg, args); + return; + case 'page': + commandPage(msg, args); + return; + case 'rescan': + commandRescan(msg); + return; + case 'calibrate': + commandCalibrate(msg, args); + return; + case 'status': + showStatus(msg); + return; + case 'journal': + commandJournal(msg); + return; + default: + fail(msg.playerid, 'unknownCommand', { command: sub }); + } +} + +/** + * Maps a v1 command to the v2 handlers. + * + * @param {object} msg Chat message. + * @param {string} action Legacy action from LEGACY_COMMANDS. + * @param {string} rest Raw text after the command. + * @returns {void} + */ +function routeLegacy(msg, action, rest) { + const params = rest.split(LEGACY_ARG_SEPARATOR).map((p) => p.trim()); + switch (action) { + case 'fill': + commandFill(msg, false); + return; + case 'fillInverse': + commandFill(msg, true); + return; + case 'menu': + showMainMenu(msg.playerid); + return; + case 'legacyHex': + if (params[0] === 'name') { + commandName(msg, params.slice(1).join(LEGACY_ARG_SEPARATOR)); + } + return; + case 'legacyConfig': { + const [prop, ...values] = params; + // v1 defaults when a colour prompt is left empty. + const updates = { + color: () => ({ + fillColor: values[0] || 'black', + strokeColor: values[1] || 'transparent', + labelColor: values[2] || 'white', + }), + strokeWidth: () => ({ strokeWidth: values[0] || '0' }), + maxDistance: () => ({ maxDistance: values[0] || '' }), + revealDistance: () => ({ revealDistance: values[0] || '0' }), + }[prop]; + if (!updates) { + fail(msg.playerid, 'unknownSetting', { key: prop || '' }); + return; + } + for (const [key, value] of Object.entries(updates())) { + if (!setConfigValue(key, value).valid) { + fail(msg.playerid, 'invalidValue', { key, value }); + } + } + showSettings(msg.playerid); + return; + } + default: + } +} + +/** + * Handles chat input: `!hexploration …` and the v1 commands. GM only. + * + * @param {object} msg Roll20 chat message. + * @returns {void} + */ +export function handleInput(msg) { + if (msg.type !== 'api') { + return; + } + const content = toText(msg.content); + const [first] = content.split(/\s+/, 1); + const isMain = first === COMMAND; + const legacy = LEGACY_COMMANDS[first]; + if (!isMain && !legacy) { + return; + } + if (!playerIsGM(msg.playerid)) { + return; + } + + try { + const rest = content.slice(first.length).trim(); + if (legacy) { + routeLegacy(msg, legacy, rest); + return; + } + const [sub = '', ...args] = rest.split(/\s+/).filter(Boolean); + const afterSub = rest.slice(sub.length).trim(); + routeCommand(msg, sub.toLowerCase(), args, afterSub); + } catch (err) { + log(`${SCRIPT_NAME} ERROR: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + fail(msg.playerid, 'unexpected', { message: err?.message || String(err) }); + } +} diff --git a/Hexploration/src/constants.js b/Hexploration/src/constants.js new file mode 100644 index 0000000000..346c4cf5d4 --- /dev/null +++ b/Hexploration/src/constants.js @@ -0,0 +1,138 @@ +// Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. +export const SCRIPT_NAME = '__SCRIPT_NAME__'; +export const SCRIPT_VERSION = '__BUILD_VERSION__'; +export const SCRIPT_LAST_UPDATED = '__BUILD_DATE__'; + +export const DEFAULT_LOCALE = 'en-US'; + +export const STATE_KEY = 'Hexploration'; +export const SCHEMA_VERSION = 2; +export const COMMAND = '!hexploration'; + +// v1 commands, kept so existing macros and the Hexploration_menu macro still work. +export const LEGACY_COMMANDS = { + '!hexploration_fillPoly': 'fill', + '!hexploration_fillInversePoly': 'fillInverse', + '!hexploration_showMenuMain': 'menu', + '!hexploration_configModifyProperty': 'legacyConfig', + '!hexploration_hexModifyProperty': 'legacyHex', +}; + +// Separator v1 used between the arguments of its config and hex commands. +export const LEGACY_ARG_SEPARATOR = '&&'; + +export const HANDOUT_HELP_NAME = 'Hexploration - Help'; +export const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; + +export const AUTHOR_LINKS = { + original: { + name: 'Ada Lindberg', + profile: 'https://app.roll20.net/users/46544/ada-l', + marketplace: 'https://marketplace.roll20.net/browse/publisher/165/ada-lindberg', + }, + maintainer: { + name: 'MidNiteShadow7', + profile: 'https://app.roll20.net/users/16506286/midniteshadow7', + github: 'https://github.com/steverobertsuk', + }, +}; + +export const DEMO_GIF_URL = + 'https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif'; + +// Roll20 layer identifiers. +export const LAYER_TOKEN = 'objects'; +export const LAYER_GM = 'gmlayer'; +export const LAYER_FOREGROUND = 'foreground'; + +// Roll20 object types for drawn shapes. Jumpgate draws pathv2; Legacy draws path. +export const PATH_TYPE_LEGACY = 'path'; +export const PATH_TYPE_V2 = 'pathv2'; +export const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + +// Status marker v1 used to flag location tokens. Still honoured as a fallback. +export const LOCATION_MARKER = 'white-tower'; + +// Option lists for settings. +export const HEX_LAYER_OPTIONS = ['auto', 'foreground', 'objects']; +export const REVEAL_BY_OPTIONS = ['players', 'characters', 'all']; +export const REVEAL_MODE_OPTIONS = ['clear', 'glimpse']; +export const ANNOUNCE_OPTIONS = ['all', 'gm', 'off']; + +// Default configuration for new installs. Migrated v1 games keep their own values. +export const DEFAULT_CONFIG = { + language: DEFAULT_LOCALE, + hexLayer: 'auto', + fillColor: '#222222', + strokeColor: '#444444', + labelColor: '#FFFFFF', + glimpseColor: 'rgba(34,34,34,0.5)', + strokeWidth: 1, + revealDistance: 1, + maxDistance: null, + lineOfSight: true, + revealPath: true, + revealBy: 'players', + revealMode: 'clear', + announce: 'all', + pingDiscoveries: false, + hideCoveredTokens: true, +}; + +// Player-visible token properties switched off while a token is under a +// covered hex, because Roll20 draws nameplates, bars and auras above the +// foreground layer. Saved values are restored when the token is uncovered. +export const COVERED_TOKEN_PROPS = [ + 'showplayers_name', + 'showplayers_bar1', + 'showplayers_bar2', + 'showplayers_bar3', + 'showplayers_aura1', + 'showplayers_aura2', +]; + +// Settings that can be overridden for a single page. +export const PAGE_SETTING_KEYS = [ + 'revealDistance', + 'lineOfSight', + 'revealPath', + 'revealBy', + 'revealMode', + 'announce', + 'pingDiscoveries', +]; + +// Limits that keep a single command from creating an unreasonable number of objects. +export const MAX_REVEAL_DISTANCE = 20; +export const MAX_STROKE_WIDTH = 20; +export const MAX_FILL_HEXES = 20000; +export const MAX_NAME_LENGTH = 100; + +// Hexes are created and removed in batches so large fills do not trip the +// API's long-running script watchdog. +export const BATCH_SIZE = 100; + +// How close (as a fraction of the column step) a path's centre must be to a +// hex centre for Rescan to adopt it as a hex. +export const RESCAN_CENTRE_TOLERANCE = 0.2; + +// How close (in pixels) a text label must be to a hex centre to be adopted as its name. +export const RESCAN_LABEL_TOLERANCE = 6; + +// Colour palette for chat cards and handouts. +export const COLOR_HEADER_BG = '#1b2a1f'; +export const COLOR_HEADER_TEXT = '#e8dcb5'; +export const COLOR_CARD_BG_TOP = '#22352a'; +export const COLOR_CARD_BG_BOTTOM = '#14211a'; +export const COLOR_BORDER = '#3c5a45'; +export const COLOR_TEXT = '#e4e0d0'; +export const COLOR_MUTED = '#9aa89c'; +export const COLOR_ACCENT = '#d9a441'; +export const COLOR_BUTTON_BG = '#b5832a'; +export const COLOR_BUTTON_TEXT = '#ffffff'; +export const COLOR_WARNING_BG = '#fef3c7'; +export const COLOR_WARNING_BORDER = '#92400e'; +export const COLOR_WARNING_TEXT = '#92400e'; +export const COLOR_ERROR_BG = '#fee2e2'; +export const COLOR_ERROR_BORDER = '#991b1b'; +export const COLOR_ERROR_TEXT = '#991b1b'; diff --git a/Hexploration/src/context.js b/Hexploration/src/context.js new file mode 100644 index 0000000000..6c0beb5c5a --- /dev/null +++ b/Hexploration/src/context.js @@ -0,0 +1,42 @@ +import { createGrid } from './grid.js'; +import { getPageData } from './state.js'; +import { isJumpgate } from './utils.js'; + +/** + * Builds the hex grid for a page, including any calibration. + * + * @param {object} page Roll20 page. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ +export function buildPageGrid(page) { + const pageId = page.get('_id'); + return createGrid({ + gridType: page.get('grid_type'), + // snapping_increment is 0 when snapping is off; the grid is still drawn at 1 unit. + scale: Number(page.get('snapping_increment')) || 1, + jumpgate: isJumpgate(), + // Set by Jumpgate's map alignment tool. + offsetX: Number(page.get('grid_offset_x')) || 0, + offsetY: Number(page.get('grid_offset_y')) || 0, + calibration: getPageData(pageId)?.calibration || null, + }); +} + +/** + * Returns everything needed to work on a page's hexes. + * + * @param {string} pageId Page ID. + * @returns {{ok: true, pageId: string, page: object, grid: object}|{ok: false, reason: string}} + * Context, or the reason it is unavailable ('noPage' or 'notHex'). + */ +export function getPageContext(pageId) { + const page = pageId ? getObj('page', pageId) : null; + if (!page) { + return { ok: false, reason: 'noPage' }; + } + const grid = buildPageGrid(page); + if (!grid) { + return { ok: false, reason: 'notHex' }; + } + return { ok: true, pageId, page, grid }; +} diff --git a/Hexploration/src/cover.js b/Hexploration/src/cover.js new file mode 100644 index 0000000000..798f5a0aa4 --- /dev/null +++ b/Hexploration/src/cover.js @@ -0,0 +1,145 @@ +// Hiding tokens' player-visible details while they are under a hex. +// +// Hexes hide the token image, but Roll20 draws nameplates, bars and auras +// above the foreground layer, so a monster under a hex would still give its +// position away. While a token's centre is under a covered (not glimpsed) hex, +// its player-visible flags are switched off; the saved values are restored +// when it is uncovered, moved out, or the setting is turned off. + +import { COVERED_TOKEN_PROPS, LAYER_TOKEN } from './constants.js'; +import { getPageContext } from './context.js'; +import { hexKey, pixelToHex } from './grid.js'; +import { getConfig, getCoveredTokens, getHex } from './state.js'; + +/** + * Returns true when a token's centre is under a covered hex. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @returns {boolean} True when covered. + */ +function isCovered(ctx, token) { + if (token.get('layer') !== LAYER_TOKEN || token.get('_subtype') !== 'token') { + return false; + } + const [row, col] = pixelToHex(ctx.grid, Number(token.get('left')), Number(token.get('top'))); + const hex = getHex(ctx.pageId, hexKey(row, col)); + return !!hex && !hex.glimpsed; +} + +/** + * Switches a token's player-visible details off, saving their values. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ +function hideDetails(token) { + const covered = getCoveredTokens(); + const id = token.get('_id'); + if (covered[id]) { + return; + } + const saved = {}; + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + saved[prop] = token.get(prop) === true; + updates[prop] = false; + } + covered[id] = { pageId: token.get('_pageid'), saved }; + token.set(updates); +} + +/** + * Restores a token's saved player-visible details. + * + * @param {string} tokenId Token ID. + * @returns {void} + */ +export function restoreDetails(tokenId) { + const covered = getCoveredTokens(); + const entry = covered[tokenId]; + if (!entry) { + return; + } + delete covered[tokenId]; + const token = getObj('graphic', tokenId); + if (token) { + token.set({ ...entry.saved }); + } +} + +/** + * Keeps a covered token's details hidden when the GM switches one on while it + * is covered: the new value is saved for when the token is uncovered. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ +export function handleCoveredChange(token, prev) { + const entry = getCoveredTokens()[token.get('_id')]; + if (!entry || !prev) { + return; + } + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + if (token.get(prop) === true && prev[prop] !== true) { + entry.saved[prop] = true; + updates[prop] = false; + } + } + if (Object.keys(updates).length > 0) { + token.set(updates); + } +} + +/** + * Hides or restores one token's details to match whether it is covered. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ +export function refreshToken(token) { + const ctx = getPageContext(token.get('_pageid')); + if (getConfig().hideCoveredTokens && ctx.ok && isCovered(ctx, token)) { + hideDetails(token); + } else { + restoreDetails(token.get('_id')); + } +} + +/** + * Hides or restores the details of every token on a page. + * + * @param {string} pageId Page ID. + * @returns {void} + */ +export function refreshPage(pageId) { + const ctx = getPageContext(pageId); + const enabled = getConfig().hideCoveredTokens && ctx.ok; + const covered = getCoveredTokens(); + for (const token of findObjs({ _type: 'graphic', _pageid: pageId, _subtype: 'token' })) { + if (enabled && isCovered(ctx, token)) { + hideDetails(token); + } else if (covered[token.get('_id')]) { + restoreDetails(token.get('_id')); + } + } + // Forget tokens that were deleted while hidden. + for (const [tokenId, entry] of Object.entries(covered)) { + if (entry.pageId === pageId && !getObj('graphic', tokenId)) { + delete covered[tokenId]; + } + } +} + +/** + * Restores every hidden token in the game (used when the setting is turned off). + * + * @returns {void} + */ +export function restoreAll() { + for (const tokenId of Object.keys(getCoveredTokens())) { + restoreDetails(tokenId); + } +} diff --git a/Hexploration/src/grid.js b/Hexploration/src/grid.js new file mode 100644 index 0000000000..bb984975af --- /dev/null +++ b/Hexploration/src/grid.js @@ -0,0 +1,529 @@ +// Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, +// so the whole module can be unit tested in Node. +// +// Hexes are addressed by offset coordinates [row, col], matching the keys v1 +// stored in state. "vertical" is Roll20's Hex (V) grid (pointy-top hexes, odd +// rows shifted right by half a hex). "horizontal" is Hex (H) (flat-top hexes, +// odd columns shifted down by half a hex). Internally the maths converts to +// cube coordinates, which make distance, rounding and line drawing exact. + +const SQRT3 = Math.sqrt(3); + +export const ORIENTATION_VERTICAL = 'vertical'; +export const ORIENTATION_HORIZONTAL = 'horizontal'; + +// Pixel spacing of a 1-unit hex grid. +// +// Legacy values were measured from the Legacy editor's grid by the v1 author +// and are kept exactly so existing v1 hexes stay aligned. Legacy hexes are +// slightly stretched rather than regular. +// +// Jumpgate draws mathematically regular hexes from the 70 px grid unit: the +// distance across the flats is one unit, so the corner radius is 70/√3. The +// first hex's bounding box sits at the page's top-left corner. (Taken from the +// Jumpgate client's hex grid, which builds cells with radius gridCellSize/√3.) +// Pages that still do not line up can be corrected with `!hexploration calibrate`. +const LEGACY_V = { colStep: 75.19856198446, rowStep: 66.965827824268, originX: 37.5, originY: 44 }; +const LEGACY_H = { colStep: 69.585127490377, rowStep: 79.688789983504, originX: 47, originY: 40.5 }; +const JUMPGATE_UNIT = 70; + +export const GRID_PROFILES = { + legacy: { + [ORIENTATION_VERTICAL]: LEGACY_V, + [ORIENTATION_HORIZONTAL]: LEGACY_H, + }, + jumpgate: { + [ORIENTATION_VERTICAL]: { + colStep: JUMPGATE_UNIT, + rowStep: (JUMPGATE_UNIT * SQRT3) / 2, + originX: JUMPGATE_UNIT / 2, + originY: JUMPGATE_UNIT / SQRT3, + }, + [ORIENTATION_HORIZONTAL]: { + colStep: (JUMPGATE_UNIT * SQRT3) / 2, + rowStep: JUMPGATE_UNIT, + originX: JUMPGATE_UNIT / SQRT3, + originY: JUMPGATE_UNIT / 2, + }, + }, +}; + +const CUBE_DIRECTIONS = [ + [1, 0, -1], + [1, -1, 0], + [0, -1, 1], + [-1, 0, 1], + [-1, 1, 0], + [0, 1, -1], +]; + +/** + * Maps a Roll20 page grid_type to a hex orientation. + * + * @param {string} gridType Page grid_type ('hex' or 'hexr'). + * @returns {string|null} Orientation, or null when the grid is not hexagonal. + */ +export function orientationForGridType(gridType) { + if (gridType === 'hex') { + return ORIENTATION_VERTICAL; + } + if (gridType === 'hexr') { + return ORIENTATION_HORIZONTAL; + } + return null; +} + +/** + * Builds a grid description for a page. + * + * @param {object} options Grid options. + * @param {string} options.gridType Page grid_type. + * @param {number} [options.scale=1] Page snapping_increment (cell size in units). + * @param {boolean} [options.jumpgate=false] True for Jumpgate geometry. + * @param {number} [options.offsetX=0] Jumpgate page grid_offset_x, in pixels. + * @param {number} [options.offsetY=0] Jumpgate page grid_offset_y, in pixels. Jumpgate + * measures it upwards, so a positive value moves the grid up the page. + * @param {object|null} [options.calibration] Per-page pixel overrides from calibrate. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ +export function createGrid({ + gridType, + scale = 1, + jumpgate = false, + offsetX = 0, + offsetY = 0, + calibration = null, +}) { + const orientation = orientationForGridType(gridType); + if (!orientation) { + return null; + } + + const unit = Number(scale) > 0 ? Number(scale) : 1; + const profile = GRID_PROFILES[jumpgate ? 'jumpgate' : 'legacy'][orientation]; + const grid = { + orientation, + colStep: profile.colStep * unit, + rowStep: profile.rowStep * unit, + originX: profile.originX * unit + (jumpgate ? Number(offsetX) || 0 : 0), + originY: profile.originY * unit - (jumpgate ? Number(offsetY) || 0 : 0), + }; + + if (calibration) { + for (const key of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(calibration[key]) && (key.startsWith('origin') || calibration[key] > 0)) { + grid[key] = calibration[key]; + } + } + } + + return grid; +} + +/** + * Returns true when an integer is odd, including negative values. + * + * @param {number} n Integer. + * @returns {boolean} True when odd. + */ +function isOdd(n) { + return (n & 1) === 1; +} + +/** + * Builds the state key for a hex. + * + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {string} Key in "row,col" form. + */ +export function hexKey(row, col) { + return `${row},${col}`; +} + +/** + * Parses a "row,col" hex key. + * + * @param {string} key Hex key. + * @returns {number[]|null} [row, col], or null when malformed. + */ +export function parseHexKey(key) { + const parts = String(key).split(','); + if (parts.length !== 2) { + return null; + } + const row = Number(parts[0]); + const col = Number(parts[1]); + return Number.isInteger(row) && Number.isInteger(col) ? [row, col] : null; +} + +/** + * Converts offset coordinates to cube coordinates. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [q, r, s]. + */ +export function offsetToCube(grid, row, col) { + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = col - (row - (row & 1)) / 2; + r = row; + } else { + q = col; + r = row - (col - (col & 1)) / 2; + } + return [q, r, -q - r]; +} + +/** + * Converts cube coordinates to offset coordinates. + * + * @param {object} grid Grid object. + * @param {number[]} cube [q, r, s]. + * @returns {number[]} [row, col]. + */ +export function cubeToOffset(grid, cube) { + const [q, r] = cube; + if (grid.orientation === ORIENTATION_VERTICAL) { + return [r, q + (r - (r & 1)) / 2]; + } + return [r + (q - (q & 1)) / 2, q]; +} + +/** + * Rounds fractional cube coordinates to the nearest hex. + * + * @param {number[]} cube Fractional [q, r, s]. + * @returns {number[]} Integer [q, r, s]. + */ +export function cubeRound(cube) { + let q = Math.round(cube[0]); + let r = Math.round(cube[1]); + let s = Math.round(cube[2]); + const dq = Math.abs(q - cube[0]); + const dr = Math.abs(r - cube[1]); + const ds = Math.abs(s - cube[2]); + + if (dq > dr && dq > ds) { + q = -r - s; + } else if (dr > ds) { + r = -q - s; + } else { + s = -q - r; + } + // Normalise -0 so keys never contain "-0". + return [q + 0, r + 0, s + 0]; +} + +/** + * Returns the pixel centre of a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [x, y]. + */ +export function hexToPixel(grid, row, col) { + if (grid.orientation === ORIENTATION_VERTICAL) { + return [ + grid.originX + (col + (isOdd(row) ? 0.5 : 0)) * grid.colStep, + grid.originY + row * grid.rowStep, + ]; + } + return [ + grid.originX + col * grid.colStep, + grid.originY + (row + (isOdd(col) ? 0.5 : 0)) * grid.rowStep, + ]; +} + +/** + * Returns the hex containing a pixel position. + * + * The grid is treated as a regular hex lattice scaled by colStep and rowStep, + * so this is exact for both regular (Jumpgate) and stretched (Legacy) hexes. + * + * @param {object} grid Grid object. + * @param {number} x Pixel x. + * @param {number} y Pixel y. + * @returns {number[]} [row, col]. + */ +export function pixelToHex(grid, x, y) { + const colF = (x - grid.originX) / grid.colStep; + const rowF = (y - grid.originY) / grid.rowStep; + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = colF - rowF / 2; + r = rowF; + } else { + q = colF; + r = rowF - colF / 2; + } + return cubeToOffset(grid, cubeRound([q, r, -q - r])); +} + +/** + * Returns the number of hex steps between two hexes. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number} Distance in hexes. + */ +export function hexDistance(grid, a, b) { + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + return Math.max(Math.abs(ca[0] - cb[0]), Math.abs(ca[1] - cb[1]), Math.abs(ca[2] - cb[2])); +} + +/** + * Returns the six hexes touching a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of [row, col]. + */ +export function neighbours(grid, row, col) { + const [q, r, s] = offsetToCube(grid, row, col); + return CUBE_DIRECTIONS.map(([dq, dr, ds]) => cubeToOffset(grid, [q + dq, r + dr, s + ds])); +} + +/** + * Returns every hex within a distance of a hex (excluding the hex itself), + * nearest first. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {number} radius Distance in hexes. + * @returns {number[][]} Array of [row, col]. + */ +export function hexesWithin(grid, row, col, radius) { + const result = []; + const [q, r] = offsetToCube(grid, row, col); + for (let dist = 1; dist <= radius; dist++) { + for (let dq = -dist; dq <= dist; dq++) { + for (let dr = Math.max(-dist, -dq - dist); dr <= Math.min(dist, -dq + dist); dr++) { + const ds = -dq - dr; + if (Math.max(Math.abs(dq), Math.abs(dr), Math.abs(ds)) === dist) { + result.push(cubeToOffset(grid, [q + dq, r + dr, -(q + dq) - (r + dr)])); + } + } + } + } + return result; +} + +/** + * Returns the hexes on a straight line between two hexes, both ends included. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ +export function hexLine(grid, a, b) { + const n = hexDistance(grid, a, b); + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + if (n === 0) { + return [[a[0], a[1]]]; + } + + // A tiny nudge stops the line landing exactly on hex edges, where rounding + // would otherwise pick a side inconsistently. + const nudge = [1e-6, 2e-6, -3e-6]; + const result = []; + for (let i = 0; i <= n; i++) { + const t = i / n; + const cube = [0, 1, 2].map((k) => ca[k] + nudge[k] + (cb[k] - ca[k]) * t); + result.push(cubeToOffset(grid, cubeRound(cube))); + } + return result; +} + +/** + * Returns the hexes strictly between two hexes on a straight line. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ +export function hexesBetween(grid, a, b) { + return hexLine(grid, a, b).slice(1, -1); +} + +/** + * Returns the hexes crossed by a pixel-space line segment, in travel order. + * + * @param {object} grid Grid object. + * @param {number[]} from [x, y]. + * @param {number[]} to [x, y]. + * @returns {number[][]} Array of [row, col]. + */ +export function hexesAlongSegment(grid, from, to) { + return hexLine(grid, pixelToHex(grid, from[0], from[1]), pixelToHex(grid, to[0], to[1])); +} + +/** + * Returns the six corner points of a hex in pixels. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of six [x, y] points, clockwise. + */ +export function hexCorners(grid, row, col) { + const [cx, cy] = hexToPixel(grid, row, col); + const corners = []; + for (let i = 0; i < 6; i++) { + if (grid.orientation === ORIENTATION_VERTICAL) { + const angle = ((30 + 60 * i) * Math.PI) / 180; + corners.push([ + cx + (Math.cos(angle) / SQRT3) * grid.colStep, + cy + ((Math.sin(angle) * 2) / 3) * grid.rowStep, + ]); + } else { + const angle = (60 * i * Math.PI) / 180; + corners.push([ + cx + ((Math.cos(angle) * 2) / 3) * grid.colStep, + cy + (Math.sin(angle) / SQRT3) * grid.rowStep, + ]); + } + } + return corners; +} + +/** + * Returns every hex whose centre lies inside a bounding box. + * + * @param {object} grid Grid object. + * @param {object} box Box with left, top, right and bottom in pixels. + * @returns {number[][]} Array of [row, col]. + */ +export function hexesInBox(grid, box) { + const [r0, c0] = pixelToHex(grid, box.left, box.top); + const [r1, c1] = pixelToHex(grid, box.right, box.bottom); + const result = []; + for (let row = Math.min(r0, r1) - 1; row <= Math.max(r0, r1) + 1; row++) { + for (let col = Math.min(c0, c1) - 1; col <= Math.max(c0, c1) + 1; col++) { + const [x, y] = hexToPixel(grid, row, col); + if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) { + result.push([row, col]); + } + } + } + return result; +} + +/** + * Returns every hex needed to cover a page completely, including the partial + * hexes along its edges. + * + * @param {object} grid Grid object. + * @param {number} widthPx Page width in pixels. + * @param {number} heightPx Page height in pixels. + * @returns {number[][]} Array of [row, col]. + */ +export function hexesCoveringPage(grid, widthPx, heightPx) { + // A hex overlaps the page when its centre is within its own half-size of + // the page edge. Slivers thinner than a quarter pixel are ignored. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const padX = (vertical ? grid.colStep / 2 : (grid.colStep * 2) / 3) - 0.25; + const padY = (vertical ? (grid.rowStep * 2) / 3 : grid.rowStep / 2) - 0.25; + return hexesInBox(grid, { + left: -padX, + top: -padY, + right: widthPx + padX, + bottom: heightPx + padY, + }); +} + +/** + * Returns the hexes a token covers: every hex whose centre lies under the + * token, plus the hex under its centre. + * + * @param {object} grid Grid object. + * @param {number} x Token centre x. + * @param {number} y Token centre y. + * @param {number} width Token width in pixels. + * @param {number} height Token height in pixels. + * @returns {number[][]} Array of [row, col], centre hex first. + */ +export function hexesUnderToken(grid, x, y, width, height) { + const centre = pixelToHex(grid, x, y); + // Shrink slightly so a token that only touches a neighbour's centre does not claim it. + const halfW = Math.max(0, width / 2 - 2); + const halfH = Math.max(0, height / 2 - 2); + const covered = hexesInBox(grid, { + left: x - halfW, + top: y - halfH, + right: x + halfW, + bottom: y + halfH, + }); + const centreKey = hexKey(centre[0], centre[1]); + return [centre, ...covered.filter(([r, c]) => hexKey(r, c) !== centreKey)]; +} + +/** + * Derives a calibration from tokens the GM has snapped to hex centres. + * + * One token corrects the grid origin. Two tokens in neighbouring cells of the + * same row (Hex V) or column (Hex H) also correct the hex spacing, keeping the + * current ratio between column and row spacing. + * + * @param {object} grid Current grid object. + * @param {number[][]} points Token centres [[x, y], ...]. + * @returns {object|null} Calibration, or null when the points cannot be used. + */ +export function calibrateGrid(grid, points) { + if (!Array.isArray(points) || points.length === 0) { + return null; + } + + let { colStep, rowStep } = grid; + if (points.length >= 2) { + const [a, b] = points; + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const along = vertical ? Math.abs(b[0] - a[0]) : Math.abs(b[1] - a[1]); + const across = vertical ? Math.abs(b[1] - a[1]) : Math.abs(b[0] - a[0]); + const currentStep = vertical ? colStep : rowStep; + const steps = Math.round(along / currentStep); + if (steps < 1 || across > currentStep / 4) { + return null; + } + const ratio = rowStep / colStep; + if (vertical) { + colStep = along / steps; + rowStep = colStep * ratio; + } else { + rowStep = along / steps; + colStep = rowStep / ratio; + } + } + + const scaled = { ...grid, colStep, rowStep }; + const [px, py] = points[0]; + const [row, col] = pixelToHex(scaled, px, py); + const [cx, cy] = hexToPixel(scaled, row, col); + const calibration = { + colStep, + rowStep, + originX: grid.originX + (px - cx), + originY: grid.originY + (py - cy), + }; + + // Keep the origin inside the first cell so offsets stay small and stable. + // Shifting by two rows/columns preserves the odd/even offset pattern. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const wrapX = vertical ? colStep : colStep * 2; + const wrapY = vertical ? rowStep * 2 : rowStep; + calibration.originX = ((calibration.originX % wrapX) + wrapX) % wrapX; + calibration.originY = ((calibration.originY % wrapY) + wrapY) % wrapY; + return calibration; +} diff --git a/Hexploration/src/hexes.js b/Hexploration/src/hexes.js new file mode 100644 index 0000000000..2ce07dfb16 --- /dev/null +++ b/Hexploration/src/hexes.js @@ -0,0 +1,545 @@ +// Creating, removing and maintaining hexes on a page: fill, inverse fill, +// conceal, reset, rescan, calibrate and undo. + +import { + BATCH_SIZE, + LAYER_GM, + LAYER_TOKEN, + LOCATION_MARKER, + MAX_FILL_HEXES, + RESCAN_CENTRE_TOLERANCE, + RESCAN_LABEL_TOLERANCE, +} from './constants.js'; +import { buildPageGrid } from './context.js'; +import { + calibrateGrid, + hexCorners, + hexesCoveringPage, + hexesInBox, + hexKey, + hexToPixel, + pixelToHex, +} from './grid.js'; +import { + attachIcon, + detachIcon, + findLocationTokens, + getHexIcon, + removeLabel, +} from './locations.js'; +import { + createHexPath, + getPagePaths, + getPathObject, + getPathRings, + readPathProps, + recreatePath, + safeRemove, +} from './paths.js'; +import { boundingBox, distinctVertices, pointInShape, ringCentre } from './polygon.js'; +import { + deleteHexRecord, + deletePageData, + getConfig, + getPageIds, + getHex, + getHexByPathId, + getLastFill, + getPageData, + getPageHexes, + getPendingLocations, + putHex, + setCalibration, + setLastFill, + setPendingLocation, +} from './state.js'; +import { runInBatches, tokenHasMarker } from './utils.js'; + +/** + * Returns the hex style from the current config. + * + * @returns {{fill: string, stroke: string, strokeWidth: number, maxDistance: number|null}} Style. + */ +export function currentStyle() { + const config = getConfig(); + return { + fill: config.fillColor, + stroke: config.strokeColor, + strokeWidth: config.strokeWidth, + maxDistance: config.maxDistance, + }; +} + +/** + * Draws one hex and stores its record. + * + * @param {object} ctx Page context. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {object} style Hex style. + * @param {object} [extra] Extra record fields (name, iconId…). + * @returns {{hex: object, fellBack: boolean}|null} New record, or null on failure. + */ +export function drawHex(ctx, row, col, style, extra = {}) { + const created = createHexPath(ctx.pageId, hexCorners(ctx.grid, row, col), style); + if (!created) { + return null; + } + const hex = { id: created.obj.get('_id'), type: created.obj.get('_type'), row, col, ...extra }; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } + putHex(ctx.pageId, hex); + return { hex, fellBack: created.fellBack }; +} + +/** + * Removes a hex: its record, its path and its name label. Its icon is moved + * back to the token layer when `showIcon` is true, otherwise left hidden. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @param {boolean} [showIcon=false] Return the icon to the token layer. + * @returns {object|null} The removed record. + */ +export function removeHex(pageId, key, showIcon = false) { + const hex = deleteHexRecord(pageId, key); + if (!hex) { + return null; + } + removeLabel(hex); + if (showIcon) { + detachIcon(hex); + } + safeRemove(getPathObject(hex.id, hex.type)); + return hex; +} + +/** + * Returns the cells whose centres lie inside any of the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects on the page. + * @returns {number[][]} Array of [row, col], without duplicates. + */ +export function cellsInPaths(ctx, paths) { + const seen = new Set(); + const cells = []; + for (const path of paths) { + const rings = getPathRings(path); + if (rings.length === 0) { + continue; + } + const box = boundingBox(rings.flat()); + for (const [row, col] of hexesInBox(ctx.grid, box)) { + const key = hexKey(row, col); + if (!seen.has(key) && pointInShape(hexToPixel(ctx.grid, row, col), rings)) { + seen.add(key); + cells.push([row, col]); + } + } + } + return cells; +} + +/** + * Returns every cell on the page except those inside the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects to leave uncovered. + * @returns {number[][]} Array of [row, col]. + */ +export function cellsOutsidePaths(ctx, paths) { + const omit = new Set(cellsInPaths(ctx, paths).map(([r, c]) => hexKey(r, c))); + const width = Number(ctx.page.get('width')) * 70; + const height = Number(ctx.page.get('height')) * 70; + return hexesCoveringPage(ctx.grid, width, height).filter(([r, c]) => !omit.has(hexKey(r, c))); +} + +/** + * Covers cells with hexes. Existing hexes are restyled rather than replaced, + * so their names and icons are kept. Location tokens in a covered cell are + * attached as icons. Work is batched; `onDone` receives a summary. + * + * @param {object} ctx Page context. + * @param {number[][]} cells Cells to cover. + * @param {object} options Fill options. + * @param {object[]} [options.sources] Saved properties of the polygons used (for undo). + * @param {string} options.kind Fill kind for undo ('fill', 'fillInverse', 'conceal'). + * @param {(summary: object) => void} options.onDone Completion callback. + * @returns {{started: boolean, reason?: string}} Whether the fill started. + */ +export function fillCells(ctx, cells, { sources = [], kind, onDone }) { + if (cells.length > MAX_FILL_HEXES) { + return { started: false, reason: 'tooMany' }; + } + + const style = currentStyle(); + const locations = findLocationTokens(ctx); + const record = { + pageId: ctx.pageId, + kind, + time: Date.now(), + created: [], + restyled: [], + icons: [], + sources, + }; + const summary = { created: 0, restyled: 0, icons: 0, failed: 0, fellBack: false }; + + runInBatches( + cells, + BATCH_SIZE, + ([row, col]) => { + const key = hexKey(row, col); + let hex = getHex(ctx.pageId, key); + const existingPath = hex ? getPathObject(hex.id, hex.type) : null; + + if (hex && existingPath) { + record.restyled.push({ + key, + fill: existingPath.get('fill'), + stroke: existingPath.get('stroke'), + strokeWidth: existingPath.get('stroke_width'), + maxDistance: hex.maxDistance ?? null, + glimpsed: hex.glimpsed === true, + }); + existingPath.set({ + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + }); + delete hex.glimpsed; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } else { + delete hex.maxDistance; + } + summary.restyled++; + } else { + if (hex) { + // The record outlived its path (deleted while the API was off). + deleteHexRecord(ctx.pageId, key); + } + const drawn = drawHex(ctx, row, col, style); + if (!drawn) { + summary.failed++; + return; + } + hex = drawn.hex; + summary.fellBack = summary.fellBack || drawn.fellBack; + record.created.push({ key, id: hex.id }); + summary.created++; + } + + const token = locations.get(key); + if (token && !hex.iconId) { + record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + attachIcon(hex, token); + summary.icons++; + } + }, + (errors) => { + summary.failed += errors; + setLastFill(record); + onDone(summary); + } + ); + + return { started: true }; +} + +/** + * Removes every hex on a page, returning icons to the token layer. Page + * settings and calibration are kept. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ +export function clearPage(ctx, onDone) { + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + for (const tokenId of getPendingLocations(ctx.pageId)) { + setPendingLocation(tokenId, null); + } + const last = getLastFill(); + if (last?.pageId === ctx.pageId) { + setLastFill(null); + } + runInBatches( + keys, + BATCH_SIZE, + (key) => removeHex(ctx.pageId, key, true), + () => onDone(keys.length) + ); +} + +/** + * Reverses the last fill: removes the hexes it created, restores the style + * of hexes it restyled, returns icons it hid, and redraws the polygons it used. + * + * @returns {{ok: boolean, reason?: string, removed?: number, restored?: number, pageId?: string}} Result. + */ +export function undoLastFill() { + const record = getLastFill(); + if (!record) { + return { ok: false, reason: 'nothingToUndo' }; + } + setLastFill(null); + const page = getObj('page', record.pageId); + if (!page) { + return { ok: false, reason: 'noPage' }; + } + + let removed = 0; + for (const { key, id } of record.created || []) { + const hex = getHex(record.pageId, key); + if (hex && hex.id === id) { + removeHex(record.pageId, key, false); + removed++; + } + } + + let restored = 0; + for (const prev of record.restyled || []) { + const hex = getHex(record.pageId, prev.key); + const path = hex ? getPathObject(hex.id, hex.type) : null; + if (path) { + path.set({ fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); + if (Number.isInteger(prev.maxDistance)) { + hex.maxDistance = prev.maxDistance; + } else { + delete hex.maxDistance; + } + if (prev.glimpsed) { + hex.glimpsed = true; + } + restored++; + } + } + + for (const { id, layer } of record.icons || []) { + const token = getObj('graphic', id); + if (token) { + for (const hex of getPageHexes(record.pageId)) { + if (hex.iconId === id) { + delete hex.iconId; + } + } + token.set('layer', layer || LAYER_TOKEN); + } + } + + for (const props of record.sources || []) { + recreatePath(props); + } + + return { ok: true, removed, restored, pageId: record.pageId }; +} + +/** + * Captures the polygons used for a fill so undo can redraw them, then deletes them. + * + * @param {object[]} paths Roll20 path objects. + * @returns {object[]} Saved properties. + */ +export function consumeSourcePaths(paths) { + // A selected path may itself be a hex; only plain drawings are consumed. + const drawings = paths.filter((path) => !getHexByPathId(path.get('_id'))); + const sources = drawings.map(readPathProps); + for (const path of drawings) { + safeRemove(path); + } + return sources; +} + +/** + * Returns the hex a path draws, judged by its shape: a six-cornered polygon + * centred on a hex cell and roughly the size of a hex. + * + * @param {object} ctx Page context. + * @param {object} path Roll20 path object. + * @returns {number[]|null} [row, col], or null when the path is not a hex. + */ +function matchHexShape(ctx, path) { + const rings = getPathRings(path); + if (rings.length !== 1) { + return null; + } + const vertices = distinctVertices(rings[0]); + if (vertices.length !== 6) { + return null; + } + const [x, y] = ringCentre(vertices); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + if (Math.hypot(x - cx, y - cy) > ctx.grid.colStep * RESCAN_CENTRE_TOLERANCE) { + return null; + } + const actual = boundingBox(vertices); + const expected = boundingBox(hexCorners(ctx.grid, row, col)); + const ratioW = (actual.right - actual.left) / (expected.right - expected.left); + const ratioH = (actual.bottom - actual.top) / (expected.bottom - expected.top); + if (ratioW < 0.75 || ratioW > 1.25 || ratioH < 0.75 || ratioH > 1.25) { + return null; + } + return [row, col]; +} + +/** + * Rebuilds a page's hex list from what is actually on the page: + * - drops records whose path is gone, and label/icon links that are broken; + * - re-files hexes whose cell changed (after calibration); + * - adopts hex-shaped paths the mod does not know about (duplicated pages, + * Legacy games copied to Jumpgate); + * - re-links GM-layer labels and white-tower icons sitting on hexes. + * + * @param {object} ctx Page context. + * @returns {{kept: number, dropped: number, moved: number, adopted: number, labels: number, icons: number}} Counts. + */ +export function rescanPage(ctx) { + const counts = { kept: 0, dropped: 0, moved: 0, adopted: 0, labels: 0, icons: 0 }; + const pageData = getPageData(ctx.pageId, true); + + // 1. Check existing records. + for (const hex of Object.values(pageData.hexes)) { + const key = hexKey(hex.row, hex.col); + const path = getPathObject(hex.id, hex.type); + if (!path) { + removeLabel(hex); + deleteHexRecord(ctx.pageId, key); + counts.dropped++; + continue; + } + hex.type = path.get('_type'); + if (hex.nameId && !getObj('text', hex.nameId)) { + delete hex.nameId; + } + if (hex.iconId && !getHexIcon(hex)) { + delete hex.iconId; + } + const cell = matchHexShape(ctx, path); + if (cell && hexKey(cell[0], cell[1]) !== key && !getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + deleteHexRecord(ctx.pageId, key); + putHex(ctx.pageId, { ...hex, row: cell[0], col: cell[1] }); + counts.moved++; + } else { + counts.kept++; + } + } + + // 2. Adopt unknown hex-shaped paths. + for (const path of getPagePaths(ctx.pageId)) { + const id = path.get('_id'); + if (getHexByPathId(id)) { + continue; + } + const cell = matchHexShape(ctx, path); + if (!cell || getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + continue; + } + putHex(ctx.pageId, { id, type: path.get('_type'), row: cell[0], col: cell[1] }); + counts.adopted++; + } + + // 3. Re-link GM-layer labels sitting on hex centres. + const linkedLabels = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.nameId) + .filter(Boolean) + ); + for (const text of findObjs({ _type: 'text', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedLabels.has(text.get('_id'))) { + continue; + } + const x = Number(text.get('left')); + const y = Number(text.get('top')); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + hex.nameId = text.get('_id'); + hex.name = String(text.get('text') || '').trim() || hex.name; + counts.labels++; + } + } + + // 4. Re-link hidden white-tower icons. + const linkedIcons = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.iconId) + .filter(Boolean) + ); + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedIcons.has(token.get('_id')) || !tokenHasMarker(token, LOCATION_MARKER)) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + hex.iconId = token.get('_id'); + counts.icons++; + } + } + + return counts; +} + +/** + * Calibrates a page's grid from tokens snapped to hex centres, then rescans + * so existing hexes are filed under their corrected cells. + * + * @param {object} ctx Page context. + * @param {object[]} tokens One or two Roll20 graphics. + * @returns {{ok: boolean, calibration?: object, counts?: object}} Result. + */ +export function calibratePage(ctx, tokens) { + const points = tokens.slice(0, 2).map((t) => [Number(t.get('left')), Number(t.get('top'))]); + // Calibrate against the uncalibrated profile so repeated calibration does not drift. + setCalibration(ctx.pageId, null); + const base = buildPageGrid(ctx.page); + const calibration = calibrateGrid(base, points); + if (!calibration) { + return { ok: false }; + } + setCalibration(ctx.pageId, calibration); + const fresh = { ...ctx, grid: buildPageGrid(ctx.page) }; + return { ok: true, calibration, counts: rescanPage(fresh) }; +} + +/** + * Clears a page's calibration and rescans. + * + * @param {object} ctx Page context. + * @returns {object} Rescan counts. + */ +export function resetCalibration(ctx) { + setCalibration(ctx.pageId, null); + return rescanPage({ ...ctx, grid: buildPageGrid(ctx.page) }); +} + +/** + * Removes stored hexes whose paths no longer exist, on every page. Run on + * startup, since paths deleted while the API was off fire no events. + * + * @returns {{dropped: number, pages: number}} Counts. + */ +export function pruneMissingHexes() { + let dropped = 0; + let pages = 0; + for (const pageId of getPageIds()) { + if (!getObj('page', pageId)) { + dropped += getPageHexes(pageId).length; + deletePageData(pageId); + pages++; + continue; + } + for (const hex of getPageHexes(pageId)) { + if (!getPathObject(hex.id, hex.type)) { + deleteHexRecord(pageId, hexKey(hex.row, hex.col)); + dropped++; + } + } + } + return { dropped, pages }; +} diff --git a/Hexploration/src/i18n.js b/Hexploration/src/i18n.js new file mode 100644 index 0000000000..f03bdcc18e --- /dev/null +++ b/Hexploration/src/i18n.js @@ -0,0 +1,123 @@ +import { + DEFAULT_LOCALE, + LOCALE_ALIASES, + LOCALE_DEFINITIONS, + TRANSLATIONS, + VALID_LOCALES, +} from './locales/index.js'; + +export { + DEFAULT_LOCALE, + LOCALE_DEFINITIONS, + LOCALE_LABELS, + SUPPORTED_LOCALE_LIST, + SUPPORTED_LOCALES, + VALID_LOCALES, +} from './locales/index.js'; + +/** + * Returns the canonical locale for a supported locale string or alias. + * Matching is case-insensitive after exact matches are checked. + * + * @param {string} lang Locale string or alias (e.g. 'en', 'fr', 'zh-TW'). + * @returns {string} Canonical locale code, or an empty string when unsupported. + */ +export function normalizeLocale(lang) { + const s = typeof lang === 'string' ? lang.trim() : ''; + if (VALID_LOCALES.has(s)) { + return s; + } + if (LOCALE_ALIASES[s]) { + return LOCALE_ALIASES[s]; + } + const normalized = s.toLowerCase(); + const found = Array.from(VALID_LOCALES).find((locale) => locale.toLowerCase() === normalized); + return ( + found || + Object.entries(LOCALE_ALIASES).find(([alias]) => alias.toLowerCase() === normalized)?.[1] || + '' + ); +} + +/** + * Returns a valid canonical locale, falling back to the default when unsupported. + * + * @param {string} lang Locale string to validate. + * @returns {string} Validated canonical locale. + */ +export function getLocale(lang) { + return normalizeLocale(lang) || DEFAULT_LOCALE; +} + +/** + * Navigates a nested object following dot-separated key path segments. + * + * @param {object} obj Root object. + * @param {string[]} parts Key path segments. + * @returns {*} Value at the path, or undefined. + */ +function getNestedValue(obj, parts) { + let current = obj; + for (const part of parts) { + if (current == null || typeof current !== 'object') { + return undefined; + } + current = current[part]; + } + return current; +} + +/** + * Returns the raw translated value (string, array or object) for a key, + * falling back to en-US when the key is missing in the requested locale. + * + * @param {string} key Dot-separated translation key. + * @param {string} locale Locale code. + * @returns {*} Raw value, or undefined when not found. + */ +export function tRaw(key, locale) { + const lang = getLocale(locale); + const parts = key.split('.'); + const value = getNestedValue(TRANSLATIONS[lang], parts); + return value === undefined && lang !== DEFAULT_LOCALE + ? getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts) + : value; +} + +/** + * Returns the text direction CSS for a locale. + * + * @param {string} locale Locale code. + * @returns {string} CSS declarations, empty for left-to-right locales. + */ +export function getDirectionStyle(locale) { + const lang = getLocale(locale); + const def = LOCALE_DEFINITIONS.find((d) => d.code === lang); + return def?.direction === 'rtl' ? 'direction:rtl;text-align:right;' : ''; +} + +/** + * Returns the translated string for a dot-separated key, interpolating {placeholder} vars. + * Falls back to en-US when the key is missing in the requested locale. + * No HTML escaping is performed — callers must pre-escape HTML-unsafe values. + * + * @param {string} key Dot-separated translation key (e.g. 'errors.noTokensSelected'). + * @param {string} locale Locale code. + * @param {object} [vars] Interpolation variables mapped to {placeholder} names. + * @returns {string} Translated and interpolated string. Returns the key when not found. + */ +export function t(key, locale, vars = {}) { + const lang = getLocale(locale); + const parts = key.split('.'); + let value = getNestedValue(TRANSLATIONS[lang], parts); + + if (value === undefined && lang !== DEFAULT_LOCALE) { + value = getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts); + } + + if (typeof value !== 'string') { + return key; + } + + return value.replaceAll(/\{(\w+)\}/g, (_, k) => (k in vars ? String(vars[k]) : `{${k}}`)); +} diff --git a/Hexploration/src/index.js b/Hexploration/src/index.js index a1ee218c6f..214e741e9c 100644 --- a/Hexploration/src/index.js +++ b/Hexploration/src/index.js @@ -1 +1,221 @@ -var Hexploration = {}; +import { whisper } from './chat.js'; +import { handleInput, showMainMenu } from './commands.js'; +import { + PATH_TYPE_LEGACY, + PATH_TYPE_V2, + SCRIPT_LAST_UPDATED, + SCRIPT_NAME, + SCRIPT_VERSION, +} from './constants.js'; +import { refreshPage, refreshToken } from './cover.js'; +import { pruneMissingHexes } from './hexes.js'; +import { t } from './i18n.js'; +import { installHandouts } from './journals.js'; +import { removeLabel } from './locations.js'; +import { revealAroundToken, handleTokenChange } from './reveal.js'; +import { + applyGlobalConfig, + deleteHexRecord, + deletePageData, + getConfig, + getCoveredTokens, + getHexByPathId, + getPageIds, + initialiseState, + setPendingLocation, +} from './state.js'; +import { escapeHtml, isJumpgate } from './utils.js'; + +let ready = false; + +/** + * Runs a handler, logging instead of crashing the sandbox on errors. + * + * @param {string} label Handler name for the log. + * @param {Function} fn Handler. + * @returns {Function} Wrapped handler. + */ +function guarded(label, fn) { + return (...args) => { + if (!ready) { + return; + } + try { + fn(...args); + } catch (err) { + log(`${SCRIPT_NAME} ERROR in ${label}: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }; +} + +/** + * Forgets a hex whose path was deleted by hand. + * + * @param {object} path Deleted Roll20 path. + * @returns {void} + */ +function handlePathDestroyed(path) { + const found = getHexByPathId(path.get('_id')); + if (found) { + removeLabel(found.hex); + deleteHexRecord(found.pageId, found.key); + refreshPage(found.pageId); + } +} + +/** + * Forgets a deleted token as a pending location or hidden token. + * + * @param {object} token Deleted Roll20 graphic. + * @returns {void} + */ +function handleGraphicDestroyed(token) { + setPendingLocation(token.get('_id'), null); + delete getCoveredTokens()[token.get('_id')]; +} + +/** + * Forgets a deleted page's hexes. + * + * @param {object} page Deleted Roll20 page. + * @returns {void} + */ +function handlePageDestroyed(page) { + const pageId = page.get('_id'); + if (getPageIds().includes(pageId)) { + deletePageData(pageId); + } +} + +/** + * Registers with TokenMod (if installed) so tokens it moves reveal hexes; + * the API does not raise change events for moves made by other mods. + * + * @returns {void} + */ +function observeOtherMods() { + if (typeof TokenMod !== 'undefined' && typeof TokenMod?.ObserveTokenChange === 'function') { + TokenMod.ObserveTokenChange(guarded('TokenMod observer', handleTokenChange)); + } +} + +/** + * Publishes the API other mods can call. + * + * @returns {void} + */ +function publishApi() { + globalThis.Hexploration = Object.freeze({ + version: SCRIPT_VERSION, + /** + * Reveals around a token as if it had just moved, for mods that move tokens. + * + * @param {object|string} tokenOrId Roll20 graphic or its ID. + * @param {object} [prev] Previous left/top, to reveal along the route. + * @returns {number} Number of hexes revealed or glimpsed. + */ + revealAround(tokenOrId, prev = null) { + const token = typeof tokenOrId === 'string' ? getObj('graphic', tokenOrId) : tokenOrId; + if (!ready || !token) { + return 0; + } + try { + const changed = revealAroundToken(token, prev); + refreshPage(token.get('_pageid')); + return changed; + } catch (err) { + log(`${SCRIPT_NAME} ERROR in revealAround: ${err?.message || err}`); + return 0; + } + }, + }); +} + +/** + * Startup: migrate state, clean up, install handouts and greet the GM. + * + * @returns {void} + */ +function checkInstall() { + const migratedFrom = initialiseState(); + applyGlobalConfig(); + const pruned = pruneMissingHexes(); + for (const pageId of new Set([ + ...getPageIds(), + ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), + ])) { + refreshPage(pageId); + } + installHandouts(); + registerEngineHandlers(); + observeOtherMods(); + publishApi(); + ready = true; + + log( + `-=> ${SCRIPT_NAME} v${SCRIPT_VERSION} [Updated: ${SCRIPT_LAST_UPDATED}] (${isJumpgate() ? 'Jumpgate' : 'Legacy'}) <=-` + ); + + const lang = getConfig().language; + const lines = [`
${escapeHtml(t('titles.ready', lang))}
`]; + if (migratedFrom === 1) { + lines.push(`
${escapeHtml(t('messages.migrated', lang))}
`); + } + if (pruned.dropped > 0) { + lines.push( + `
${escapeHtml(t('messages.pruned', lang, pruned))}
` + ); + } + lines.push( + `
${escapeHtml(t('messages.readyHint', lang))}
` + ); + whisper(null, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, lines); + if (migratedFrom === 1 || pruned.dropped > 0) { + showMainMenu(null); + } +} + +/** + * Registers all Roll20 event handlers. + * + * @returns {void} + */ +function registerEventHandlers() { + on('ready', () => { + try { + checkInstall(); + } catch (err) { + log(`${SCRIPT_NAME} ERROR during startup: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }); + on('chat:message', (msg) => { + if (ready) { + handleInput(msg); + } + }); + on('change:graphic', guarded('change:graphic', handleTokenChange)); + on('add:graphic', guarded('add:graphic', refreshToken)); + on('destroy:graphic', guarded('destroy:graphic', handleGraphicDestroyed)); + on('destroy:page', guarded('destroy:page', handlePageDestroyed)); + on(`destroy:${PATH_TYPE_LEGACY}`, guarded('destroy:path', handlePathDestroyed)); +} + +/** + * Registers handlers that depend on the game engine. pathv2 objects only + * exist in Jumpgate, and the engine is only known once the game has loaded. + * + * @returns {void} + */ +function registerEngineHandlers() { + if (isJumpgate()) { + on(`destroy:${PATH_TYPE_V2}`, guarded('destroy:pathv2', handlePathDestroyed)); + } +} + +registerEventHandlers(); diff --git a/Hexploration/src/journals.js b/Hexploration/src/journals.js new file mode 100644 index 0000000000..c57fae9832 --- /dev/null +++ b/Hexploration/src/journals.js @@ -0,0 +1,225 @@ +// Journal handouts: the Help handout and the Command Deck. + +import { + AUTHOR_LINKS, + COLOR_ACCENT, + COLOR_BORDER, + COLOR_BUTTON_BG, + COLOR_BUTTON_TEXT, + COLOR_CARD_BG_BOTTOM, + COLOR_HEADER_BG, + COLOR_HEADER_TEXT, + COLOR_MUTED, + COLOR_TEXT, + COMMAND, + DEFAULT_CONFIG, + DEMO_GIF_URL, + HANDOUT_DECK_NAME, + HANDOUT_HELP_NAME, + PAGE_SETTING_KEYS, + SCRIPT_NAME, + SCRIPT_VERSION, +} from './constants.js'; +import { getDirectionStyle, getLocale, LOCALE_LABELS, SUPPORTED_LOCALES, t, tRaw } from './i18n.js'; +import { getConfig } from './state.js'; +import { escapeHtml } from './utils.js'; + +const STYLE = { + outer: `background:${COLOR_CARD_BG_BOTTOM};color:${COLOR_TEXT};padding:14px 18px;border:1px solid ${COLOR_BORDER};border-radius:6px;font-family:Arial,sans-serif;line-height:1.5;`, + header: `background:${COLOR_HEADER_BG};padding:12px;border-radius:4px;text-align:center;border-bottom:3px solid ${COLOR_ACCENT};margin-bottom:12px;`, + h1: `color:${COLOR_HEADER_TEXT};margin:0;font-size:1.8em;letter-spacing:0.05em;`, + subtitle: `color:${COLOR_MUTED};margin:4px 0 0 0;font-size:0.9em;`, + h2: `color:${COLOR_ACCENT};border-bottom:1px solid ${COLOR_BORDER};padding-bottom:3px;margin:18px 0 8px 0;font-size:1.25em;`, + p: `color:${COLOR_TEXT};margin:6px 0;`, + li: `color:${COLOR_TEXT};margin:3px 0;`, + table: 'width:100%;border-collapse:collapse;margin:6px 0;font-size:0.92em;', + th: `background:${COLOR_HEADER_BG};color:${COLOR_HEADER_TEXT};padding:5px 8px;text-align:left;border:1px solid ${COLOR_BORDER};`, + td: `padding:5px 8px;border:1px solid ${COLOR_BORDER};vertical-align:top;color:${COLOR_TEXT};`, + code: 'font-family:monospace;color:#f3d48b;white-space:nowrap;', + link: `color:${COLOR_ACCENT};`, + footer: `color:${COLOR_MUTED};font-size:0.85em;text-align:center;margin-top:16px;border-top:1px solid ${COLOR_BORDER};padding-top:8px;`, + btn: `background:${COLOR_BUTTON_BG};color:${COLOR_BUTTON_TEXT};padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;font-weight:bold;`, + btnDark: `background:#2c4034;color:${COLOR_TEXT};border:1px solid #4d6b56;padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;`, + section: `background:${COLOR_HEADER_BG};color:${COLOR_ACCENT};padding:4px 8px;font-variant:small-caps;font-weight:bold;letter-spacing:0.05em;border-left:3px solid ${COLOR_ACCENT};margin:12px 0 4px 0;`, + desc: `color:${COLOR_MUTED};font-size:0.85em;margin:0 0 4px 8px;`, +}; + +/** + * Builds a table. + * + * @param {string[]} headings Column headings (escaped). + * @param {string[][]} rows Row cells (trusted HTML). + * @returns {string} HTML string. + */ +function table(headings, rows) { + const head = headings.map((h) => `${escapeHtml(h)}`).join(''); + const body = rows + .map((cells) => `${cells.map((c) => `${c}`).join('')}`) + .join(''); + return `${head}${body}
`; +} + +/** + * Builds a paragraph list from a translated array. + * + * @param {*} items Translated value (array of strings expected). + * @param {boolean} [ordered=false] Use a numbered list. + * @returns {string} HTML string. + */ +function list(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const lis = (Array.isArray(items) ? items : []) + .map((item) => `
  • ${escapeHtml(item)}
    • `) + .join(''); + return `<${tag}>${lis}`; +} + +/** + * Builds a link. + * + * @param {string} url URL. + * @param {string} label Link text. + * @returns {string} HTML anchor. + */ +function link(url, label) { + return `${escapeHtml(label)}`; +} + +/** + * Builds the Help handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ +export function buildHelpHtml(locale) { + const lang = getLocale(locale); + const h = (key, vars) => escapeHtml(t(`handout.${key}`, lang, vars)); + const raw = (key) => tRaw(`handout.${key}`, lang); + const code = (text) => `${escapeHtml(text)}`; + const section = (key, body) => `

    ${h(`${key}.heading`)}

    ${body}`; + + const commands = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ].map(([cmd, key]) => [code(`${COMMAND} ${cmd}`.trim()), escapeHtml(t(`help.${key}`, lang))]); + + const settings = Object.keys(DEFAULT_CONFIG).map((key) => [ + code(key), + escapeHtml(t(`settings.${key}.label`, lang)), + escapeHtml(t(`settings.${key}.desc`, lang)) + + (PAGE_SETTING_KEYS.includes(key) ? ` ${h('settings.perPage')}` : ''), + ]); + + const legacyCommands = [ + ['!hexploration_showMenuMain', `${COMMAND}`], + ['!hexploration_fillPoly', `${COMMAND} fill`], + ['!hexploration_fillInversePoly', `${COMMAND} fill inverse`], + ['!hexploration_hexModifyProperty name&&…', `${COMMAND} name …`], + ['!hexploration_configModifyProperty …', `${COMMAND} set …`], + ].map(([v1, v2]) => [code(v1), code(v2)]); + + const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const { original, maintainer } = AUTHOR_LINKS; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${h('versionLabel')} ${SCRIPT_VERSION} • ${h('subtitle')}

    +
    + ${section('overview', `

    ${h('overview.body')}

    ${link(DEMO_GIF_URL, t('handout.overview.demo', lang))}

    `)} + ${section('quickStart', list(raw('quickStart.steps'), true))} + ${section('commands', `

    ${h('commands.intro')}

    ${table([t('handout.commands.colCommand', lang), t('handout.commands.colDesc', lang)], commands)}`)} + ${section('revealing', list(raw('revealing.points')))} + ${section('locations', list(raw('locations.points')))} + ${section('settings', `

    ${h('settings.intro')}

    ${table([t('handout.settings.colKey', lang), t('handout.settings.colName', lang), t('handout.settings.colDesc', lang)], settings)}`)} + ${section('jumpgate', list(raw('jumpgate.points')))} + ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} + ${section('troubleshooting', list(raw('troubleshooting.points')))} + ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section( + 'credits', + `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    +

    ${h('credits.maintainer')} ${link(maintainer.profile, maintainer.name)} • ${link(maintainer.github, 'GitHub')}

    +

    ${h('credits.support')}

    ` + )} +
    ${SCRIPT_NAME} ${SCRIPT_VERSION} • ${h('footer', { deck: HANDOUT_DECK_NAME })}
    +
    `; +} + +/** + * Builds the Command Deck handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ +export function buildDeckHtml(locale) { + const lang = getLocale(locale); + const tr = (key, vars) => t(key, lang, vars); + const btn = (key, cmd, dark = false) => + `${escapeHtml(tr(`buttons.${key}`))}`; + const group = (titleKey, descKey, buttons) => + `
    ${escapeHtml(tr(titleKey))}
    ${escapeHtml(tr(descKey))}
    ${buttons.join('')}
    `; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +
    + ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} + ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} + ${group('menu.locations', 'deck.locationsDesc', [btn('mark', 'mark'), btn('unmark', 'unmark', true), btn('name', `name ?{${tr('prompts.name')}}`)])} + ${group('menu.tools', 'deck.toolsDesc', [btn('settings', 'set', true), btn('pageSettings', 'page', true), btn('status', 'status', true), btn('rescan', 'rescan', true), btn('calibrate', 'calibrate', true), btn('calibrateReset', 'calibrate reset', true), btn('help', 'help', true), btn('menu', '', true)])} +
    ${escapeHtml(tr('deck.footer', { help: HANDOUT_HELP_NAME }))}
    +
    `; +} + +/** + * Creates or updates a handout, removing duplicates with the same name. + * + * @param {string} name Handout name. + * @param {string} html Handout notes HTML. + * @returns {void} + */ +function upsertHandout(name, html) { + const existing = findObjs({ _type: 'handout', name }); + const [primary, ...duplicates] = existing; + const handout = primary || createObj('handout', { name }); + if (!handout) { + return; + } + handout.set({ inplayerjournals: '', controlledby: '' }); + handout.set('notes', html); + for (const dup of duplicates) { + dup.remove(); + } +} + +/** + * Creates or refreshes the Help and Command Deck handouts in the current language. + * + * @returns {void} + */ +export function installHandouts() { + const lang = getConfig().language; + upsertHandout(HANDOUT_HELP_NAME, buildHelpHtml(lang)); + upsertHandout(HANDOUT_DECK_NAME, buildDeckHtml(lang)); +} diff --git a/Hexploration/src/locales/index.js b/Hexploration/src/locales/index.js new file mode 100644 index 0000000000..b72ecbc382 --- /dev/null +++ b/Hexploration/src/locales/index.js @@ -0,0 +1,61 @@ +import localeAf from './locale/af.js'; +import localeCa from './locale/ca.js'; +import localeZhTW from './locale/zh-TW.js'; +import localeCs from './locale/cs.js'; +import localeDa from './locale/da.js'; +import localeNl from './locale/nl.js'; +import localeEnUS from './locale/en-US.js'; +import localeFi from './locale/fi.js'; +import localeFr from './locale/fr.js'; +import localeDe from './locale/de.js'; +import localeEl from './locale/el.js'; +import localeHe from './locale/he.js'; +import localeHu from './locale/hu.js'; +import localeIt from './locale/it.js'; +import localeJa from './locale/ja.js'; +import localeKo from './locale/ko.js'; +import localePl from './locale/pl.js'; +import localePtPT from './locale/pt-PT.js'; +import localePtBR from './locale/pt-BR.js'; +import localeRu from './locale/ru.js'; +import localeEs from './locale/es.js'; +import localeSv from './locale/sv.js'; +import localeTr from './locale/tr.js'; +import localeUk from './locale/uk.js'; + +export { + DEFAULT_LOCALE, + LOCALE_ALIASES, + LOCALE_DEFINITIONS, + LOCALE_LABELS, + SUPPORTED_LOCALE_LIST, + SUPPORTED_LOCALES, + VALID_LOCALES, +} from './metadata.js'; + +export const TRANSLATIONS = { + af: localeAf, + ca: localeCa, + 'zh-TW': localeZhTW, + cs: localeCs, + da: localeDa, + nl: localeNl, + 'en-US': localeEnUS, + fi: localeFi, + fr: localeFr, + de: localeDe, + el: localeEl, + he: localeHe, + hu: localeHu, + it: localeIt, + ja: localeJa, + ko: localeKo, + pl: localePl, + 'pt-PT': localePtPT, + 'pt-BR': localePtBR, + ru: localeRu, + es: localeEs, + sv: localeSv, + tr: localeTr, + uk: localeUk, +}; diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js new file mode 100644 index 0000000000..0c7a1fbc00 --- /dev/null +++ b/Hexploration/src/locales/locale/af.js @@ -0,0 +1,374 @@ +const TRANSLATION = { + titles: { + ready: "Heeksplorasie is gereed.", + settings: "Heksplorasie-instellings", + languages: "Kies 'n taal", + pageSettings: "Bladsyinstellings: {page}", + status: "Heksplorasiestatus: {page}", + help: "Heksplorasie-opdragte", + confirm: "Bevestig asseblief", + }, + discovery: { + title: "Ligging ontdek", + }, + menu: { + draw: "Teken", + reveal: "Openbaar en versteek", + locations: "Liggings", + tools: "Gereedskap", + layerInUse: "Nuwe hekse word op die {layer} geteken.", + pageSettingsHelp: + "Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.", + }, + buttons: { + fill: "Vul", + fillInverse: "Omgekeerde vul", + undo: "Ontdoen vul", + reveal: "Onthul", + conceal: "Versteek", + explore: "Verken", + revealPage: "Onthul bladsy", + resetPage: "Stel bladsy terug", + mark: "Merk ligging", + unmark: "Ontmerk", + name: "Noem Hex", + settings: "Instellings", + pageSettings: "Bladsy-instellings", + status: "Status", + rescan: "Skandeer weer", + calibrate: "Kalibreer", + calibrateReset: "Stel Kalibrasie terug", + help: "Help", + change: "Verander", + menu: "Spyskaart", + clearOverrides: "Vee oorskrywings uit", + confirmReset: "Ja, verwyder alle hekse", + }, + prompts: { + name: "Liggingnaam (laat leeg om skoon te maak)", + }, + values: { + on: "Aan", + off: "Af", + none: "Geen", + hexLayer: { + auto: "Outo (voorgrond indien beskikbaar)", + foreground: "voorgrond laag", + objects: "tekenlaag", + }, + revealBy: { + players: "Speler tokens", + characters: "Karaktertekens", + all: "Alle tekens", + }, + revealMode: { + clear: "Duidelik", + glimpse: "Glimpie", + }, + announce: { + all: "Almal", + gm: "Slegs GM", + off: "Af", + }, + orientation: { + vertical: "Heks (V)", + horizontal: "Heks (H)", + }, + fillKind: { + fill: "Vul", + fillInverse: "Omgekeerde vul", + conceal: "Versteek", + }, + }, + settings: { + language: { + label: "Taal", + desc: "Taal vir spyskaarte, boodskappe en uitdeelstukke.", + }, + hexLayer: { + label: "Hex laag", + desc: "Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.", + }, + fillColor: { + label: "Vul kleur", + desc: "Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).", + }, + strokeColor: { + label: "Rand Kleur", + desc: "Kleur van die buitelyn van nuwe hekse.", + }, + labelColor: { + label: "Etiket Kleur", + desc: "Kleur van die GM-net naametikette op benoemde hekse.", + }, + glimpseColor: { + label: "Glimp kleur", + desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + }, + strokeWidth: { + label: "Grens breedte", + desc: "Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).", + }, + maxDistance: { + label: "Hex Reveal Distance", + desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + }, + revealDistance: { + label: "Sigafstand", + desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + }, + lineOfSight: { + label: "Siglyn", + desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + }, + revealPath: { + label: "Openbaar Langs Pad", + desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + }, + revealBy: { + label: "Tekens wat openbaar", + desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + }, + revealMode: { + label: "Onthullingsmodus", + desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + }, + announce: { + label: "Kondig ontdekkings aan", + desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + }, + pingDiscoveries: { + label: "Ping Ontdekkings", + desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + }, + }, + status: { + engine: "Spel enjin", + grid: "Rooster", + layer: "Hex laag", + hexes: "Hekse", + named: "Benoemde hekse", + icons: "Liggingtekens", + glimpsed: "Geskimpte hekkies", + pending: "Liggings wat wag vir 'n vulling", + calibrated: "Gekalibreer", + overrides: "Bladsy ignoreer", + undo: "Ontdoen beskikbaar", + }, + messages: { + filled: + "Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.", + revealed: "{count} hekkies geopenbaar.", + revealedPage: "Alle {count} hekse op die bladsy is geopenbaar.", + confirmReset: + 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: "{count} hekse van die bladsy verwyder.", + undone: + "Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.", + named: '{count} heksies genaamd "{name}".', + unnamed: "Naam verwyder van {count} hekse.", + marked: + "{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.", + unmarked: "{count} tekens is nie meer liggings nie.", + settingChanged: "{setting} gestel na {value}.", + rescanned: + "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + calibrated: + "Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.", + calibrationReset: + "Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.", + journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', + migrated: + "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + pruned: + "{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.", + readyHint: + 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + }, + warnings: { + foregroundUnavailable: + "Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.", + someFailed: + "{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.", + }, + errors: { + noPage: "Kon nie die bladsy vind om aan te werk nie.", + notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + noPolygons: "Kies een of meer getekende vorms om te vul.", + emptyArea: "Die geselekteerde area bevat geen heksasiemiddels nie.", + tooMany: "Dit sal {count} hexes skep, wat te veel in een slag is.", + nothingToConceal: "Kies getekende vorms of tekens om te versteek.", + nothingToReveal: "Kies hekkies, getekende vorms of tekens om te openbaar.", + noTokens: "Kies eers een of meer tekens.", + noHexes: "Kies eers een of meer hekse (of tekens wat op hekse staan).", + nothingToUndo: "Daar is geen vul om ongedaan te maak nie.", + unknownCommand: "Onbekende opdrag: {command}", + unknownSetting: "Onbekende instelling: {key}", + unknownPageSetting: "Instellings wat per bladsy gestel kan word: {keys}", + invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', + calibrateNeedsTokens: + "Kies een of twee tokens wat aan heksende middelpunte geknip is.", + calibrateFailed: "Daardie tekens kan nie gebruik word om te kalibreer nie.", + unexpected: "Iets het verkeerd geloop: {message}", + }, + hints: { + noPage: "Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.", + notHex: + "Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.", + noPolygons: + "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", + emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", + tooMany: "Vul `n kleiner area, of verdeel die area in verskeie vorms.", + noHexes: + "Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.", + unknownCommand: "Tik !hexploration help om die opdragte te lys.", + unknownSetting: "Tik !hexploration set om elke instelling te sien.", + calibrateNeedsTokens: + "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + calibrateFailed: + "Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.", + unexpected: "Besonderhede is in die API-konsole-logboek.", + }, + help: { + menu: "Wys die spyskaart.", + fill: "Bedek die geselekteerde getekende vorms met hekse.", + fillInverse: "Bedek die hele bladsy behalwe binne die geselekteerde vorms.", + undo: "Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.", + reveal: + "Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.", + revealPage: "Onthul elke heksie op die bladsy sonder aankondigings.", + conceal: + "Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.", + explore: + "Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.", + resetPage: "Verwyder elke heks op die bladsy (vra eers).", + name: "Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.", + mark: "Verander die geselekteerde tekens in versteekte liggings.", + unmark: "Stop dat die geselekteerde tokens versteekte liggings is.", + set: "Verander 'n instelling, of wys alle instellings.", + pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", + pageClear: "Verwyder die huidige bladsy se ignorering.", + rescan: + "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + calibrate: + "Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.", + calibrateReset: "Verwyder die huidige bladsy se kalibrasie.", + status: "Wys wat Hexploration van die huidige bladsy weet.", + journal: "Herbou die hulp- en beveldek-uitdeelstukke.", + help: "Wys hierdie lys.", + handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', + }, + deck: { + subtitle: "Beveldek", + drawDesc: + "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + revealDesc: + "Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.", + locationsDesc: + "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + toolsDesc: + "Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.", + footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', + }, + handout: { + versionLabel: "Weergawe", + subtitle: "Heks-vir-heks verkenning vir Roll20", + footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', + overview: { + heading: "Oorsig", + body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", + }, + quickStart: { + heading: "Vinnige Begin", + steps: [ + "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", + "Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.", + "Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.", + "Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.", + "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + ], + }, + commands: { + heading: "Opdragte", + intro: + "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", + colCommand: "Bevel", + colDesc: "Wat dit doen", + }, + revealing: { + heading: "Hoe onthulling werk", + points: [ + "Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.", + "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", + "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", + "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", + "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", + "Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.", + ], + }, + locations: { + heading: "Genoemde hekse en liggings", + points: [ + "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", + "Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.", + "Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.", + "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + "Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.", + ], + }, + settings: { + heading: "Instellings", + intro: + "Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.", + colKey: "Sleutel", + colName: "Instelling", + colDesc: "Beskrywing", + perPage: "(Kan per bladsy gestel word.)", + }, + jumpgate: { + heading: "Jumpgate en Legacy", + points: [ + "Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.", + "Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.", + "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + ], + }, + upgrading: { + heading: "Opgradering vanaf weergawe 1", + points: [ + "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", + "Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.", + "Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.", + "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + ], + colV1: "Weergawe 1 opdrag", + colV2: "Weergawe 2 opdrag", + }, + troubleshooting: { + heading: "Probleemoplossing", + points: [ + "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", + "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", + "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", + "Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.", + "Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.", + ], + }, + languages: { + heading: "Tale", + body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + }, + credits: { + heading: "Krediete", + original: "Oorspronklike mod deur", + maintainer: "Weergawe 2 onderhou deur", + marketplace: "Ada se kunspakkies op die Roll20 Marketplace", + support: + "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js new file mode 100644 index 0000000000..cd19ce55cf --- /dev/null +++ b/Hexploration/src/locales/locale/ca.js @@ -0,0 +1,380 @@ +const TRANSLATION = { + titles: { + ready: "L'exploració està a punt.", + settings: "Configuració d'exploració", + languages: "Trieu un idioma", + pageSettings: "Configuració de la pàgina: {page}", + status: "Estat de l'exploració: {page}", + help: "Comandes d'exploració", + confirm: "Si us plau, confirmeu", + }, + discovery: { + title: "Localització descoberta", + }, + menu: { + draw: "Dibuixa", + reveal: "Revela i amaga", + locations: "Ubicacions", + tools: "Eines", + layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + pageSettingsHelp: + "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", + }, + buttons: { + fill: "Omplir", + fillInverse: "Farciment invers", + undo: "Desfer el farciment", + reveal: "Revelar", + conceal: "Ocultar", + explore: "Explora", + revealPage: "Revela la pàgina", + resetPage: "Restableix la pàgina", + mark: "Marca la ubicació", + unmark: "Desmarca", + name: "Nom Hex", + settings: "Configuració", + pageSettings: "Configuració de la pàgina", + status: "Estat", + rescan: "Torna a escanejar", + calibrate: "Calibrar", + calibrateReset: "Restableix la calibració", + help: "Ajuda", + change: "Canviar", + menu: "Menú", + clearOverrides: "Esborra les substitucions", + confirmReset: "Sí, traieu tots els hexagones", + }, + prompts: { + name: "Nom de la ubicació (deixeu en blanc per esborrar)", + }, + values: { + on: "Encès", + off: "Apagat", + none: "Cap", + hexLayer: { + auto: "Automàtic (en primer pla si està disponible)", + foreground: "capa de primer pla", + objects: "capa de testimoni", + }, + revealBy: { + players: "Fitxes de jugador", + characters: "Fitxes de personatges", + all: "Totes les fitxes", + }, + revealMode: { + clear: "Clar", + glimpse: "Un cop d'ull", + }, + announce: { + all: "Tothom", + gm: "Només GM", + off: "Apagat", + }, + orientation: { + vertical: "Hexadecimal (V)", + horizontal: "Hex (H)", + }, + fillKind: { + fill: "Omplir", + fillInverse: "Farciment invers", + conceal: "Ocultar", + }, + }, + settings: { + language: { + label: "Llengua", + desc: "Idioma per a menús, missatges i fullets.", + }, + hexLayer: { + label: "Capa hexagonal", + desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + }, + fillColor: { + label: "Color de farciment", + desc: "Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).", + }, + strokeColor: { + label: "Color de la vora", + desc: "Color del contorn dels nous hexagonals.", + }, + labelColor: { + label: "Color de l'etiqueta", + desc: "Color de les etiquetes de nom només de GM en hexadecims amb nom.", + }, + glimpseColor: { + label: "Color d'ull", + desc: "Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.", + }, + strokeWidth: { + label: "Amplada de la vora", + desc: "Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).", + }, + maxDistance: { + label: "Distància de revelació hexagonal", + desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", + }, + revealDistance: { + label: "Distància de visió", + desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + }, + lineOfSight: { + label: "Línia de visió", + desc: "Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.", + }, + revealPath: { + label: "Revela al llarg del camí", + desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + }, + revealBy: { + label: "Fitxes que revelen", + desc: "Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.", + }, + revealMode: { + label: "Mode de revelació", + desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + }, + announce: { + label: "Anunciar descobriments", + desc: "Qui veu el missatge de xat quan es descobreix una ubicació amb nom.", + }, + pingDiscoveries: { + label: "Ping Descobriments", + desc: "Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.", + }, + }, + status: { + engine: "Motor de joc", + grid: "Quadrícula", + layer: "Capa hexagonal", + hexes: "Hexes", + named: "Hexagones anomenats", + icons: "Fitxes d'ubicació", + glimpsed: "Hexagones albirats", + pending: "Ubicacions a l'espera d'omplir-se", + calibrated: "Calibrat", + overrides: "Anul·lació de la pàgina", + undo: "Desfer disponible", + }, + messages: { + filled: + "Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.", + revealed: "{count} hexadecimals revelats.", + revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + confirmReset: + 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: "{count} hexadecimals eliminats de la pàgina.", + undone: + "Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.", + named: '{count} hexadecimals anomenats "{name}".', + unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + marked: + "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", + unmarked: "Les fitxes {count} ja no són ubicacions.", + settingChanged: "{setting} s'ha establert en {value}.", + rescanned: + "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + calibrated: + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + calibrationReset: + "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', + migrated: + "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + pruned: + "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + readyHint: + 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + }, + warnings: { + foregroundUnavailable: + "Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.", + someFailed: + "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + }, + errors: { + noPage: "No s'ha pogut trobar la pàgina per treballar.", + notHex: "Aquesta pàgina no utilitza una graella hexadecimal.", + noPolygons: "Seleccioneu una o més formes dibuixades per omplir.", + emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", + tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", + nothingToConceal: "Seleccioneu formes dibuixades o fitxes per ocultar.", + nothingToReveal: + "Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.", + noTokens: "Seleccioneu primer un o més fitxes.", + noHexes: + "Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).", + nothingToUndo: "No hi ha cap emplenament per desfer.", + unknownCommand: "Ordre desconeguda: {command}", + unknownSetting: "Configuració desconeguda: {key}", + unknownPageSetting: "Configuració que es pot establir per pàgina: {keys}", + invalidValue: '"{value}" no és un valor vàlid per a {key}.', + calibrateNeedsTokens: + "Seleccioneu una o dues fitxes encaixades als centres hexagonals.", + calibrateFailed: "Aquestes fitxes no es poden utilitzar per calibrar.", + unexpected: "S'ha produït un error: {message}", + }, + hints: { + noPage: + "Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.", + notHex: + "Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.", + noPolygons: + "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", + emptyArea: + "Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.", + tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", + noHexes: + "Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.", + unknownCommand: "Escriviu !hexploration help per llistar les ordres.", + unknownSetting: "Escriviu !hexploration set per veure tots els paràmetres.", + calibrateNeedsTokens: + "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + calibrateFailed: + "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + unexpected: "Els detalls es troben al registre de la consola de l'API.", + }, + help: { + menu: "Mostra el menú.", + fill: "Cobriu les formes dibuixades seleccionades amb hexagonals.", + fillInverse: + "Cobriu tota la pàgina excepte dins de les formes seleccionades.", + undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + reveal: + "Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.", + revealPage: "Revela cada hexadecimal de la pàgina sense anuncis.", + conceal: + "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: + "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: "Traieu tots els hexadecimals de la pàgina (demana primer).", + name: "Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.", + mark: "Converteix les fitxes seleccionades en llocs ocults.", + unmark: "Deixeu que les fitxes seleccionades siguin ubicacions ocultes.", + set: "Canvia un paràmetre o mostra tots els paràmetres.", + pageSet: + "Substituïu una configuració de revelació només a la pàgina actual.", + pageClear: "Elimina les substitucions de la pàgina actual.", + rescan: + "Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.", + calibrate: + "Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.", + calibrateReset: "Elimineu el calibratge de la pàgina actual.", + status: "Mostra què sap Hexploration sobre la pàgina actual.", + journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + help: "Mostra aquesta llista.", + handout: 'Les instruccions completes es troben al fullet "{name}".', + }, + deck: { + subtitle: "Comandament de la plataforma", + drawDesc: + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + revealDesc: + "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + locationsDesc: + "Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.", + toolsDesc: + "Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.", + footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', + }, + handout: { + versionLabel: "Versió", + subtitle: "Exploració hexadecimal per hexadecimal per a Roll20", + footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', + overview: { + heading: "Visió general", + body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + demo: "Mira una petita demostració (de la versió 1)", + }, + quickStart: { + heading: "Inici ràpid", + steps: [ + "Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).", + "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", + "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", + "Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.", + ], + }, + commands: { + heading: "Ordres", + intro: + "Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.", + colCommand: "Comandament", + colDesc: "Què fa", + }, + revealing: { + heading: "Com funciona la revelació", + points: [ + "Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.", + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", + "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", + "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + ], + }, + locations: { + heading: "Hexes i ubicacions anomenades", + points: [ + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", + "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", + "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + ], + }, + settings: { + heading: "Configuració", + intro: + "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + colKey: "clau", + colName: "Configuració", + colDesc: "Descripció", + perPage: "(Es pot configurar per pàgina.)", + }, + jumpgate: { + heading: "Jumpgate i Legacy", + points: [ + "Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.", + "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", + "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + ], + }, + upgrading: { + heading: "Actualització de la versió 1", + points: [ + "La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.", + "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + "Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.", + "La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.", + ], + colV1: "Comandament de la versió 1", + colV2: "Comandament de la versió 2", + }, + troubleshooting: { + heading: "Resolució de problemes", + points: [ + "No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).", + "Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.", + "Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.", + "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", + ], + }, + languages: { + heading: "Idiomes", + body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + }, + credits: { + heading: "Crèdits", + original: "Mod original de", + maintainer: "Versió 2 mantinguda per", + marketplace: "Els paquets d'art de l'Ada al mercat Roll20", + support: + "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js new file mode 100644 index 0000000000..7689b35747 --- /dev/null +++ b/Hexploration/src/locales/locale/cs.js @@ -0,0 +1,379 @@ +const TRANSLATION = { + titles: { + ready: "Heexploration je připraven.", + settings: "Nastavení Heexploration", + languages: "Vyberte jazyk", + pageSettings: "Nastavení stránky: {page}", + status: "Stav průzkumu: {page}", + help: "Příkazy pro průzkum", + confirm: "Prosím potvrďte", + }, + discovery: { + title: "Místo objeveno", + }, + menu: { + draw: "Remíza", + reveal: "Odhalit a skrýt", + locations: "Místa", + tools: "Nástroje", + layerInUse: "Na {layer} se kreslí nové hexy.", + pageSettingsHelp: + "Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.", + }, + buttons: { + fill: "Vyplnit", + fillInverse: "Inverzní výplň", + undo: "Vrátit zpět výplň", + reveal: "Odhalit", + conceal: "Skrývat", + explore: "Prozkoumat", + revealPage: "Odhalit stránku", + resetPage: "Obnovit stránku", + mark: "Označte umístění", + unmark: "Zrušit označení", + name: "Jméno Hex", + settings: "Nastavení", + pageSettings: "Nastavení stránky", + status: "Postavení", + rescan: "Znovu naskenujte", + calibrate: "Kalibrovat", + calibrateReset: "Resetovat kalibraci", + help: "Pomoc", + change: "Přeměna", + menu: "Menu", + clearOverrides: "Vymazat přepisy", + confirmReset: "Ano, Odebrat všechny hexy", + }, + prompts: { + name: "Název místa (pro vymazání ponechte prázdné)", + }, + values: { + on: "Na", + off: "Vypnuto", + none: "Žádný", + hexLayer: { + auto: "Auto (popředí, pokud je k dispozici)", + foreground: "vrstva popředí", + objects: "vrstva tokenů", + }, + revealBy: { + players: "Hráčské žetony", + characters: "Žetony postav", + all: "Všechny tokeny", + }, + revealMode: { + clear: "Jasný", + glimpse: "Záblesk", + }, + announce: { + all: "Každý", + gm: "Pouze GM", + off: "Vypnuto", + }, + orientation: { + vertical: "Hexadecimální (V)", + horizontal: "Hexadecimální (H)", + }, + fillKind: { + fill: "Vyplnit", + fillInverse: "Inverzní výplň", + conceal: "Skrývat", + }, + }, + settings: { + language: { + label: "Jazyk", + desc: "Jazyk pro nabídky, zprávy a letáky.", + }, + hexLayer: { + label: "Hexadecimální vrstva", + desc: "Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.", + }, + fillColor: { + label: "Barva výplně", + desc: "Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).", + }, + strokeColor: { + label: "Barva ohraničení", + desc: "Barva obrysu nových hexů.", + }, + labelColor: { + label: "Barva štítku", + desc: "Barva jmenovek pouze GM na pojmenovaných hexech.", + }, + glimpseColor: { + label: "Barva záblesku", + desc: "Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().", + }, + strokeWidth: { + label: "Šířka okraje", + desc: "Šířka obrysu nových hexů v pixelech (0 až 20).", + }, + maxDistance: { + label: "Hexadecimální vzdálenost odhalení", + desc: "Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.", + }, + revealDistance: { + label: "Pohledová vzdálenost", + desc: "Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.", + }, + lineOfSight: { + label: "Zornost", + desc: "Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.", + }, + revealPath: { + label: "Odhalení Po cestě", + desc: "Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.", + }, + revealBy: { + label: "Tokeny, které odhalují", + desc: "Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.", + }, + revealMode: { + label: "Režim odhalení", + desc: "Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.", + }, + announce: { + label: "Oznamte objevy", + desc: "Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.", + }, + pingDiscoveries: { + label: "Ping Discovery", + desc: "Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.", + }, + }, + status: { + engine: "Herní engine", + grid: "Mřížka", + layer: "Hexadecimální vrstva", + hexes: "Hexy", + named: "Pojmenované hexy", + icons: "Tokeny polohy", + glimpsed: "Zahlédnuté hexy", + pending: "Místa čekající na zaplnění", + calibrated: "Zkalibrováno", + overrides: "Přepíše stránku", + undo: "Zpět k dispozici", + }, + messages: { + filled: + "Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.", + revealed: "{count} odhalených hexů.", + revealedPage: "Všechny {count} hexy na stránce odhaleny.", + confirmReset: + "Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.", + resetPage: "{count} hexy odstraněny ze stránky.", + undone: + "Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.", + named: "{count} hexy s názvem „{name}“.", + unnamed: "Název byl vymazán z {count} hexů.", + marked: + "{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.", + unmarked: "{count} tokeny již nejsou umístění.", + settingChanged: "{setting} nastaveno na {value}.", + rescanned: + "Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.", + calibrated: + "Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.", + calibrationReset: + "Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.", + journalRebuilt: "Materiály „{help}“ a „{deck}“ byly přepracovány.", + migrated: + "Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.", + pruned: + "{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.", + readyHint: + "Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.", + }, + warnings: { + foregroundUnavailable: + "Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.", + someFailed: + "{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.", + }, + errors: { + noPage: "Nelze najít stránku, na které by se dalo pracovat.", + notHex: "Tato stránka nepoužívá hexadecimální mřížku.", + noPolygons: + "Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.", + emptyArea: "Vybraná oblast neobsahuje žádné středy šestihran.", + tooMany: "To by vytvořilo {count} hexů, což je příliš mnoho najednou.", + nothingToConceal: + "Vyberte nakreslené tvary nebo žetony, které chcete skrýt.", + nothingToReveal: + "Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.", + noTokens: "Nejprve vyberte jeden nebo více žetonů.", + noHexes: + "Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).", + nothingToUndo: "Neexistuje žádná výplň, kterou lze vrátit zpět.", + unknownCommand: "Neznámý příkaz: {command}", + unknownSetting: "Neznámé nastavení: {key}", + unknownPageSetting: "Nastavení, která lze nastavit na stránce: {keys}", + invalidValue: "„{value}“ není platná hodnota pro {key}.", + calibrateNeedsTokens: + "Vyberte jeden nebo dva žetony přichycené na středy hexů.", + calibrateFailed: "Tyto tokeny nelze použít ke kalibraci.", + unexpected: "Něco se pokazilo: {message}", + }, + hints: { + noPage: + "Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.", + notHex: + "Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.", + noPolygons: + "Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.", + emptyArea: + "Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.", + tooMany: "Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.", + noHexes: + "Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.", + unknownCommand: + "Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.", + unknownSetting: + "Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.", + calibrateNeedsTokens: + "Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.", + calibrateFailed: + "Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.", + unexpected: "Podrobnosti jsou v protokolu konzoly API.", + }, + help: { + menu: "Ukaž menu.", + fill: "Zakryjte vybrané nakreslené tvary hexy.", + fillInverse: "Zakryjte celou stránku kromě vybraných tvarů.", + undo: "Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.", + reveal: "Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.", + revealPage: "Odhalte každé hex na stránce bez oznámení.", + conceal: "Znovu zakryjte oblast pod vybranými tvary a žetony hexy.", + explore: "Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.", + resetPage: "Odstraňte každý hex na stránce (nejprve se ptá).", + name: "Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.", + mark: "Proměňte vybrané žetony na skrytá místa.", + unmark: "Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.", + set: "Změňte nastavení nebo zobrazte všechna nastavení.", + pageSet: "Přepsat nastavení odkrytí pouze na aktuální stránce.", + pageClear: "Odstraňte přepsání aktuální stránky.", + rescan: + "Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.", + calibrate: + "Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.", + calibrateReset: "Odstraňte kalibraci aktuální stránky.", + status: "Ukažte, co Heexploration ví o aktuální stránce.", + journal: "Znovu sestavte podklady pro balíček nápovědy a příkazů.", + help: "Zobrazit tento seznam.", + handout: "Úplné pokyny jsou v letáku „{name}“.", + }, + deck: { + subtitle: "Velitelský balíček", + drawDesc: + "Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.", + revealDesc: + "Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.", + locationsDesc: + "Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.", + toolsDesc: + "Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.", + footer: "Úplné pokyny naleznete v letáku „{help}“.", + }, + handout: { + versionLabel: "Verze", + subtitle: "Průzkum hex po hexu pro Roll20", + footer: "Pro ovládání jedním kliknutím použijte leták „{deck}“.", + overview: { + heading: "Přehled", + body: "Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.", + demo: "Podívejte se na krátkou ukázku (od verze 1)", + }, + quickStart: { + heading: "Rychlý start", + steps: [ + "Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).", + "Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.", + "Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.", + "Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.", + "Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.", + ], + }, + commands: { + heading: "Příkazy", + intro: + "Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.", + colCommand: "Příkaz", + colDesc: "Co to dělá", + }, + revealing: { + heading: "Jak funguje odhalování", + points: [ + "Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.", + "Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.", + "Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.", + "Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.", + "V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.", + "API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.", + ], + }, + locations: { + heading: "Pojmenované hexy a umístění", + points: [ + "Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.", + "Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.", + "Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.", + "Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.", + "Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.", + ], + }, + settings: { + heading: "Nastavení", + intro: + "Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.", + colKey: "Klíč", + colName: "Nastavení", + colDesc: "Popis", + perPage: "(Lze nastavit na stránku.)", + }, + jumpgate: { + heading: "Jumpgate a Legacy", + points: [ + "Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.", + "Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.", + "Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.", + "Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.", + ], + }, + upgrading: { + heading: "Upgrade z verze 1", + points: [ + "Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.", + "Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.", + "Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.", + "Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.", + ], + colV1: "Příkaz verze 1", + colV2: "Příkaz verze 2", + }, + troubleshooting: { + heading: "Odstraňování problémů", + points: [ + "Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).", + "Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.", + "Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.", + "Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.", + "Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.", + ], + }, + languages: { + heading: "Jazyky", + body: "Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:", + }, + credits: { + heading: "Kredity", + original: "Původní mod od", + maintainer: "Verze 2 spravovaná společností", + marketplace: "Adiny umělecké balíčky na Roll20 Marketplace", + support: + "Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js new file mode 100644 index 0000000000..f40e4849cd --- /dev/null +++ b/Hexploration/src/locales/locale/da.js @@ -0,0 +1,377 @@ +const TRANSLATION = { + titles: { + ready: "Hexploration er klar.", + settings: "Indstillinger for Hexploration", + languages: "Vælg et sprog", + pageSettings: "Sideindstillinger: {page}", + status: "Hexploration Status: {page}", + help: "Hexploration kommandoer", + confirm: "Bekræft venligst", + }, + discovery: { + title: "Sted opdaget", + }, + menu: { + draw: "Tegne", + reveal: "Afsløre og skjul", + locations: "Steder", + tools: "Værktøjer", + layerInUse: "Nye sekskanter bliver tegnet på {layer}.", + pageSettingsHelp: + "Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.", + }, + buttons: { + fill: "Fylde", + fillInverse: "Omvendt fyld", + undo: "Fortryd Fyld", + reveal: "Afsløre", + conceal: "Skjule", + explore: "Udforske", + revealPage: "Afsløre side", + resetPage: "Nulstil side", + mark: "Marker placering", + unmark: "Fjern markering", + name: "Navn Hex", + settings: "Indstillinger", + pageSettings: "Sideindstillinger", + status: "Status", + rescan: "Scan igen", + calibrate: "Kalibrer", + calibrateReset: "Nulstil kalibrering", + help: "Hjælp", + change: "Forandring", + menu: "Menu", + clearOverrides: "Ryd tilsidesættelser", + confirmReset: "Ja, Fjern alle Hexes", + }, + prompts: { + name: "Placeringsnavn (lad tom for at rydde)", + }, + values: { + on: "På", + off: "Slukket", + none: "Ingen", + hexLayer: { + auto: "Auto (forgrund, hvis tilgængelig)", + foreground: "forgrundslaget", + objects: "symbollag", + }, + revealBy: { + players: "Spillerpoletter", + characters: "Karakter tokens", + all: "Alle tokens", + }, + revealMode: { + clear: "Klar", + glimpse: "Glimt", + }, + announce: { + all: "Alle sammen", + gm: "Kun GM", + off: "Slukket", + }, + orientation: { + vertical: "Hex (V)", + horizontal: "Hex (H)", + }, + fillKind: { + fill: "Fylde", + fillInverse: "Omvendt fyld", + conceal: "Skjule", + }, + }, + settings: { + language: { + label: "Sprog", + desc: "Sprog til menuer, beskeder og uddelingskopier.", + }, + hexLayer: { + label: "Hex lag", + desc: "Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.", + }, + fillColor: { + label: "Fyld farve", + desc: "Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).", + }, + strokeColor: { + label: "Kantfarve", + desc: "Farve på omridset af nye sekskanter.", + }, + labelColor: { + label: "Etiket farve", + desc: "Farven på GM-only navneetiketter på navngivne sekskanter.", + }, + glimpseColor: { + label: "Glimt farve", + desc: "Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.", + }, + strokeWidth: { + label: "Border Bredde", + desc: "Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).", + }, + maxDistance: { + label: "Hex Reveal Distance", + desc: "Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.", + }, + revealDistance: { + label: "Synsafstand", + desc: "Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.", + }, + lineOfSight: { + label: "Synslinie", + desc: "Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.", + }, + revealPath: { + label: "Afsløre langs stien", + desc: "Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.", + }, + revealBy: { + label: "Tokens, der afslører", + desc: "Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.", + }, + revealMode: { + label: "Reveal Mode", + desc: "Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.", + }, + announce: { + label: "Annoncer opdagelser", + desc: "Hvem ser chatbeskeden, når en navngivet placering opdages.", + }, + pingDiscoveries: { + label: "Ping opdagelser", + desc: "Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.", + }, + }, + status: { + engine: "Spil motor", + grid: "Gitter", + layer: "Hex lag", + hexes: "Hekser", + named: "Navngivne hexes", + icons: "Placeringstokens", + glimpsed: "Glimpede sekskanter", + pending: "Steder, der venter på udfyldning", + calibrated: "Kalibreret", + overrides: "Side tilsidesætter", + undo: "Fortryd tilgængelig", + }, + messages: { + filled: + "Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.", + revealed: "{count} hexes afsløret.", + revealedPage: "Alle {count} hexes på siden afsløret.", + confirmReset: + 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: "{count} sekskanter fjernet fra siden.", + undone: + "Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.", + named: '{count} hexes med navnet "{name}".', + unnamed: "Navnet er ryddet fra {count} hexes.", + marked: + "{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.", + unmarked: "{count} tokens er ikke længere placeringer.", + settingChanged: "{setting} indstillet til {value}.", + rescanned: + "Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.", + calibrated: + "Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.", + calibrationReset: + "Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.", + journalRebuilt: + 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + migrated: + "Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.", + pruned: + "{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.", + readyHint: + 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + }, + warnings: { + foregroundUnavailable: + "Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.", + someFailed: + "{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.", + }, + errors: { + noPage: "Kunne ikke finde siden at arbejde på.", + notHex: "Denne side bruger ikke et hex-gitter.", + noPolygons: "Vælg en eller flere tegnede figurer, der skal udfyldes.", + emptyArea: "Det valgte område indeholder ingen hex-centre.", + tooMany: "Det ville skabe {count} hexes, hvilket er for mange på én gang.", + nothingToConceal: "Vælg tegnede figurer eller tokens til at skjule.", + nothingToReveal: + "Vælg sekskanter, tegnede figurer eller tokens for at afsløre.", + noTokens: "Vælg først et eller flere tokens.", + noHexes: + "Vælg først en eller flere hexes (eller poletter stående på hexes).", + nothingToUndo: "Der er ingen udfyldning at fortryde.", + unknownCommand: "Ukendt kommando: {command}", + unknownSetting: "Ukendt indstilling: {key}", + unknownPageSetting: "Indstillinger, der kan indstilles pr. side: {keys}", + invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', + calibrateNeedsTokens: "Vælg et eller to tokens fastgjort til hex-centre.", + calibrateFailed: "Disse tokens kan ikke bruges til at kalibrere.", + unexpected: "Noget gik galt: {message}", + }, + hints: { + noPage: "Åbn den side, du vil arbejde på, eller vælg noget på den.", + notHex: + "Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.", + noPolygons: + "Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.", + emptyArea: + "Tegn en større form, eller kontroller indstillingerne for sidegitteret.", + tooMany: "Udfyld et mindre område, eller opdel området i flere former.", + noHexes: + "Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.", + unknownCommand: "Skriv !hexploration help for at vise kommandoerne.", + unknownSetting: "Skriv !hexploration set for at se alle indstillinger.", + calibrateNeedsTokens: + "Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.", + calibrateFailed: + "To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.", + unexpected: "Detaljer er i API-konsolloggen.", + }, + help: { + menu: "Vis menuen.", + fill: "Dæk de valgte tegnede figurer med sekskanter.", + fillInverse: "Dæk hele siden undtagen inde i de valgte former.", + undo: "Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.", + reveal: "Afslør de valgte hexes og hexes under de valgte former og tokens.", + revealPage: "Afslør hver hex på siden uden meddelelser.", + conceal: + "Dæk området under de valgte former og tokens med sekskanter igen.", + explore: + "Afslør omkring de valgte tokens, som om de lige var flyttet dertil.", + resetPage: "Fjern hver hex på siden (spørg først).", + name: "Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.", + mark: "Gør de valgte tokens til skjulte placeringer.", + unmark: "Stop de valgte tokens med at være skjulte placeringer.", + set: "Skift en indstilling, eller vis alle indstillinger.", + pageSet: "Tilsidesæt kun en afsløringsindstilling på den aktuelle side.", + pageClear: "Fjern den aktuelle sides tilsidesættelser.", + rescan: + "Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.", + calibrate: + "Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.", + calibrateReset: "Fjern den aktuelle sides kalibrering.", + status: "Vis, hvad Hexploration ved om den aktuelle side.", + journal: "Genopbyg hjælpe- og kommandodækket-uddelingsarkene.", + help: "Vis denne liste.", + handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', + }, + deck: { + subtitle: "Kommandodæk", + drawDesc: + "Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.", + revealDesc: + "Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.", + locationsDesc: + "Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.", + toolsDesc: + "Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.", + footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', + }, + handout: { + versionLabel: "Version", + subtitle: "Hex-by-hex-udforskning for Roll20", + footer: + 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + overview: { + heading: "Oversigt", + body: "Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.", + demo: "Se en kort demo (fra version 1)", + }, + quickStart: { + heading: "Hurtig start", + steps: [ + "Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).", + "Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.", + "Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.", + "Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.", + "Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.", + ], + }, + commands: { + heading: "Kommandoer", + intro: + "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", + colCommand: "Kommando", + colDesc: "Hvad den gør", + }, + revealing: { + heading: "Sådan fungerer afsløring", + points: [ + "Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.", + "Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.", + "Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.", + "Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.", + "I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.", + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + ], + }, + locations: { + heading: "Navngivne Hekser og Steder", + points: [ + "Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.", + "Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.", + "Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.", + "Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.", + "Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.", + ], + }, + settings: { + heading: "Indstillinger", + intro: + "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + colKey: "Nøgle", + colName: "Indstilling", + colDesc: "Beskrivelse", + perPage: "(Kan indstilles pr. side.)", + }, + jumpgate: { + heading: "Jumpgate og Legacy", + points: [ + "Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.", + "Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.", + "Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.", + "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + ], + }, + upgrading: { + heading: "Opgradering fra version 1", + points: [ + "Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.", + "Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.", + "Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.", + "Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.", + ], + colV1: "Version 1 kommando", + colV2: "Version 2 kommando", + }, + troubleshooting: { + heading: "Fejlfinding", + points: [ + "Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).", + "Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.", + "Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.", + "Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.", + "For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.", + ], + }, + languages: { + heading: "Sprog", + body: "Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:", + }, + credits: { + heading: "Credits", + original: "Original mod af", + maintainer: "Version 2 vedligeholdes af", + marketplace: "Adas kunstpakker på Roll20 Marketplace", + support: + "Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/de.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/el.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/en-US.js b/Hexploration/src/locales/locale/en-US.js new file mode 100644 index 0000000000..c539e8eafc --- /dev/null +++ b/Hexploration/src/locales/locale/en-US.js @@ -0,0 +1,366 @@ +export default { + titles: { + ready: 'Hexploration is ready.', + settings: 'Hexploration Settings', + languages: 'Choose a Language', + pageSettings: 'Page Settings: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration Commands', + confirm: 'Please Confirm', + }, + discovery: { + title: 'Location Discovered', + }, + menu: { + draw: 'Draw', + reveal: 'Reveal and Hide', + locations: 'Locations', + tools: 'Tools', + layerInUse: 'New hexes are being drawn on the {layer}.', + pageSettingsHelp: + 'These settings apply to this page only. Settings marked ★ override the global settings.', + }, + buttons: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + undo: 'Undo Fill', + reveal: 'Reveal', + conceal: 'Conceal', + explore: 'Explore', + revealPage: 'Reveal Page', + resetPage: 'Reset Page', + mark: 'Mark Location', + unmark: 'Unmark', + name: 'Name Hex', + settings: 'Settings', + pageSettings: 'Page Settings', + status: 'Status', + rescan: 'Rescan', + calibrate: 'Calibrate', + calibrateReset: 'Reset Calibration', + help: 'Help', + change: 'Change', + menu: 'Menu', + clearOverrides: 'Clear Overrides', + confirmReset: 'Yes, Remove All Hexes', + }, + prompts: { + name: 'Location name (leave empty to clear)', + }, + values: { + on: 'On', + off: 'Off', + none: 'None', + hexLayer: { + auto: 'Auto (foreground if available)', + foreground: 'foreground layer', + objects: 'token layer', + }, + revealBy: { + players: 'Player tokens', + characters: 'Character tokens', + all: 'All tokens', + }, + revealMode: { + clear: 'Clear', + glimpse: 'Glimpse', + }, + announce: { + all: 'Everyone', + gm: 'GM only', + off: 'Off', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + conceal: 'Conceal', + }, + }, + settings: { + language: { + label: 'Language', + desc: 'Language for menus, messages and handouts.', + }, + hexLayer: { + label: 'Hex Layer', + desc: 'Where new hexes are drawn. Auto tries the foreground layer (above tokens) and falls back to the token layer if the game does not support it.', + }, + fillColor: { + label: 'Fill Colour', + desc: 'Colour of new hexes. Use rgba() for see-through hexes, for example rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Border Colour', + desc: 'Colour of the outline of new hexes.', + }, + labelColor: { + label: 'Label Colour', + desc: 'Colour of the GM-only name labels on named hexes.', + }, + glimpseColor: { + label: 'Glimpse Colour', + desc: 'Colour hexes change to when glimpsed (Glimpse reveal mode). Use a see-through rgba() colour.', + }, + strokeWidth: { + label: 'Border Width', + desc: 'Width of the outline of new hexes, in pixels (0 to 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Applied to hexes as they are drawn: a token must be within this many hexes to reveal them, however far it can see. Leave empty for no limit.', + }, + revealDistance: { + label: 'Sight Distance', + desc: 'How many hexes around a moving token are revealed (0 to 20). 0 reveals only the hexes the token passes through.', + }, + lineOfSight: { + label: 'Line of Sight', + desc: 'When on, a hex is only revealed if no covered hex lies between it and the token.', + }, + revealPath: { + label: 'Reveal Along Path', + desc: 'When on, every hex a token passes through while being dragged (including waypoints) is revealed, not just where it stops.', + }, + revealBy: { + label: 'Tokens That Reveal', + desc: 'Which tokens on the token layer reveal hexes: tokens controlled by a player, tokens that represent any character, or every token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear removes hexes within sight. Glimpse makes them see-through instead; they are removed when a token enters them.', + }, + announce: { + label: 'Announce Discoveries', + desc: 'Who sees the chat message when a named location is discovered.', + }, + pingDiscoveries: { + label: 'Ping Discoveries', + desc: 'When on, players are pinged to a named location when it is discovered.', + }, + hideCoveredTokens: { + label: 'Hide Covered Tokens', + desc: 'Roll20 draws names, bars and auras above hexes. When on, tokens under a covered hex have their player-visible name, bars and auras switched off, and switched back on when they are uncovered.', + }, + }, + status: { + engine: 'Game engine', + grid: 'Grid', + layer: 'Hex layer', + hexes: 'Hexes', + named: 'Named hexes', + icons: 'Location tokens', + glimpsed: 'Glimpsed hexes', + pending: 'Locations waiting for a fill', + calibrated: 'Calibrated', + overrides: 'Page overrides', + undo: 'Undo available', + }, + messages: { + filled: + 'Fill complete. Hexes drawn: {created}. Restyled: {restyled}. Locations hidden: {icons}.', + revealed: 'Hexes revealed: {count}.', + revealedPage: 'Every hex on the page revealed ({count}).', + confirmReset: + 'Remove every hex from "{page}" ({count})? Location tokens return to the token layer. Undo cannot reverse this.', + resetPage: 'Hexes removed from the page: {count}.', + undone: 'Last fill undone. Hexes removed: {removed}. Restyled hexes restored: {restored}.', + named: 'Hexes named "{name}": {count}.', + unnamed: 'Names cleared: {count}.', + marked: + 'Locations hidden in existing hexes: {attached}. Waiting for the next fill that covers them: {pending}.', + unmarked: 'Tokens that are no longer locations: {count}.', + settingChanged: '{setting} set to {value}.', + rescanned: + 'Rescan complete. Kept: {kept}. Adopted: {adopted}. Re-filed: {moved}. Missing and forgotten: {dropped}. Labels re-linked: {labels}. Location tokens re-linked: {icons}.', + calibrated: + 'Grid calibrated (column step {colStep}px, row step {rowStep}px). Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + calibrationReset: + 'Calibration removed. Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + 'Your Hexploration 1.x hex maps have been upgraded. If this game was copied from a Legacy game, run Rescan on each hex map page.', + pruned: + 'Saved hexes that no longer exist and were forgotten: {dropped}. If this game or page was copied, run Rescan on the page to pick its hexes up again.', + readyHint: + 'Type !hexploration for the menu, or open the "Hexploration - Command Deck" handout.', + }, + warnings: { + foregroundUnavailable: + 'This game does not support drawing on the foreground layer, so hexes were drawn on the token layer.', + someFailed: 'Hexes that could not be drawn: {count}. Check the API console for details.', + }, + errors: { + noPage: 'Could not find the page to work on.', + notHex: 'This page does not use a hex grid.', + noPolygons: 'Select one or more drawn shapes to fill.', + emptyArea: 'The selected area does not contain any hex centres.', + tooMany: 'That would create too many hexes in one go ({count}).', + nothingToConceal: 'Select drawn shapes or tokens to conceal.', + nothingToReveal: 'Select hexes, drawn shapes or tokens to reveal.', + noTokens: 'Select one or more tokens first.', + noHexes: 'Select one or more hexes (or tokens standing on hexes) first.', + nothingToUndo: 'There is no fill to undo.', + unknownCommand: 'Unknown command: {command}', + unknownSetting: 'Unknown setting: {key}', + unknownPageSetting: 'Settings that can be set per page: {keys}', + invalidValue: '"{value}" is not a valid value for {key}.', + calibrateNeedsTokens: 'Select one or two tokens snapped to hex centres.', + calibrateFailed: 'Those tokens cannot be used to calibrate.', + unexpected: 'Something went wrong: {message}', + }, + hints: { + noPage: 'Open the page you want to work on, or select something on it.', + notHex: 'Set the page grid to Hex (V) or Hex (H) in Page Settings.', + noPolygons: + 'Draw a polygon, rectangle, ellipse or freehand shape around the area, select it, then try again.', + emptyArea: 'Draw a larger shape, or check the page grid settings.', + tooMany: 'Fill a smaller area, or split the area into several shapes.', + noHexes: 'Hexes are on the foreground or token layer; switch to that layer to select them.', + unknownCommand: 'Type !hexploration help to list the commands.', + unknownSetting: 'Type !hexploration set to see every setting.', + calibrateNeedsTokens: + 'Snap a token to the centre of a hex and select it. Select a second token snapped to a neighbouring hex in the same row (Hex V) or column (Hex H) to correct the hex size too.', + calibrateFailed: + 'Two tokens must be in the same row (Hex V) or the same column (Hex H), at least one hex apart.', + unexpected: 'Details are in the API console log.', + }, + help: { + menu: 'Show the menu.', + fill: 'Cover the selected drawn shapes with hexes.', + fillInverse: 'Cover the whole page except inside the selected shapes.', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: 'Reveal the selected hexes, and the hexes under the selected shapes and tokens.', + revealPage: 'Reveal every hex on the page without announcements.', + conceal: 'Cover the area under the selected shapes and tokens with hexes again.', + explore: 'Reveal around the selected tokens as if they had just moved there.', + resetPage: 'Remove every hex on the page (asks first).', + name: 'Name the selected hexes, or the hexes under the selected tokens. Leave the name empty to clear it.', + mark: 'Turn the selected tokens into hidden locations.', + unmark: 'Stop the selected tokens being hidden locations.', + set: 'Change a setting, or show all settings.', + pageSet: 'Override a reveal setting on the current page only.', + pageClear: 'Remove the current page’s overrides.', + rescan: 'Rebuild the page’s hex list, for example after copying a page or game.', + calibrate: 'Line the hex grid up with one or two selected tokens snapped to hex centres.', + calibrateReset: 'Remove the current page’s calibration.', + status: 'Show what Hexploration knows about the current page.', + journal: 'Rebuild the Help and Command Deck handouts.', + help: 'Show this list.', + handout: 'Full instructions are in the "{name}" handout.', + }, + deck: { + subtitle: 'Command Deck', + drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', + revealDesc: + 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', + locationsDesc: + 'Select tokens to hide them as locations under hexes. Select hexes or tokens to name a hex.', + toolsDesc: + 'Settings, page overrides, status, rescanning copied pages and calibrating the grid.', + footer: 'See the "{help}" handout for full instructions.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex exploration for Roll20', + footer: 'Use the "{deck}" handout for one-click controls.', + overview: { + heading: 'Overview', + body: 'Hexploration covers a hex map with opaque hexes. As the party moves, the hexes they pass through (and, if you like, the hexes around them) are removed, so the map is uncovered one hex at a time. Hidden locations can be placed under hexes and are announced when found. It works in Jumpgate and Legacy games, on Hex (V) and Hex (H) grids of any size.', + demo: 'Watch a short demo (from version 1)', + }, + quickStart: { + heading: 'Quick Start', + steps: [ + 'Open a page whose grid is set to Hex (V) or Hex (H).', + 'Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide.', + 'Select the shapes and click Fill in the Command Deck (or type !hexploration fill). The shapes are replaced by hexes.', + 'Optional: before filling, select tokens for important places and click Mark Location. They are hidden under the hexes and announced when discovered.', + 'Move a player token. Every hex it passes through, and the hexes within its Sight Distance, are revealed.', + ], + }, + commands: { + heading: 'Commands', + intro: + 'Only GMs can use these commands. Most act on the selected objects; the rest act on the page you are viewing.', + colCommand: 'Command', + colDesc: 'What it does', + }, + revealing: { + heading: 'How Revealing Works', + points: [ + 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', + 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', + 'Sight Distance reveals the hexes around each of those hexes. With Line of Sight on, a hex is only revealed if no covered hex lies in between.', + 'Hex Reveal Distance is stored on hexes as they are drawn. Those hexes are only revealed from within that many hexes, however far a token can see. Use it for mountains or forests that hide what is behind them.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them.', + 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + ], + }, + locations: { + heading: 'Named Hexes and Locations', + points: [ + 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', + 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', + 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', + ], + }, + settings: { + heading: 'Settings', + intro: + 'Change settings with !hexploration set (or the Settings button). Hex Layer, Tokens That Reveal and Language can also be set on the Mod’s settings page.', + colKey: 'Key', + colName: 'Setting', + colDesc: 'Description', + perPage: '(Can be set per page.)', + }, + jumpgate: { + heading: 'Jumpgate and Legacy', + points: [ + 'Hexploration works out which engine the game uses and draws the matching kind of shape. Shapes drawn in either editor can be filled.', + 'With Hex Layer set to Auto, hexes are drawn on the foreground layer, above tokens, so players cannot see what is underneath. If the foreground layer is not available, the token layer is used instead.', + 'Jumpgate draws mathematically regular hexes, which are a slightly different shape from Legacy hexes. If the hexes do not line up with a page’s grid, snap a token to a hex centre, select it and click Calibrate. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size too.', + 'When a page or game is copied, its hexes get new IDs. Run Rescan on the page to pick them up again, together with their name labels and location tokens.', + ], + }, + upgrading: { + heading: 'Upgrading from Version 1', + points: [ + 'Version 2 no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. You can remove them unless another mod uses them.', + 'Existing hex maps, names, location tokens and settings are upgraded automatically on the first start.', + 'The version 1 commands, including the Hexploration_menu macro, still work.', + 'Version 1 let any token that represented a character reveal hexes. Set Tokens That Reveal to Character tokens to keep that behaviour.', + ], + colV1: 'Version 1 command', + colV2: 'Version 2 command', + }, + troubleshooting: { + heading: 'Troubleshooting', + points: [ + 'Nothing happens when a token moves: check the token is on the token layer and matches Tokens That Reveal, and that the page has hexes (!hexploration status).', + 'Hexes are offset from the grid: use Calibrate, then check with a token on a few hexes across the map.', + 'Hexes stopped revealing after copying a page or game: run Rescan on the page.', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: 'Languages', + body: 'Choose a language with !hexploration set language. Available languages:', + }, + credits: { + heading: 'Credits', + original: 'Original mod by', + maintainer: 'Version 2 maintained by', + marketplace: 'Ada’s art packs on the Roll20 Marketplace', + support: + 'If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log.', + }, + }, +}; diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/es.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/fi.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/fr.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/he.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/hu.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/it.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/ja.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/ko.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/nl.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/pl.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/ru.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/sv.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/tr.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js new file mode 100644 index 0000000000..ff8b4c5632 --- /dev/null +++ b/Hexploration/src/locales/locale/uk.js @@ -0,0 +1 @@ +export default {}; diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js new file mode 100644 index 0000000000..4da711f792 --- /dev/null +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -0,0 +1,363 @@ +const TRANSLATION = { + titles: { + ready: "H探索已準備就緒。", + settings: "H探索設置", + languages: "選擇語言", + pageSettings: "頁面設定：{page}", + status: "H探索狀態：{page}", + help: "探索命令", + confirm: "請確認", + }, + discovery: { + title: "發現地點", + }, + menu: { + draw: "畫", + reveal: "顯示和隱藏", + locations: "地點", + tools: "工具", + layerInUse: "正在 {layer} 上繪製新的六角形。", + pageSettingsHelp: "這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。", + }, + buttons: { + fill: "充滿", + fillInverse: "反向填充", + undo: "撤銷填充", + reveal: "揭示", + conceal: "隱藏", + explore: "探索", + revealPage: "顯示頁面", + resetPage: "重置頁面", + mark: "標記位置", + unmark: "取消標記", + name: "名稱十六進位", + settings: "設定", + pageSettings: "頁面設定", + status: "地位", + rescan: "重新掃描", + calibrate: "校準", + calibrateReset: "重置校準", + help: "幫助", + change: "改變", + menu: "選單", + clearOverrides: "清除覆蓋", + confirmReset: "是的，刪除所有六角形", + }, + prompts: { + name: "地點名稱（留空以清除）", + }, + values: { + on: "在", + off: "離開", + none: "沒有任何", + hexLayer: { + auto: "自動（前景，如果可用）", + foreground: "前景層", + objects: "令牌層", + }, + revealBy: { + players: "玩家代幣", + characters: "Character tokens", + all: "所有代幣", + }, + revealMode: { + clear: "清除", + glimpse: "一瞥", + }, + announce: { + all: "每個人", + gm: "限通用汽車", + off: "離開", + }, + orientation: { + vertical: "六角 (V)", + horizontal: "六角 (H)", + }, + fillKind: { + fill: "充滿", + fillInverse: "反向填充", + conceal: "隱藏", + }, + }, + settings: { + language: { + label: "語言", + desc: "選單、訊息和講義的語言。", + }, + hexLayer: { + label: "六角層", + desc: "繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。", + }, + fillColor: { + label: "填充顏色", + desc: "新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。", + }, + strokeColor: { + label: "邊框顏色", + desc: "新六邊形輪廓的顏色。", + }, + labelColor: { + label: "標籤顏色", + desc: "命名六角形上僅限 GM 的名稱標籤的顏色。", + }, + glimpseColor: { + label: "瞥見顏色", + desc: "瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。", + }, + strokeWidth: { + label: "邊框寬度", + desc: "新六邊形輪廓的寬度，以像素為單位（0 到 20）。", + }, + maxDistance: { + label: "十六進位顯示距離", + desc: "應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。", + }, + revealDistance: { + label: "視距", + desc: "顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。", + }, + lineOfSight: { + label: "視線", + desc: "啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。", + }, + revealPath: { + label: "沿路徑顯示", + desc: "啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。", + }, + revealBy: { + label: "揭示的代幣", + desc: "令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。", + }, + revealMode: { + label: "揭示模式", + desc: "清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。", + }, + announce: { + label: "宣布發現", + desc: "當發現指定位置時誰會看到聊天訊息。", + }, + pingDiscoveries: { + label: "平發現", + desc: "啟用後，當發現指定位置時，玩家會被 ping 到該位置。", + }, + }, + status: { + engine: "遊戲引擎", + grid: "網格", + layer: "六角層", + hexes: "六角形", + named: "命名六角形", + icons: "位置標記", + glimpsed: "瞥見的六角形", + pending: "等待填補的地點", + calibrated: "已校準", + overrides: "頁面覆蓋", + undo: "可以撤銷", + }, + messages: { + filled: + "填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。", + revealed: "{count} 十六進位顯示。", + revealedPage: "顯示頁面上的所有 {count} 十六進位。", + confirmReset: + "從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。", + resetPage: "從頁面中刪除了 {count} 十六進位。", + undone: + "上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。", + named: "{count} 名為「{name}」的十六進位。", + unnamed: "從 {count} 十六進位清除名稱。", + marked: + "{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。", + unmarked: "{count} 標記不再是位置。", + settingChanged: "{setting} 設定為 {value}。", + rescanned: + "重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_", + calibrated: + "網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。", + calibrationReset: + "校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。", + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + "您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。", + pruned: + "{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。", + readyHint: + "在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。", + }, + warnings: { + foregroundUnavailable: + "遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。", + someFailed: "無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。", + }, + errors: { + noPage: "找不到要處理的頁面。", + notHex: "此頁面不使用六角網格。", + noPolygons: "選擇一個或多個要填滿的繪製形狀。", + emptyArea: "所選區域不包含任何六角形中心。", + tooMany: "這會建立 {count} 六角形，一次性就太多了。", + nothingToConceal: "選擇要隱藏的繪製形狀或標記。", + nothingToReveal: "選擇要顯示的六角形、繪製的形狀或標記。", + noTokens: "首先選擇一個或多個令牌。", + noHexes: "首先選擇一個或多個六角形（或站在六角形上的標記）。", + nothingToUndo: "沒有可撤消的填充。", + unknownCommand: "未知指令：{command}", + unknownSetting: "未知設定：{key}", + unknownPageSetting: "每頁可設定的設定：{keys}", + invalidValue: "“{value}”對於 {key} 不是有效值。", + calibrateNeedsTokens: "選擇一或兩個吸附到六角形中心的標記。", + calibrateFailed: "這些令牌不能用於校準。", + unexpected: "出了點問題：{message}", + }, + hints: { + noPage: "開啟您要處理的頁面，或選擇其中的某些內容。", + notHex: "在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。", + noPolygons: + "圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。", + emptyArea: "繪製更大的形狀，或檢查頁面網格設定。", + tooMany: "填滿較小的區域，或將該區域分割成多個形狀。", + noHexes: "六角形位於前景或令牌層；切換到該層以選擇它們。", + unknownCommand: "鍵入 !hexploration help 以列出指令。", + unknownSetting: "輸入 !hexploration set 查看每個設定。", + calibrateNeedsTokens: + "將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。", + calibrateFailed: + "兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。", + unexpected: "詳細資訊位於 API 控制台日誌中。", + }, + help: { + menu: "顯示選單。", + fill: "用六角形覆蓋選定的繪製形狀。", + fillInverse: "覆蓋除所選形狀內部之外的整個頁面。", + undo: "Undo the last fill, inverse fill or conceal, and restore the shapes it used.", + reveal: "顯示選定的六角形以及選定形狀和標記下的六角形。", + revealPage: "顯示頁面上的每個十六進制，無需公告。", + conceal: "再次用六角形覆蓋所選形狀和標記下方的區域。", + explore: "顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。", + resetPage: "刪除頁面上的每個十六進制（首先詢問）。", + name: "命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。", + mark: "將選取的標記變成隱藏位置。", + unmark: "停止將選定的標記隱藏在位置。", + set: "更改設定或顯示所有設定。", + pageSet: "僅覆蓋目前頁面上的顯示設定。", + pageClear: "刪除目前頁面的覆蓋。", + rescan: "重建頁面的十六進位列表，例如複製頁面或遊戲後。", + calibrate: "將六角形網格與對齊到六角形中心的一兩個選定標記對齊。", + calibrateReset: "刪除目前頁面的校準。", + status: "顯示 Hexploration 對目前頁面的了解。", + journal: "重建幫助和命令平台講義。", + help: "顯示此清單。", + handout: "完整說明位於「{name}」講義。", + }, + deck: { + subtitle: "指揮台", + drawDesc: + "在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。", + revealDesc: + "選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。", + locationsDesc: + "選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。", + toolsDesc: "設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。", + footer: "有關完整說明，請參閱“{help}”講義。", + }, + handout: { + versionLabel: "版本", + subtitle: "Roll20 的逐十六進位探索", + footer: "使用“{deck}”講義進行一鍵式控制項。", + overview: { + heading: "概述", + body: "Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。", + demo: "觀看簡短的演示（來自版本 1）", + }, + quickStart: { + heading: "快速入門", + steps: [ + "開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。", + "在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。", + "選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。", + "可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。", + "移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。", + ], + }, + commands: { + heading: "命令", + intro: + "只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。", + colCommand: "命令", + colDesc: "它的作用", + }, + revealing: { + heading: "揭示如何運作", + points: [ + "只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。", + "標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。", + "視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。", + "六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。", + "在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。", + "API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。", + ], + }, + locations: { + heading: "命名六角形和位置", + points: [ + "標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。", + "與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。", + "隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。", + "Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。", + "宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。", + ], + }, + settings: { + heading: "設定", + intro: + "使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。", + colKey: "鑰匙", + colName: "環境", + colDesc: "描述", + perPage: "（可按頁設定。）", + }, + jumpgate: { + heading: "跳躍門和遺產", + points: [ + "Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。", + "將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。", + "Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。", + "當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。", + ], + }, + upgrading: { + heading: "從版本 1 升級", + points: [ + "版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。", + "現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。", + "版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。", + "版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。", + ], + colV1: "版本 1 指令", + colV2: "版本 2 指令", + }, + troubleshooting: { + heading: "故障排除", + points: [ + "令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。", + "六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。", + "複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。", + "Fill says the area has no hex centres: the shape must contain the centre of at least one hex.", + "For anything else, check the API console log and include its messages when asking for help.", + ], + }, + languages: { + heading: "語言", + body: "透過 !hexploration 設定語言來選擇語言。可用語言：", + }, + credits: { + heading: "製作人員", + original: "原始模組由", + maintainer: "版本 2 維護者", + marketplace: "Roll20 Marketplace 上的 Ada 藝術包", + support: + "如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/metadata.js b/Hexploration/src/locales/metadata.js new file mode 100644 index 0000000000..351f1266cf --- /dev/null +++ b/Hexploration/src/locales/metadata.js @@ -0,0 +1,245 @@ +export const DEFAULT_LOCALE = 'en-US'; + +export const LOCALE_DEFINITIONS = Object.freeze([ + { + code: 'af', + name: 'Afrikaans', + direction: 'ltr', + translationFile: 'locale/af.js', + flag: '🇿🇦', + flagLabel: 'Flag of South Africa', + }, + { + code: 'ca', + name: 'Catalan', + nativeName: 'Català', + direction: 'ltr', + translationFile: 'locale/ca.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'zh-TW', + name: 'Chinese (Traditional)', + nativeName: '正體中文', + direction: 'ltr', + translationFile: 'locale/zh-TW.js', + aliases: ['zh'], + flag: '🇹🇼', + flagLabel: 'Flag of Taiwan', + }, + { + code: 'cs', + name: 'Czech', + nativeName: 'Čeština', + direction: 'ltr', + translationFile: 'locale/cs.js', + flag: '🇨🇿', + flagLabel: 'Flag of Czechia', + }, + { + code: 'da', + name: 'Danish', + nativeName: 'Dansk', + direction: 'ltr', + translationFile: 'locale/da.js', + flag: '🇩🇰', + flagLabel: 'Flag of Denmark', + }, + { + code: 'nl', + name: 'Dutch', + nativeName: 'Nederlands', + direction: 'ltr', + translationFile: 'locale/nl.js', + flag: '🇳🇱', + flagLabel: 'Flag of the Netherlands', + }, + { + code: 'en-US', + name: 'English', + nativeName: 'English', + direction: 'ltr', + translationFile: 'locale/en-US.js', + aliases: ['en'], + flag: '🇺🇸', + flagLabel: 'Flag of the United States', + }, + { + code: 'fi', + name: 'Finnish', + nativeName: 'Suomeksi', + direction: 'ltr', + translationFile: 'locale/fi.js', + flag: '🇫🇮', + flagLabel: 'Flag of Finland', + }, + { + code: 'fr', + name: 'French', + nativeName: 'Français', + direction: 'ltr', + translationFile: 'locale/fr.js', + flag: '🇫🇷', + flagLabel: 'Flag of France', + }, + { + code: 'de', + name: 'German', + nativeName: 'Deutsch', + direction: 'ltr', + translationFile: 'locale/de.js', + flag: '🇩🇪', + flagLabel: 'Flag of Germany', + }, + { + code: 'el', + name: 'Greek', + nativeName: 'Ελληνικά', + direction: 'ltr', + translationFile: 'locale/el.js', + flag: '🇬🇷', + flagLabel: 'Flag of Greece', + }, + { + code: 'he', + name: 'Hebrew', + nativeName: 'עברית', + direction: 'rtl', + translationFile: 'locale/he.js', + flag: '🇮🇱', + flagLabel: 'Flag of Israel', + }, + { + code: 'hu', + name: 'Hungarian', + nativeName: 'Magyar', + direction: 'ltr', + translationFile: 'locale/hu.js', + flag: '🇭🇺', + flagLabel: 'Flag of Hungary', + }, + { + code: 'it', + name: 'Italian', + nativeName: 'Italiano', + direction: 'ltr', + translationFile: 'locale/it.js', + flag: '🇮🇹', + flagLabel: 'Flag of Italy', + }, + { + code: 'ja', + name: 'Japanese', + nativeName: '日本語', + direction: 'ltr', + translationFile: 'locale/ja.js', + flag: '🇯🇵', + flagLabel: 'Flag of Japan', + }, + { + code: 'ko', + name: 'Korean', + nativeName: '한국어', + direction: 'ltr', + translationFile: 'locale/ko.js', + flag: '🇰🇷', + flagLabel: 'Flag of South Korea', + }, + { + code: 'pl', + name: 'Polish', + nativeName: 'Polski', + direction: 'ltr', + translationFile: 'locale/pl.js', + flag: '🇵🇱', + flagLabel: 'Flag of Poland', + }, + { + code: 'pt-PT', + name: 'Portuguese (Portugal)', + nativeName: 'Português - Portugal', + direction: 'ltr', + translationFile: 'locale/pt-PT.js', + aliases: ['pt'], + flag: '🇵🇹', + flagLabel: 'Flag of Portugal', + }, + { + code: 'pt-BR', + name: 'Portuguese (Brazil)', + nativeName: 'Português - Brasil', + direction: 'ltr', + translationFile: 'locale/pt-BR.js', + flag: '🇧🇷', + flagLabel: 'Flag of Brazil', + }, + { + code: 'ru', + name: 'Russian', + nativeName: 'Русский', + direction: 'ltr', + translationFile: 'locale/ru.js', + flag: '🇷🇺', + flagLabel: 'Flag of Russia', + }, + { + code: 'es', + name: 'Spanish', + nativeName: 'Español', + direction: 'ltr', + translationFile: 'locale/es.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'sv', + name: 'Swedish', + nativeName: 'Svenska', + direction: 'ltr', + translationFile: 'locale/sv.js', + flag: '🇸🇪', + flagLabel: 'Flag of Sweden', + }, + { + code: 'tr', + name: 'Turkish', + nativeName: 'Türkçe', + direction: 'ltr', + translationFile: 'locale/tr.js', + flag: '🇹🇷', + flagLabel: 'Flag of Turkey', + }, + { + code: 'uk', + name: 'Ukrainian', + nativeName: 'Українська', + direction: 'ltr', + translationFile: 'locale/uk.js', + flag: '🇺🇦', + flagLabel: 'Flag of Ukraine', + }, +]); + +export const SUPPORTED_LOCALES = Object.freeze(LOCALE_DEFINITIONS.map(({ code }) => code)); +export const VALID_LOCALES = new Set(SUPPORTED_LOCALES); +export const LOCALE_ALIASES = Object.freeze( + LOCALE_DEFINITIONS.reduce((aliases, locale) => { + for (const alias of locale.aliases || []) { + aliases[alias] = locale.code; + } + return aliases; + }, {}) +); +export const LOCALE_LABELS = Object.freeze( + LOCALE_DEFINITIONS.reduce((labels, locale) => { + const displayName = locale.nativeName + ? `${locale.code} - ${locale.name} (${locale.nativeName})` + : `${locale.code} - ${locale.name}`; + labels[locale.code] = displayName; + return labels; + }, {}) +); +export const SUPPORTED_LOCALE_LIST = SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join( + ' / ' +); diff --git a/Hexploration/src/main.js b/Hexploration/src/main.js deleted file mode 100644 index 2d8cb02622..0000000000 --- a/Hexploration/src/main.js +++ /dev/null @@ -1,342 +0,0 @@ -(() => { - 'use strict'; - - const CMD_FILL = '!hexploration_fillPoly'; - const CMD_FILL_INVERSE = '!hexploration_fillInversePoly'; - const CMD_SHOW_MENU = '!hexploration_showMenuMain'; - - /** - * Fills the area defined by some path with hex tiles. - * @param {Path} path - * @return {Path[]} - */ - function fillArea(path) { - let page = getObj('page', path.get('_pageid')); - - let hexes = getHexesInArea(path); - path.remove(); - return _fillHexes(page, hexes); - } - - /** - * Fills in the given hexes. - * @param {Page} page - * @param {tuple} hexes - * @return {Path[]} - */ - function _fillHexes(page, hexes) { - let config = Hexploration._state.getConfig(); - let pageId = page.get('_id'); - let tile = new Hexploration.HexagonTile(page); - - let locationMarkers = Hexploration._locations.getMarkers(page); - let locations = {}; - _.each(locationMarkers, marker => { - let x = marker.get('left'); - let y = marker.get('top'); - - let [row, column] = tile.getRowColumn(x, y); - locations[row + ',' + column] = marker; - }); - - return _.chain(hexes) - .map(hex => { - let [row, column] = hex; - - // If there is already a hex here, remove the existing hex so that - // we can replace it. - Hexploration._state.deleteHex(page, row, column); - - // Create the hex. - let hexagon = tile.getHexagon(row, column); - let hexPath = hexagon.render(pageId, 'objects', { - fill: config.fillColor, - stroke: config.strokeColor, - stroke_width: config.strokeWidth - }); - - let persistedHex = Hexploration._state.persistHex(page, hexPath, row, column); - persistedHex.maxDistance = config.maxDistance; - - // If there was a location marker at the hex's location, give the - // hex a name and remove the marker. - let marker = locations[row + ',' + column]; - if(marker) { - Hexploration._locations.setHexIcon(hexPath, marker); - } - - return hexPath; - }) - .compact() - .value(); - } - - /** - * Fills the page with hexes, except for in the areas specified by the - * provided paths. - * @param {Path[]} paths - * @return {Path[]} - */ - function fillInverseArea(paths) { - let page = getObj('page', paths[0].get('_pageid')); - - let omitHexes = []; - _.each(paths, path => { - let hexes = getHexesInArea(path); - omitHexes = omitHexes.concat(hexes); - path.remove(); - }); - - let hexes = []; - _.each(_.range(page.get('height')), row => { - _.each(_.range(page.get('width')), column => { - let isOmitted = _.find(omitHexes, hex => { - let [omitRow, omitColumn] = hex; - return row === omitRow && column === omitColumn; - }); - if(!isOmitted) - hexes.push([row, column]); - }); - }); - - return _fillHexes(page, hexes); - } - - /** - * Gets the row, column pairs for hexes contained in some area. - * @param {Path} path - * @return {vec2[]} - */ - function getHexesInArea(path) { - let page = getObj('page', path.get('_pageid')); - let tile = new Hexploration.HexagonTile(page); - - let poly = new PathMath.Polygon(path); - let bbox = poly.getBoundingBox(); - - // Determine the bounding rows and columns for the polygon. - let startRowCol = tile.getRowColumn(bbox.left, bbox.top); - let endRowCol = tile.getRowColumn(bbox.right, bbox.bottom); - - let rows = _.range(startRowCol[0], endRowCol[0] + 1); - let cols = _.range(startRowCol[1], endRowCol[1] + 1); - - // Get a list of the hex coordinates that fit in the area. - let hexes = []; - _.each(rows, row => { - _.each(cols, col => { - let center = tile.getCoordinates(row, col); - if(poly.containsPt(center)) - hexes.push([row, col]); - }); - }); - return hexes; - } - - /** - * Gets a HexagonTile for a page or an object residing on the page. - * @param {(Page|Path|Graphic)} obj - * @return {Hexploration.HexagonTile} - */ - function getHexTile(obj) { - let type = obj.get('_type'); - let page; - if(type === 'page') - page = getObj('page', obj.get('_id')); - else - page = getObj('page', obj.get('_pageid')); - - try { - return new Hexploration.HexagonTile(page); - } - catch(err) { - return undefined; - } - } - - /** - * Installs/updates a macro for the script. - * @param {string} name - * @param {string} action - */ - function _installMacro(player, name, action) { - let macro = findObjs({ - _type: 'macro', - _playerid: player.get('_id'), - name - })[0]; - - if(macro) - macro.set('action', action); - else { - createObj('macro', { - _playerid: player.get('_id'), - name, - action - }); - } - } - - /** - * Removes a hex from a page, given its row and column. - * @param {Page} page - * @param {int} row - * @param {int} column - * @param {uint} [distance] - */ - function revealHex(page, row, column, distance=0) { - let pageHex = Hexploration._state.getPageHex(page, row, column); - if(pageHex) { - // Skip the hex if the distance is further than the max distance. - if(distance > pageHex.maxDistance) - return; - - let hexPath = getObj('path', pageHex.id); - Hexploration._state.deletePath(hexPath); - hexPath.remove(); - - if(pageHex.iconId) { - let icon = getObj('graphic', pageHex.iconId); - if(icon) { - icon.set('layer', 'objects'); - icon.set('showname', true); - - let name = icon.get('name'); - let imgsrc = icon.get('imgsrc'); - Hexploration._menus.showDiscovery(name, imgsrc); - } - } - else if(pageHex.name) - Hexploration._menus.showDiscovery(pageHex.name); - } - } - - /** - * Reveals the hexes nearby a token, out to the configured reveal distance. - * @param {Graphic} obj - */ - function revealHexesAroundToken(obj) { - let config = Hexploration._state.getConfig(); - let page = getObj('page', obj.get('_pageid')); - let hexTile = getHexTile(page); - if(hexTile) { - let x = obj.get('left'); - let y = obj.get('top'); - - // Always reveal the hex the token moved onto. - let tokenHex = hexTile.getRowColumn(x, y); - let [row, column] = tokenHex; - revealHex(page, row, column); - - // Also reveal any nearby hexes, out to the configured reveal distance. - let nearbyHexes = hexTile.getNearbyHexes(row, column, config.revealDistance); - _.each(nearbyHexes, hex => { - // Skip revealing this hex if there is an unrevealed hex between it and - // the token. - let tweenHexes = hexTile.getTweenHexes(tokenHex, hex); - let lineOfSightBlocked = (tweenHexes.length > 0 && - !!_.find(tweenHexes, tweenHex => { - return Hexploration._state.hasPageHex(page, ...tweenHex); - })); - if(lineOfSightBlocked) - return; - - // We have line of sight. Reveal it if we're within its maximum - // distance. - let [row, column] = hex; - let distance = hexTile.getDistance(tokenHex, hex); - revealHex(page, row, column, distance); - }); - } - } - - // Interpret chat commands. - on('chat:message', msg => { - try { - if(msg.type !== 'api') - return; - - let argv = msg.content.split(' '); - if(argv[0] === CMD_FILL) { - if(msg.selected && msg.selected.length > 0) { - _.each(msg.selected, sel => { - let path = getObj('path', sel._id); - fillArea(path); - }); - } - else - throw new Error('You must select one or more polygons to be ' + - 'filled with hexes.'); - } - else if(argv[0] === CMD_FILL_INVERSE) { - if(msg.selected && msg.selected.length > 0) { - let paths = _.map(msg.selected, sel => { - return getObj('path', sel._id); - }); - fillInverseArea(paths); - } - else - throw new Error('You must select one or more polygons to be ' + - 'filled with hexes.'); - } - else if(argv[0] === CMD_SHOW_MENU) - Hexploration._menus.showMain(); - } - catch(err) { - Hexploration._chat.error(err); - } - }); - - // When a graphic is moved, see if it moved into an area concealed by a hex. - // If it did, reveal that hex. - on('change:graphic', (obj, prev) => { - try { - // Skip if the token doesn't represent a character. - if(!obj.get('represents')) - return; - - revealHexesAroundToken(obj); - } - catch(err) { - Hexploration._chat.error(err); - } - }); - - // When a hex is deleted, remove its data from the state. - on('destroy:path', path => { - try { - Hexploration._state.deletePath(path); - } - catch(err) { - Hexploration._chat.error(err); - } - }); - - // When the API is loaded, install the menu macro - // if it isn't already installed. - on('ready', () => { - let players = findObjs({ - _type: 'player' - }); - - // Create the macro, or update the players' old macro if they already have it. - _.each(players, player => { - if(playerIsGM(player.get('_id'))) { - _installMacro(player, 'Hexploration_menu', CMD_SHOW_MENU); - } - }); - - log('⬢⬢⬢ Initialized Hexploration vSCRIPT_VERSION ⬢⬢⬢'); - }); - - _.extend(Hexploration, { - CMD_FILL, - CMD_FILL_INVERSE, - CMD_SHOW_MENU, - fillArea, - fillInverseArea, - getHexesInArea, - getHexTile, - revealHex - }); -})(); diff --git a/Hexploration/src/paths.js b/Hexploration/src/paths.js new file mode 100644 index 0000000000..123d5dc875 --- /dev/null +++ b/Hexploration/src/paths.js @@ -0,0 +1,210 @@ +// Roll20 object access for drawn shapes. Jumpgate games draw `pathv2` +// objects; Legacy games draw `path` objects. Everything that reads or writes a +// path goes through this module so the rest of the mod never cares which. + +import { + LAYER_FOREGROUND, + LAYER_TOKEN, + PATH_TYPE_LEGACY, + PATH_TYPE_V2, + PATH_TYPES, +} from './constants.js'; +import { pathToRings, polygonPathProps } from './polygon.js'; +import { getConfig } from './state.js'; +import { isJumpgate } from './utils.js'; + +// Set when the foreground layer turns out to be unavailable, so later hexes +// go straight to the token layer instead of failing one by one. +let foregroundUnavailable = false; + +/** + * Returns a path object of either type by ID. + * + * @param {string} id Object ID. + * @param {string|null} [type] Known type, checked first. + * @returns {object|null} Roll20 path or pathv2 object. + */ +export function getPathObject(id, type = null) { + if (!id) { + return null; + } + const types = activePathTypes(); + const order = type && types.includes(type) ? [type, ...types.filter((t) => t !== type)] : types; + for (const t of order) { + const obj = getObj(t, id); + if (obj) { + return obj; + } + } + return null; +} + +/** + * Returns true when a Roll20 object is a path of either type. + * + * @param {object} obj Roll20 object. + * @returns {boolean} True for path and pathv2. + */ +export function isPathObject(obj) { + return !!obj && PATH_TYPES.includes(obj.get('_type')); +} + +/** + * Copies the properties the polygon module needs from a path. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {object} Plain properties including `type`. + */ +export function readPathProps(obj) { + const type = obj.get('_type'); + const base = { + type, + pageId: obj.get('_pageid'), + layer: obj.get('layer'), + rotation: obj.get('rotation'), + fill: obj.get('fill'), + stroke: obj.get('stroke'), + stroke_width: obj.get('stroke_width'), + }; + if (type === PATH_TYPE_V2) { + return { + ...base, + shape: obj.get('shape'), + points: obj.get('points'), + x: obj.get('x'), + y: obj.get('y'), + }; + } + return { + ...base, + _path: obj.get('_path'), + left: obj.get('left'), + top: obj.get('top'), + width: obj.get('width'), + height: obj.get('height'), + scaleX: obj.get('scaleX'), + scaleY: obj.get('scaleY'), + }; +} + +/** + * Returns a path's outline as page-space rings. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {number[][][]} Rings. + */ +export function getPathRings(obj) { + const props = readPathProps(obj); + const page = getObj('page', props.pageId); + return pathToRings(props, page ? { width: page.get('width'), height: page.get('height') } : {}); +} + +/** + * Recreates a path from properties saved by readPathProps (used by undo). + * + * @param {object} props Saved properties. + * @returns {object|null} New Roll20 object. + */ +export function recreatePath(props) { + const { type, pageId, ...rest } = props; + const attrs = { _pageid: pageId }; + for (const [key, value] of Object.entries(rest)) { + if (value !== undefined && value !== null) { + attrs[key] = value; + } + } + // A Legacy game cannot create pathv2 objects, and vice versa. + const createType = type === PATH_TYPE_V2 && !isJumpgate() ? PATH_TYPE_LEGACY : type; + return createObj(createType, attrs) || null; +} + +/** + * Returns the layer new hexes should be drawn on. + * + * @returns {string} Roll20 layer. + */ +export function getHexLayer() { + const setting = getConfig().hexLayer; + if (setting === 'objects' || foregroundUnavailable) { + return LAYER_TOKEN; + } + return LAYER_FOREGROUND; +} + +/** + * Draws a hex outline as a path. + * + * The foreground layer is tried first (unless the GM chose the token layer); + * if the game rejects it, the hex is drawn on the token layer instead and the + * fallback is remembered for the rest of the session. + * + * @param {string} pageId Page ID. + * @param {number[][]} corners Hex corners in page pixels. + * @param {object} style Style with fill, stroke and strokeWidth. + * @returns {{obj: object, fellBack: boolean}|null} New path, or null when it could not be created. + */ +export function createHexPath(pageId, corners, style) { + const jumpgate = isJumpgate(); + const type = jumpgate ? PATH_TYPE_V2 : PATH_TYPE_LEGACY; + const geometry = polygonPathProps(corners, jumpgate); + const attrs = { + ...geometry, + _pageid: pageId, + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + controlledby: '', + }; + + const layer = getHexLayer(); + let obj = createObj(type, { ...attrs, layer }); + if (obj && obj.get('layer') === layer) { + return { obj, fellBack: false }; + } + + if (layer === LAYER_FOREGROUND) { + if (obj) { + obj.remove(); + } + foregroundUnavailable = true; + obj = createObj(type, { ...attrs, layer: LAYER_TOKEN }); + return obj ? { obj, fellBack: true } : null; + } + return obj ? { obj, fellBack: false } : null; +} + +/** + * Removes a Roll20 object if it still exists. + * + * @param {object|null} obj Roll20 object. + * @returns {void} + */ +export function safeRemove(obj) { + if (obj) { + try { + obj.remove(); + } catch (err) { + log(`Hexploration: could not remove object: ${err?.message || err}`); + } + } +} + +/** + * Returns every path of either type on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Roll20 path objects. + */ +export function getPagePaths(pageId) { + return activePathTypes().flatMap((type) => findObjs({ _type: type, _pageid: pageId })); +} + +/** + * Returns the path types that can exist in this game. Jumpgate games can + * hold both (old API-made paths survive); Legacy games only have `path`. + * + * @returns {string[]} Path types. + */ +function activePathTypes() { + return isJumpgate() ? PATH_TYPES : [PATH_TYPE_LEGACY]; +} diff --git a/Hexploration/src/polygon.js b/Hexploration/src/polygon.js new file mode 100644 index 0000000000..5761b0e9b5 --- /dev/null +++ b/Hexploration/src/polygon.js @@ -0,0 +1,366 @@ +// Polygon maths for Roll20 drawn shapes. Pure functions only: callers pass +// plain property objects, so the module can be unit tested in Node. +// +// Both kinds of Roll20 path store points relative to their own bounding box +// and are placed by their centre: +// - Legacy `path`: `_path` is a JSON list of SVG-like commands (M, L, Q, C), +// placed by left/top, sized by width/height, scaled by scaleX/scaleY. +// - Jumpgate `pathv2`: `points` is a JSON list of [x, y] pairs interpreted by +// `shape` (pol, free, rec, eli) and placed by x/y. It has no scale. +// Both can be rotated by `rotation` degrees about their centre. + +const UNIT_PX = 70; +const ELLIPSE_SEGMENTS = 32; +const CURVE_SEGMENTS = 8; + +/** + * Returns the bounding box of a list of points. + * + * @param {number[][]} points Array of [x, y]. + * @returns {{left: number, top: number, right: number, bottom: number}} Bounding box. + */ +export function boundingBox(points) { + let left = Infinity; + let top = Infinity; + let right = -Infinity; + let bottom = -Infinity; + for (const [x, y] of points) { + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x); + bottom = Math.max(bottom, y); + } + return { left, top, right, bottom }; +} + +/** + * Tests whether a point lies inside a polygon ring (even-odd rule). The ring + * is treated as closed whether or not its last point repeats the first. + * + * @param {number[]} point [x, y]. + * @param {number[][]} ring Array of [x, y]. + * @returns {boolean} True when inside. + */ +export function pointInRing(point, ring) { + const [x, y] = point; + let inside = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const [xi, yi] = ring[i]; + const [xj, yj] = ring[j]; + const crosses = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi; + if (crosses) { + inside = !inside; + } + } + return inside; +} + +/** + * Tests whether a point lies inside any of a shape's rings (even-odd across + * rings, so a ring drawn inside another makes a hole). + * + * @param {number[]} point [x, y]. + * @param {number[][][]} rings Array of rings. + * @returns {boolean} True when inside. + */ +export function pointInShape(point, rings) { + let inside = false; + for (const ring of rings) { + if (ring.length >= 3 && pointInRing(point, ring)) { + inside = !inside; + } + } + return inside; +} + +/** + * Builds a transform from path-local coordinates to page pixels. + * + * @param {object} t Transform values. + * @returns {(x: number, y: number) => number[]} Point transform. + */ +function makeTransform({ width, height, cx, cy, scaleX = 1, scaleY = 1, rotation = 0 }) { + const angle = ((Number(rotation) || 0) * Math.PI) / 180; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + return (x, y) => { + const lx = (x - width / 2) * scaleX; + const ly = (y - height / 2) * scaleY; + return [cx + lx * cos - ly * sin, cy + lx * sin + ly * cos]; + }; +} + +/** + * Samples a quadratic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 Control point. + * @param {number[]} p2 End point. + * @returns {number[][]} Points after the start point. + */ +function sampleQuadratic(p0, p1, p2) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + points.push([ + u * u * p0[0] + 2 * u * t * p1[0] + t * t * p2[0], + u * u * p0[1] + 2 * u * t * p1[1] + t * t * p2[1], + ]); + } + return points; +} + +/** + * Samples a cubic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 First control point. + * @param {number[]} p2 Second control point. + * @param {number[]} p3 End point. + * @returns {number[][]} Points after the start point. + */ +function sampleCubic(p0, p1, p2, p3) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + const a = u * u * u; + const b = 3 * u * u * t; + const c = 3 * u * t * t; + const d = t * t * t; + points.push([ + a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], + a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1], + ]); + } + return points; +} + +/** + * Converts a Legacy path's command list into rings in path-local coordinates. + * + * @param {Array[]} commands Parsed `_path` commands. + * @returns {number[][][]} Rings. + */ +function legacyCommandsToRings(commands) { + const rings = []; + let ring = []; + let prevType = null; + for (const cmd of commands) { + if (!Array.isArray(cmd)) { + continue; + } + const [type, ...args] = cmd; + const nums = args.map(Number); + const prev = ring.at(-1); + if (type === 'M' && prevType !== 'M') { + if (ring.length > 0) { + rings.push(ring); + } + ring = [[nums[0], nums[1]]]; + } else if (type === 'L' || type === 'M') { + // Two consecutive Ms are drawn by Roll20 as a line, so treat the second as L. + ring.push([nums[0], nums[1]]); + } else if (type === 'Q' && prev) { + ring.push(...sampleQuadratic(prev, [nums[0], nums[1]], [nums[2], nums[3]])); + } else if (type === 'C' && prev) { + ring.push(...sampleCubic(prev, [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]])); + } + prevType = type; + } + if (ring.length > 0) { + rings.push(ring); + } + return rings; +} + +/** + * Returns points approximating an ellipse inside a box. + * + * @param {number} width Box width. + * @param {number} height Box height. + * @returns {number[][]} Points in box-local coordinates. + */ +function ellipsePoints(width, height) { + const points = []; + for (let i = 0; i < ELLIPSE_SEGMENTS; i++) { + const angle = (i / ELLIPSE_SEGMENTS) * Math.PI * 2; + points.push([ + width / 2 + (Math.cos(angle) * width) / 2, + height / 2 + (Math.sin(angle) * height) / 2, + ]); + } + return points; +} + +/** + * Parses a JSON string, returning null on failure. + * + * @param {string} text JSON text. + * @returns {*} Parsed value, or null. + */ +function safeJson(text) { + try { + return JSON.parse(text); + } catch { + return null; + } +} + +/** + * Converts a Legacy path's properties into page-space rings. + * + * @param {object} props Path properties (_path, left, top, width, height, scaleX, scaleY, rotation). + * @param {object} [page] Page size in units ({ width, height }) for mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ +export function legacyPathToRings(props, page = {}) { + const raw = String(props._path || props.path || '') + .replaceAll('mapWidth', String((Number(page.width) || 0) * UNIT_PX)) + .replaceAll('mapHeight', String((Number(page.height) || 0) * UNIT_PX)); + const commands = safeJson(raw); + if (!Array.isArray(commands)) { + return []; + } + const transform = makeTransform({ + width: Number(props.width) || 0, + height: Number(props.height) || 0, + cx: Number(props.left) || 0, + cy: Number(props.top) || 0, + scaleX: Number(props.scaleX) || 1, + scaleY: Number(props.scaleY) || 1, + rotation: props.rotation, + }); + return legacyCommandsToRings(commands).map((ring) => ring.map(([x, y]) => transform(x, y))); +} + +/** + * Converts a Jumpgate pathv2's properties into page-space rings. + * + * @param {object} props Path properties (points, shape, x, y, rotation). + * @returns {number[][][]} Rings in page pixels. + */ +export function pathV2ToRings(props) { + const parsed = safeJson(props.points); + if (!Array.isArray(parsed) || parsed.length === 0) { + return []; + } + const raw = parsed + .filter((p) => Array.isArray(p) && p.length >= 2) + .map(([x, y]) => [Number(x), Number(y)]) + .filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)); + if (raw.length === 0) { + return []; + } + + // Points are normalised so the bounding box starts at 0,0. + const box = boundingBox(raw); + const local = raw.map(([x, y]) => [x - box.left, y - box.top]); + const width = box.right - box.left; + const height = box.bottom - box.top; + + let ring; + if (props.shape === 'rec') { + ring = [ + [0, 0], + [width, 0], + [width, height], + [0, height], + ]; + } else if (props.shape === 'eli') { + ring = ellipsePoints(width, height); + } else { + ring = local; + } + + const transform = makeTransform({ + width, + height, + cx: Number(props.x) || 0, + cy: Number(props.y) || 0, + rotation: props.rotation, + }); + return [ring.map(([x, y]) => transform(x, y))]; +} + +/** + * Converts either kind of path into page-space rings. + * + * @param {object} props Path properties including `type` ('path' or 'pathv2'). + * @param {object} [page] Page size in units, for Legacy mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ +export function pathToRings(props, page) { + if (props.type === 'pathv2') { + return pathV2ToRings(props); + } + return legacyPathToRings(props, page); +} + +/** + * Builds the properties for a closed polygon as either kind of path. + * Points are made relative to their bounding box, and the path is placed by + * its centre, matching how Roll20 stores both path types. + * + * @param {number[][]} points Polygon corners in page pixels. + * @param {boolean} jumpgate True to build a pathv2, false for a Legacy path. + * @returns {object} Geometry properties for createObj. + */ +export function polygonPathProps(points, jumpgate) { + const box = boundingBox(points); + const width = box.right - box.left; + const height = box.bottom - box.top; + const cx = box.left + width / 2; + const cy = box.top + height / 2; + const round = (n) => Math.round(n * 1000) / 1000; + const local = points.map(([x, y]) => [round(x - box.left), round(y - box.top)]); + const closed = [...local, local[0]]; + + if (jumpgate) { + return { + shape: 'pol', + points: JSON.stringify(closed), + x: cx, + y: cy, + }; + } + + const commands = closed.map(([x, y], i) => [i === 0 ? 'M' : 'L', x, y]); + return { + _path: JSON.stringify(commands), + left: cx, + top: cy, + width, + height, + }; +} + +/** + * Returns the centroid of a ring's distinct vertices. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[]} [x, y]. + */ +export function ringCentre(ring) { + const pts = distinctVertices(ring); + const sum = pts.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [0, 0]); + return [sum[0] / pts.length, sum[1] / pts.length]; +} + +/** + * Returns a ring's vertices with a repeated closing point removed. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[][]} Distinct vertices. + */ +export function distinctVertices(ring) { + if (ring.length > 1) { + const first = ring[0]; + const last = ring.at(-1); + if (Math.abs(first[0] - last[0]) < 0.01 && Math.abs(first[1] - last[1]) < 0.01) { + return ring.slice(0, -1); + } + } + return ring; +} diff --git a/Hexploration/src/reveal.js b/Hexploration/src/reveal.js new file mode 100644 index 0000000000..5c7906b3de --- /dev/null +++ b/Hexploration/src/reveal.js @@ -0,0 +1,332 @@ +// Revealing hexes: when tokens move, from GM commands, and through the public API. + +import { buildCard } from './chat.js'; +import { BATCH_SIZE, LAYER_TOKEN, SCRIPT_NAME } from './constants.js'; +import { getPageContext } from './context.js'; +import { handleCoveredChange, refreshPage, refreshToken } from './cover.js'; +import { + hexDistance, + hexesAlongSegment, + hexesBetween, + hexesUnderToken, + hexesWithin, + hexKey, + hexToPixel, +} from './grid.js'; +import { removeHex } from './hexes.js'; +import { t } from './i18n.js'; +import { getDiscoveryName, getHexIcon } from './locations.js'; +import { getPathObject } from './paths.js'; +import { getConfig, getHex, getPageHexes, getPageSettings } from './state.js'; +import { escapeHtml, getTokenControllers, runInBatches, toText } from './utils.js'; + +/** + * Returns true when a token should reveal hexes under the page's settings. + * + * @param {object} token Roll20 graphic. + * @param {object} settings Effective page settings. + * @returns {boolean} True when the token reveals. + */ +export function tokenReveals(token, settings) { + if (!token || token.get('_subtype') !== 'token' || token.get('layer') !== LAYER_TOKEN) { + return false; + } + switch (settings.revealBy) { + case 'all': + return true; + case 'characters': + return !!token.get('represents'); + default: + return getTokenControllers(token).some((id) => id === 'all' || !playerIsGM(id)); + } +} + +/** + * Announces a discovered location. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record (before removal). + * @param {string} name Location name. + * @param {string} imgsrc Icon image URL (may be empty). + * @param {object} settings Effective page settings. + * @returns {void} + */ +function announceDiscovery(ctx, hex, name, imgsrc, settings) { + if (name && settings.announce !== 'off') { + const lang = getConfig().language; + const img = imgsrc + ? `
    ` + : ''; + const html = buildCard( + t('discovery.title', lang), + `${img}
    ${escapeHtml(name)}
    ` + ); + const prefix = settings.announce === 'gm' ? '/w gm ' : ''; + sendChat(SCRIPT_NAME, `${prefix}${html}`); + } + if (name && settings.pingDiscoveries) { + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + sendPing(x, y, ctx.pageId, null, true); + } +} + +/** + * Reveals one hex: removes it and its label, shows its icon, and announces + * it when named. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {object} settings Effective page settings. + * @param {object} [options] Options. + * @param {number} [options.distance=0] Distance from the revealing token (for maxDistance). + * @param {boolean} [options.announce=true] Announce named discoveries. + * @returns {boolean} True when a hex was revealed. + */ +export function revealHex(ctx, key, settings, { distance = 0, announce = true } = {}) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + if (distance > 0 && Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + + const name = getDiscoveryName(hex); + const icon = getHexIcon(hex); + const imgsrc = icon ? toText(icon.get('imgsrc')) : ''; + removeHex(ctx.pageId, key, false); + if (icon) { + icon.set({ layer: LAYER_TOKEN, showname: true }); + } + if (announce) { + announceDiscovery(ctx, hex, name, imgsrc, settings); + } + return true; +} + +/** + * Turns a hex see-through (glimpse mode) without revealing it. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {number} distance Distance from the revealing token. + * @returns {boolean} True when the hex changed. + */ +export function glimpseHex(ctx, key, distance) { + const hex = getHex(ctx.pageId, key); + if (!hex || hex.glimpsed) { + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + const path = getPathObject(hex.id, hex.type); + if (!path) { + return false; + } + path.set('fill', getConfig().glimpseColor); + hex.glimpsed = true; + return true; +} + +/** + * Returns true when line of sight from one hex to another is blocked by a + * covered hex. Glimpsed hexes have been seen through, so they do not block. + * + * @param {object} ctx Page context. + * @param {number[]} from [row, col]. + * @param {number[]} to [row, col]. + * @returns {boolean} True when blocked. + */ +function isBlocked(ctx, from, to) { + return hexesBetween(ctx.grid, from, to).some(([r, c]) => { + const hex = getHex(ctx.pageId, hexKey(r, c)); + return hex && !hex.glimpsed; + }); +} + +/** + * Parses a token's lastmove into points. + * + * @param {string} lastmove Roll20 lastmove ("x1,y1,x2,y2,…"). + * @returns {number[][]} Array of [x, y]. + */ +function parseLastMove(lastmove) { + const nums = toText(lastmove) + .split(',') + .map(Number) + .filter((n) => Number.isFinite(n)); + const points = []; + for (let i = 0; i + 1 < nums.length; i += 2) { + points.push([nums[i], nums[i + 1]]); + } + return points; +} + +/** + * Returns the cells a token passed through on its last move, in order, plus + * every cell it now covers. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @param {object|null} prev Previous token properties, when known. + * @param {boolean} followPath Include the route travelled. + * @returns {number[][]} Array of [row, col], without duplicates. + */ +function travelledCells(ctx, token, prev, followPath) { + const current = [Number(token.get('left')), Number(token.get('top'))]; + const cells = []; + + if ( + followPath && + prev && + Number.isFinite(Number(prev.left)) && + Number.isFinite(Number(prev.top)) + ) { + const start = [Number(prev.left), Number(prev.top)]; + // lastmove holds the start point and any waypoints of the latest drag. It + // is only trusted when it starts where the token was; moves made by other + // mods leave a stale lastmove behind. + const waypoints = parseLastMove(token.get('lastmove')); + const startsHere = + waypoints.length > 0 && + Math.abs(waypoints[0][0] - start[0]) < 1 && + Math.abs(waypoints[0][1] - start[1]) < 1; + const route = startsHere ? [...waypoints, current] : [start, current]; + for (let i = 1; i < route.length; i++) { + cells.push(...hexesAlongSegment(ctx.grid, route[i - 1], route[i])); + } + } + + cells.push( + ...hexesUnderToken( + ctx.grid, + current[0], + current[1], + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + + const seen = new Set(); + return cells.filter(([r, c]) => { + const key = hexKey(r, c); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); +} + +/** + * Reveals around a list of origin cells using the page's settings. + * + * @param {object} ctx Page context. + * @param {number[][]} origins Cells the token occupied, in order. + * @param {object} settings Effective page settings. + * @returns {number} Number of hexes revealed or glimpsed. + */ +function revealFromCells(ctx, origins, settings) { + let changed = 0; + for (const origin of origins) { + if (revealHex(ctx, hexKey(origin[0], origin[1]), settings)) { + changed++; + } + for (const cell of hexesWithin(ctx.grid, origin[0], origin[1], settings.revealDistance)) { + const key = hexKey(cell[0], cell[1]); + if (!getHex(ctx.pageId, key)) { + continue; + } + if (settings.lineOfSight && isBlocked(ctx, origin, cell)) { + continue; + } + const distance = hexDistance(ctx.grid, origin, cell); + const done = + settings.revealMode === 'glimpse' + ? glimpseHex(ctx, key, distance) + : revealHex(ctx, key, settings, { distance }); + if (done) { + changed++; + } + } + } + return changed; +} + +/** + * Reveals the hexes a token has moved through and can now see. + * + * @param {object} token Roll20 graphic. + * @param {object|null} [prev] Previous token properties from a change event. + * @param {boolean} [force=false] Skip the "which tokens reveal" check. + * @returns {number} Number of hexes revealed or glimpsed. + */ +export function revealAroundToken(token, prev = null, force = false) { + const pageId = token?.get('_pageid'); + if (!pageId || getPageHexes(pageId).length === 0) { + return 0; + } + const ctx = getPageContext(pageId); + if (!ctx.ok) { + return 0; + } + const settings = getPageSettings(pageId); + if (!force && !tokenReveals(token, settings)) { + return 0; + } + return revealFromCells(ctx, travelledCells(ctx, token, prev, settings.revealPath), settings); +} + +/** + * Handles a graphic change event: reveals when a token moves or arrives on + * the token layer. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ +export function handleTokenChange(token, prev) { + const moved = prev && (prev.left !== token.get('left') || prev.top !== token.get('top')); + const surfaced = prev && prev.layer !== token.get('layer') && token.get('layer') === LAYER_TOKEN; + const resized = + prev && (prev.width !== token.get('width') || prev.height !== token.get('height')); + handleCoveredChange(token, prev); + const layerChanged = prev && prev.layer !== token.get('layer'); + if (moved || surfaced || resized) { + if (revealAroundToken(token, moved ? prev : null) > 0) { + // Reveals may uncover other tokens as well as this one. + refreshPage(token.get('_pageid')); + return; + } + } + if (moved || layerChanged) { + refreshToken(token); + } +} + +/** + * Reveals every hex on a page without announcements. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ +export function revealPage(ctx, onDone) { + const settings = getPageSettings(ctx.pageId); + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + let count = 0; + runInBatches( + keys, + BATCH_SIZE, + (key) => { + if (revealHex(ctx, key, settings, { announce: false })) { + count++; + } + }, + () => { + refreshPage(ctx.pageId); + onDone(count); + } + ); +} diff --git a/Hexploration/src/utils.js b/Hexploration/src/utils.js new file mode 100644 index 0000000000..3f8e2b97c8 --- /dev/null +++ b/Hexploration/src/utils.js @@ -0,0 +1,222 @@ +/** + * Returns true when a value is a plain non-null, non-array object. + * + * @param {*} value Value to test. + * @returns {boolean} True when the value is a record. + */ +export function isRecord(value) { + return value !== null && typeof value === 'object' && !Array.isArray(value); +} + +/** + * Converts a value to trimmed text, treating null and undefined as empty. + * + * @param {*} value Value to convert. + * @returns {string} Trimmed string. + */ +export function toText(value) { + return value === null || value === undefined ? '' : String(value).trim(); +} + +/** + * Escapes HTML special characters. + * + * @param {*} text Text to escape. + * @returns {string} Escaped text. + */ +export function escapeHtml(text) { + return String(text) + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); +} + +/** + * Parses a whole number, rejecting anything that is not entirely digits + * (with an optional leading minus sign). + * + * @param {*} raw Raw input. + * @returns {number|null} Parsed integer, or null when invalid. + */ +export function parseStrictInt(raw) { + const text = toText(raw); + return /^-?\d+$/.test(text) ? Number(text) : null; +} + +/** + * Parses a yes/no style value. + * + * @param {*} raw Raw input. + * @returns {boolean|null} Parsed boolean, or null when not recognised. + */ +export function parseBoolean(raw) { + if (typeof raw === 'boolean') { + return raw; + } + const text = toText(raw).toLowerCase(); + if (['on', 'true', 'yes', '1'].includes(text)) { + return true; + } + if (['off', 'false', 'no', '0'].includes(text)) { + return false; + } + return null; +} + +/** + * Returns true when a value is a colour Roll20 accepts for path fill and stroke: + * #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(), rgba(), transparent, or a CSS colour name. + * + * @param {*} raw Colour text. + * @returns {boolean} True when valid. + */ +export function isValidColor(raw) { + const text = toText(raw); + return ( + /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text) || + /^rgba?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+%?\s*)?\)$/i.test(text) || + /^[a-z]{3,20}$/i.test(text) + ); +} + +/** + * Clamps a number into a range. + * + * @param {number} value Value. + * @param {number} min Minimum. + * @param {number} max Maximum. + * @returns {number} Clamped value. + */ +export function clamp(value, min, max) { + return Math.min(max, Math.max(min, value)); +} + +/** + * Returns the IDs of every GM in the game. + * + * @returns {string[]} GM player IDs. + */ +export function getGmPlayerIds() { + return findObjs({ _type: 'player' }) + .filter((player) => playerIsGM(player.id)) + .map((player) => player.id); +} + +let jumpgateCache = null; + +/** + * Returns true when the game runs on Jumpgate. Roll20 has exposed this as + * both `_release` and `release`, so both are checked. + * + * @returns {boolean} True for Jumpgate games. + */ +export function isJumpgate() { + if (jumpgateCache === null) { + const campaign = Campaign(); + const release = toText(campaign.get('_release') || campaign.get('release')).toLowerCase(); + jumpgateCache = release === 'jumpgate'; + } + return jumpgateCache; +} + +/** + * Returns the page a player is viewing: their own page when split from the + * party, otherwise the player ribbon page. + * + * @param {string} playerId Roll20 player ID. + * @returns {string} Page ID. + */ +export function getPlayerPageId(playerId) { + const campaign = Campaign(); + if (playerIsGM(playerId)) { + const player = getObj('player', playerId); + const lastPage = player?.get('_lastpage'); + if (lastPage) { + return lastPage; + } + } + const specific = campaign.get('playerspecificpages'); + if (isRecord(specific) && specific[playerId]) { + return specific[playerId]; + } + return campaign.get('playerpageid'); +} + +/** + * Returns the player IDs who control a token, directly or through the + * character it represents. + * + * @param {Graphic} token Roll20 token. + * @returns {string[]} Controller IDs (may include 'all'). + */ +export function getTokenControllers(token) { + const ids = new Set(); + const add = (list) => { + for (const id of toText(list).split(',')) { + if (id.trim()) { + ids.add(id.trim()); + } + } + }; + add(token.get('controlledby')); + const characterId = token.get('represents'); + if (characterId) { + add(getObj('character', characterId)?.get('controlledby')); + } + return [...ids]; +} + +/** + * Returns true when a token carries a status marker, matching both plain + * markers ("white-tower") and numbered ones ("white-tower@2"). + * + * @param {Graphic} token Roll20 token. + * @param {string} marker Marker tag. + * @returns {boolean} True when the marker is present. + */ +export function tokenHasMarker(token, marker) { + return toText(token.get('statusmarkers')) + .split(',') + .some((tag) => tag.split('@')[0] === marker); +} + +/** + * Splits work into batches run on successive event-loop turns, so large jobs + * do not trip the API sandbox's long-running script watchdog. + * + * @param {Array} items Items to process. + * @param {number} size Batch size. + * @param {(item: *, index: number) => void} work Called for each item. + * @param {(errors: number) => void} [done] Called once every item has been + * processed, with the number of items whose work threw. + * @returns {void} + */ +export function runInBatches(items, size, work, done) { + let index = 0; + let errors = 0; + // Errors are caught per item: an exception thrown from a timer callback + // would otherwise stop the whole API sandbox. + const step = () => { + const end = Math.min(items.length, index + size); + for (; index < end; index++) { + try { + work(items[index], index); + } catch (err) { + errors++; + log(`Hexploration: batch item failed: ${err?.message || err}`); + } + } + if (index < items.length) { + setTimeout(step, 0); + } else if (done) { + try { + done(errors); + } catch (err) { + log(`Hexploration: batch completion failed: ${err?.message || err}`); + } + } + }; + step(); +} From eba8c0a4bdf60d336c24b35331a9de8091d3368f Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 02:21:42 +0000 Subject: [PATCH 03/24] test(Hexploration): Add geometry, path and end-to-end tests The hex grid and path maths are pure modules, so they are tested directly, including round trips, page coverage, token footprints, calibration and both path formats. A small stand-in for the Roll20 sandbox loads the built Hexploration.js and drives real commands and token moves for Jumpgate, Legacy and v1 upgrade scenarios, failing if the mod logs an error. Signed-off-by: Steve Roberts --- Hexploration/tests/grid.test.mjs | 231 ++++++++++ Hexploration/tests/hexploration.test.mjs | 534 +++++++++++++++++++++++ Hexploration/tests/polygon.test.mjs | 168 +++++++ Hexploration/tests/roll20-stub.mjs | 198 +++++++++ 4 files changed, 1131 insertions(+) create mode 100644 Hexploration/tests/grid.test.mjs create mode 100644 Hexploration/tests/hexploration.test.mjs create mode 100644 Hexploration/tests/polygon.test.mjs create mode 100644 Hexploration/tests/roll20-stub.mjs diff --git a/Hexploration/tests/grid.test.mjs b/Hexploration/tests/grid.test.mjs new file mode 100644 index 0000000000..243dee3566 --- /dev/null +++ b/Hexploration/tests/grid.test.mjs @@ -0,0 +1,231 @@ +import assert from 'node:assert/strict'; +import { describe, it } from 'node:test'; + +import { + calibrateGrid, + createGrid, + cubeToOffset, + hexCorners, + hexDistance, + hexesBetween, + hexesAlongSegment, + hexesCoveringPage, + hexesUnderToken, + hexesWithin, + hexKey, + hexLine, + hexToPixel, + neighbours, + offsetToCube, + parseHexKey, + pixelToHex, +} from '../src/grid.js'; + +const GRIDS = { + 'legacy V': createGrid({ gridType: 'hex' }), + 'legacy H': createGrid({ gridType: 'hexr' }), + 'jumpgate V': createGrid({ gridType: 'hex', jumpgate: true }), + 'jumpgate H': createGrid({ gridType: 'hexr', jumpgate: true }), + 'jumpgate V x2': createGrid({ gridType: 'hex', jumpgate: true, scale: 2 }), + 'legacy H x0.5': createGrid({ gridType: 'hexr', scale: 0.5 }), +}; + +const near = (a, b, eps = 1e-6) => Math.abs(a - b) < eps; + +describe('createGrid', () => { + it('returns null for square and other grids', () => { + assert.equal(createGrid({ gridType: 'square' }), null); + assert.equal(createGrid({ gridType: 'dimetric' }), null); + }); + + it('keeps the v1 Legacy pixel offsets so old hexes stay aligned', () => { + const v = GRIDS['legacy V']; + assert.deepEqual(hexToPixel(v, 0, 0), [37.5, 44]); + const h = GRIDS['legacy H']; + assert.deepEqual(hexToPixel(h, 0, 0), [47, 40.5]); + }); + + it('matches the Jumpgate client grid: 70 px across the flats, first hex at the corner', () => { + const v = GRIDS['jumpgate V']; + assert.ok(near(v.colStep, 70) && near(v.originX, 35) && near(v.originY, 70 / Math.sqrt(3))); + const h = GRIDS['jumpgate H']; + assert.ok(near(h.rowStep, 70) && near(h.originY, 35) && near(h.originX, 70 / Math.sqrt(3))); + }); + + it('applies Jumpgate grid offsets (y measured upwards) but ignores them in Legacy', () => { + const g = createGrid({ gridType: 'hex', jumpgate: true, offsetX: 10, offsetY: 5 }); + assert.ok(near(g.originX, 45) && near(g.originY, 70 / Math.sqrt(3) - 5)); + const legacy = createGrid({ gridType: 'hex', offsetX: 10, offsetY: 5 }); + assert.deepEqual(hexToPixel(legacy, 0, 0), [37.5, 44]); + }); + + it('makes Jumpgate hexes regular', () => { + const v = GRIDS['jumpgate V']; + assert.ok(near(v.rowStep / v.colStep, Math.sqrt(3) / 2)); + const h = GRIDS['jumpgate H']; + assert.ok(near(h.colStep / h.rowStep, Math.sqrt(3) / 2)); + }); + + it('scales with the page cell size', () => { + assert.ok(near(GRIDS['jumpgate V x2'].colStep, GRIDS['jumpgate V'].colStep * 2)); + }); + + it('applies calibration overrides', () => { + const g = createGrid({ gridType: 'hex', calibration: { originX: 10, colStep: 80 } }); + assert.equal(g.originX, 10); + assert.equal(g.colStep, 80); + assert.equal(g.originY, 44); + }); +}); + +describe('hex keys', () => { + it('round-trips', () => { + assert.deepEqual(parseHexKey(hexKey(-3, 7)), [-3, 7]); + assert.equal(parseHexKey('a,b'), null); + assert.equal(parseHexKey('1,2,3'), null); + }); +}); + +for (const [name, grid] of Object.entries(GRIDS)) { + describe(`geometry (${name})`, () => { + it('round-trips offset and cube coordinates', () => { + for (let row = -4; row <= 4; row++) { + for (let col = -4; col <= 4; col++) { + assert.deepEqual(cubeToOffset(grid, offsetToCube(grid, row, col)), [row, col]); + } + } + }); + + it('finds the hex at its own centre and near its corners', () => { + for (let row = -2; row <= 6; row++) { + for (let col = -2; col <= 6; col++) { + const [x, y] = hexToPixel(grid, row, col); + assert.deepEqual(pixelToHex(grid, x, y), [row, col]); + // 90% of the way to each corner is still inside the hex. + for (const [cx, cy] of hexCorners(grid, row, col)) { + const px = x + (cx - x) * 0.9; + const py = y + (cy - y) * 0.9; + assert.deepEqual(pixelToHex(grid, px, py), [row, col], `corner of ${row},${col}`); + } + } + } + }); + + it('has six neighbours one step away', () => { + for (const [row, col] of [ + [0, 0], + [1, 1], + [2, 3], + [3, 2], + ]) { + const ns = neighbours(grid, row, col); + assert.equal(ns.length, 6); + assert.equal(new Set(ns.map(([r, c]) => hexKey(r, c))).size, 6); + for (const n of ns) { + assert.equal(hexDistance(grid, [row, col], n), 1); + } + } + }); + + it('neighbour centres are equally spaced on regular grids', () => { + if (!name.startsWith('jumpgate')) { + return; + } + const centre = hexToPixel(grid, 3, 3); + const dists = neighbours(grid, 3, 3).map(([r, c]) => { + const [x, y] = hexToPixel(grid, r, c); + return Math.hypot(x - centre[0], y - centre[1]); + }); + for (const d of dists) { + assert.ok(near(d, dists[0], 1e-6)); + } + }); + + it('lists hexes within a radius, nearest first', () => { + const ring2 = hexesWithin(grid, 4, 4, 2); + assert.equal(ring2.length, 18); + const ds = ring2.map((h) => hexDistance(grid, [4, 4], h)); + assert.deepEqual( + ds, + [...ds].sort((a, b) => a - b) + ); + assert.ok(ds.every((d) => d >= 1 && d <= 2)); + assert.equal(hexesWithin(grid, 4, 4, 0).length, 0); + }); + + it('draws connected lines between hexes', () => { + const line = hexLine(grid, [0, 0], [5, 7]); + assert.equal(line.length, hexDistance(grid, [0, 0], [5, 7]) + 1); + for (let i = 1; i < line.length; i++) { + assert.equal(hexDistance(grid, line[i - 1], line[i]), 1); + } + assert.equal(hexesBetween(grid, [0, 0], [0, 1]).length, 0); + assert.equal(hexesBetween(grid, [2, 2], [2, 2]).length, 0); + }); + + it('follows a pixel segment through every hex it crosses', () => { + const a = hexToPixel(grid, 1, 1); + const b = hexToPixel(grid, 6, 4); + const cells = hexesAlongSegment(grid, a, b); + assert.deepEqual(cells[0], [1, 1]); + assert.deepEqual(cells.at(-1), [6, 4]); + }); + + it('covers the whole page', () => { + const w = 10 * 70; + const h = 8 * 70; + const cells = hexesCoveringPage(grid, w, h); + const keys = new Set(cells.map(([r, c]) => hexKey(r, c))); + // Sample points across the page, up to half a pixel from each edge (a + // point exactly on the edge can round into a hex that lies off the page). + for (let x = 0.5; x <= w - 0.5; x += 13) { + for (let y = 0.5; y <= h - 0.5; y += 11) { + const [r, c] = pixelToHex(grid, x, y); + assert.ok(keys.has(hexKey(r, c)), `point ${x},${y} not covered`); + } + } + }); + + it('lists the hexes under a large token, centre first', () => { + const [x, y] = hexToPixel(grid, 4, 4); + const small = hexesUnderToken(grid, x, y, 10, 10); + assert.deepEqual(small, [[4, 4]]); + const big = hexesUnderToken(grid, x, y, grid.colStep * 3, grid.rowStep * 3); + assert.deepEqual(big[0], [4, 4]); + assert.ok(big.length >= 7); + }); + }); +} + +describe('calibrateGrid', () => { + it('moves the origin onto a snapped token', () => { + const grid = GRIDS['jumpgate V']; + const [x, y] = hexToPixel(grid, 3, 3); + const cal = calibrateGrid(grid, [[x + 5, y - 4]]); + const fixed = createGrid({ gridType: 'hex', jumpgate: true, calibration: cal }); + const [r, c] = pixelToHex(fixed, x + 5, y - 4); + const [cx, cy] = hexToPixel(fixed, r, c); + assert.ok(near(cx, x + 5) && near(cy, y - 4)); + }); + + it('measures spacing from two neighbouring tokens', () => { + const grid = GRIDS['jumpgate V']; + const cal = calibrateGrid(grid, [ + [100, 100], + [100 + 80 * 2, 100], + ]); + assert.ok(near(cal.colStep, 80)); + assert.ok(near(cal.rowStep / cal.colStep, grid.rowStep / grid.colStep)); + }); + + it('rejects tokens that are not in the same row', () => { + const grid = GRIDS['jumpgate V']; + assert.equal( + calibrateGrid(grid, [ + [100, 100], + [180, 160], + ]), + null + ); + }); +}); diff --git a/Hexploration/tests/hexploration.test.mjs b/Hexploration/tests/hexploration.test.mjs new file mode 100644 index 0000000000..d68b907772 --- /dev/null +++ b/Hexploration/tests/hexploration.test.mjs @@ -0,0 +1,534 @@ +// End-to-end tests of the built Hexploration.js against a stubbed Roll20 API. +// Run `npm run build` first. + +import assert from 'node:assert/strict'; +import { afterEach, describe, it } from 'node:test'; + +import { createGrid, hexToPixel, pixelToHex } from '../src/grid.js'; +import { createSandbox } from './roll20-stub.mjs'; + +const JG_V = createGrid({ gridType: 'hex', jumpgate: true }); +const LEGACY_V = createGrid({ gridType: 'hex', jumpgate: false }); + +/** + * Adds a drawn rectangle covering pixel bounds. + */ +function drawRect(game, left, top, right, bottom, jumpgate = true) { + const w = right - left; + const h = bottom - top; + if (jumpgate) { + return game.add('pathv2', { + _pageid: 'page1', + layer: 'objects', + shape: 'rec', + points: JSON.stringify([ + [0, 0], + [w, h], + ]), + x: left + w / 2, + y: top + h / 2, + }); + } + return game.add('path', { + _pageid: 'page1', + layer: 'objects', + _path: JSON.stringify([ + ['M', 0, 0], + ['L', w, 0], + ['L', w, h], + ['L', 0, h], + ['L', 0, 0], + ]), + left: left + w / 2, + top: top + h / 2, + width: w, + height: h, + scaleX: 1, + scaleY: 1, + }); +} + +function addToken(game, grid, row, col, attrs = {}) { + const [left, top] = hexToPixel(grid, row, col); + return game.add('graphic', { + _pageid: 'page1', + _subtype: 'token', + layer: 'objects', + left, + top, + width: 70, + height: 70, + controlledby: 'p1', + name: 'Hero', + statusmarkers: '', + ...attrs, + }); +} + +function hexCount(game) { + return Object.keys(game.hexState().pages.page1?.hexes || {}).length; +} + +function hasHex(game, row, col) { + return !!game.hexState().pages.page1?.hexes[`${row},${col}`]; +} + +const games = []; + +function readyGame(options) { + const game = createSandbox(options); + games.push(game); + game.ready(); + return game; +} + +// No scenario should make the mod log an error. +afterEach(() => { + for (const game of games.splice(0)) { + const errors = game.logs.filter((line) => /ERROR|failed/.test(line)); + assert.deepEqual(errors, []); + } +}); + +describe('startup', () => { + it('creates the handouts and greets the GM', () => { + const game = readyGame(); + const names = game.ofType('handout').map((h) => h.attrs.name); + assert.deepEqual(names.sort(), ['Hexploration - Command Deck', 'Hexploration - Help']); + assert.match(game.chat[0].text, /Hexploration is ready/); + assert.equal(game.hexState().schemaVersion, 2); + assert.equal(typeof game.sandbox.Hexploration.revealAround, 'function'); + }); + + it('ignores commands from players', () => { + const game = readyGame(); + const before = game.chat.length; + game.command('!hexploration', [], 'p1'); + assert.equal(game.chat.length, before); + }); +}); + +describe('filling (Jumpgate)', () => { + it('fills a drawn rectangle with pathv2 hexes on the foreground layer', () => { + const game = readyGame(); + const rect = drawRect(game, 0, 0, 700, 500); + game.command('!hexploration fill', [rect]); + assert.ok(hexCount(game) > 40, `expected many hexes, got ${hexCount(game)}`); + const hexes = game.ofType('pathv2'); + assert.equal(hexes.length, hexCount(game)); + assert.ok(hexes.every((h) => h.attrs.layer === 'foreground' && h.attrs.shape === 'pol')); + assert.ok(!game.objects.has(rect.id), 'source shape is consumed'); + assert.match(game.lastChat(), /Fill complete/); + }); + + it('falls back to the token layer when foreground is unavailable', () => { + const game = readyGame({ foreground: false }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 300, 300)]); + const hexes = game.ofType('pathv2'); + assert.ok(hexes.length > 0); + assert.ok(hexes.every((h) => h.attrs.layer === 'objects')); + assert.ok(game.chat.some((c) => /foreground layer/.test(c.text))); + }); + + it('inverse fill covers the page except the selected area', () => { + const game = readyGame(); + game.command('!hexploration fill inverse', [drawRect(game, 200, 200, 500, 400)]); + assert.ok(hexCount(game) > 100); + assert.ok(!hasHex(game, ...pixelToHex(JG_V, 350, 300)), 'inside the shape stays open'); + assert.ok(hasHex(game, 0, 0)); + assert.ok(hasHex(game, ...pixelToHex(JG_V, 20 * 70 - 5, 15 * 70 - 5)), 'far corner is covered'); + }); + + it('undo removes the hexes and restores the shape', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + const created = hexCount(game); + assert.ok(created > 0); + game.command('!hexploration undo'); + assert.equal(hexCount(game), 0); + assert.equal(game.ofType('pathv2').length, 1, 'only the restored shape remains'); + assert.match(game.lastChat(), new RegExp(`Hexes removed: ${created}`)); + }); + + it('refuses to fill on a square grid', () => { + const game = readyGame(); + game.objects.get('page1').attrs.grid_type = 'square'; + game.command('!hexploration fill', [drawRect(game, 0, 0, 300, 300)]); + assert.match(game.lastChat(), /does not use a hex grid/); + }); +}); + +describe('revealing', () => { + it('reveals the hexes along a player token’s route and around it', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 1'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 1400, 1000)]); + const token = addToken(game, JG_V, 1, 1); + const [x2, y2] = hexToPixel(JG_V, 1, 8); + game.move(token, x2, y2); + for (let col = 1; col <= 8; col++) { + assert.ok(!hasHex(game, 1, col), `hex 1,${col} on the route should be revealed`); + } + assert.ok(!hasHex(game, 0, 8) && !hasHex(game, 2, 8), 'neighbours of the end are revealed'); + assert.ok(hasHex(game, 5, 5), 'distant hexes stay hidden'); + }); + + it('follows waypoints from lastmove', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 0'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 1400, 1000)]); + const token = addToken(game, JG_V, 1, 1); + const start = hexToPixel(JG_V, 1, 1); + const corner = hexToPixel(JG_V, 6, 1); + const end = hexToPixel(JG_V, 6, 6); + game.move(token, end[0], end[1], `${start[0]},${start[1]},${corner[0]},${corner[1]}`); + assert.ok(!hasHex(game, 4, 1), 'hex on the first leg is revealed'); + assert.ok(!hasHex(game, 6, 4), 'hex on the second leg is revealed'); + assert.ok(hasHex(game, 3, 4), 'hex off the route stays hidden'); + }); + + it('does not reveal for GM-only tokens or tokens on the GM layer', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const total = hexCount(game); + const monster = addToken(game, JG_V, 1, 1, { controlledby: '', represents: 'char1' }); + game.move(monster, ...hexToPixel(JG_V, 2, 4)); + const hidden = addToken(game, JG_V, 1, 1, { layer: 'gmlayer' }); + game.move(hidden, ...hexToPixel(JG_V, 3, 3)); + assert.equal(hexCount(game), total); + }); + + it('character mode reveals for any token representing a character', () => { + const game = readyGame(); + game.command('!hexploration set revealBy characters'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const monster = addToken(game, JG_V, 1, 1, { controlledby: '', represents: 'char1' }); + game.move(monster, ...hexToPixel(JG_V, 2, 4)); + assert.ok(!hasHex(game, 2, 4)); + }); + + it('line of sight stops reveals behind hexes with a reveal-distance limit', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 3'); + game.command('!hexploration set maxDistance 0'); + // A wall of "mountain" hexes that can only be revealed by entering them. + game.command('!hexploration fill', [drawRect(game, 300, 0, 380, 700)]); + game.command('!hexploration set maxDistance'); + game.command('!hexploration fill', [drawRect(game, 380, 0, 700, 700)]); + const token = addToken(game, JG_V, 4, 2); + game.move(token, ...hexToPixel(JG_V, 4, 3)); + assert.ok(hasHex(game, 4, 4), 'mountain hex next to the token stays'); + assert.ok(hasHex(game, 4, 5), 'hex behind the mountain stays'); + }); + + it('glimpse mode makes nearby hexes see-through', () => { + const game = readyGame(); + game.command('!hexploration set revealMode glimpse'); + game.command('!hexploration set revealDistance 1'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const token = addToken(game, JG_V, 2, 2); + game.move(token, ...hexToPixel(JG_V, 2, 3)); + assert.ok(!hasHex(game, 2, 3), 'entered hex is removed'); + const neighbour = game.hexState().pages.page1.hexes['2,4']; + assert.equal(neighbour.glimpsed, true); + const path = game.objects.get(neighbour.id); + assert.equal(path.attrs.fill, 'rgba(34,34,34,0.5)'); + }); + + it('reveals through the public API and the explore command', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 0'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const token = addToken(game, JG_V, 2, 2); + assert.ok(game.sandbox.Hexploration.revealAround(token.id) >= 1); + assert.ok(!hasHex(game, 2, 2)); + const npc = addToken(game, JG_V, 3, 5, { controlledby: '' }); + game.command('!hexploration explore', [npc]); + assert.ok(!hasHex(game, 3, 5)); + }); + + it('reveal, conceal and reveal page work on selections', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const hex = game.objects.get(game.hexState().pages.page1.hexes['2,2'].id); + game.command('!hexploration reveal', [hex]); + assert.ok(!hasHex(game, 2, 2)); + const marker = addToken(game, JG_V, 2, 2, { controlledby: '' }); + game.command('!hexploration conceal', [marker]); + assert.ok(hasHex(game, 2, 2)); + game.command('!hexploration reveal page'); + assert.equal(hexCount(game), 0); + }); + + it('reset page asks first, then removes everything', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + game.command('!hexploration reset page'); + assert.ok(hexCount(game) > 0); + assert.match(game.lastChat(), /Yes, Remove All Hexes/); + game.command('!hexploration reset page confirm'); + assert.equal(hexCount(game), 0); + assert.equal(game.ofType('pathv2').length, 0); + }); +}); + +describe('hiding covered tokens', () => { + const visible = { showplayers_name: true, showplayers_bar1: true, showplayers_aura1: true }; + + it('hides player-visible details of tokens covered by a fill, and restores them on reveal', () => { + const game = readyGame(); + const monster = addToken(game, JG_V, 2, 2, { controlledby: '', ...visible }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + assert.equal(monster.attrs.showplayers_name, false); + assert.equal(monster.attrs.showplayers_bar1, false); + assert.equal(monster.attrs.showplayers_aura1, false); + const hex = game.objects.get(game.hexState().pages.page1.hexes['2,2'].id); + game.command('!hexploration reveal', [hex]); + assert.equal(monster.attrs.showplayers_name, true); + assert.equal(monster.attrs.showplayers_bar1, true); + assert.equal(monster.attrs.showplayers_bar2, false, 'flags that were off stay off'); + assert.equal(Object.keys(game.hexState().coveredTokens).length, 0); + }); + + it('hides a token moved under hexes and restores it when it moves out', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + const monster = addToken(game, JG_V, 9, 9, { controlledby: '', ...visible }); + game.move(monster, ...hexToPixel(JG_V, 2, 2)); + assert.equal(monster.attrs.showplayers_name, false); + game.move(monster, ...hexToPixel(JG_V, 9, 9)); + assert.equal(monster.attrs.showplayers_name, true); + }); + + it('restores tokens uncovered by a player token’s reveal', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 1'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const monster = addToken(game, JG_V, 3, 4, { controlledby: '', ...visible }); + game.command('!hexploration rescan'); + assert.equal(monster.attrs.showplayers_name, false); + const hero = addToken(game, JG_V, 3, 1); + game.move(hero, ...hexToPixel(JG_V, 3, 3)); + assert.equal(monster.attrs.showplayers_name, true); + }); + + it('keeps details switched on by the GM hidden until the token is uncovered', () => { + const game = readyGame(); + const monster = addToken(game, JG_V, 2, 2, { controlledby: '' }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + game.edit(monster, { showplayers_name: true, showplayers_bar1: true }); + assert.equal(monster.attrs.showplayers_name, false); + assert.equal(monster.attrs.showplayers_bar1, false); + const hex = game.objects.get(game.hexState().pages.page1.hexes['2,2'].id); + game.command('!hexploration reveal', [hex]); + assert.equal(monster.attrs.showplayers_name, true); + assert.equal(monster.attrs.showplayers_bar1, true); + }); + + it('does nothing when switched off, and restores everything when turned off', () => { + const game = readyGame(); + const monster = addToken(game, JG_V, 2, 2, { controlledby: '', ...visible }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + assert.equal(monster.attrs.showplayers_name, false); + game.command('!hexploration set hideCoveredTokens off'); + assert.equal(monster.attrs.showplayers_name, true); + game.command('!hexploration conceal', [monster]); + assert.equal(monster.attrs.showplayers_name, true); + }); +}); + +describe('locations', () => { + it('hides marked tokens under a fill and announces them when found', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 0'); + const tower = addToken(game, JG_V, 3, 3, { + name: 'Old Tower', + controlledby: '', + imgsrc: 'https://example.com/t.png', + }); + game.command('!hexploration mark', [tower]); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + assert.equal(tower.attrs.layer, 'gmlayer'); + const hero = addToken(game, JG_V, 3, 1); + game.move(hero, ...hexToPixel(JG_V, 3, 3)); + assert.equal(tower.attrs.layer, 'objects'); + assert.equal(tower.attrs.showname, true); + assert.ok( + game.chat.some((c) => /Location Discovered/.test(c.text) && /Old Tower/.test(c.text)) + ); + }); + + it('honours the v1 white-tower marker', () => { + const game = readyGame(); + const tower = addToken(game, JG_V, 2, 2, { + name: 'Ruin', + controlledby: '', + statusmarkers: 'white-tower', + }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + assert.equal(tower.attrs.layer, 'gmlayer'); + assert.equal(game.hexState().pages.page1.hexes['2,2'].iconId, tower.id); + }); + + it('names a hex, shows a GM label and escapes the announcement', () => { + const game = readyGame(); + game.command('!hexploration set revealDistance 0'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const hex = game.objects.get(game.hexState().pages.page1.hexes['2,3'].id); + game.command('!hexploration name Cave', [hex]); + const label = game.ofType('text')[0]; + assert.equal(label.attrs.layer, 'gmlayer'); + const hero = addToken(game, JG_V, 2, 1); + game.move(hero, ...hexToPixel(JG_V, 2, 3)); + const announcement = game.chat.find((c) => /Location Discovered/.test(c.text)); + assert.ok(announcement.text.includes('<b>Cave</b>')); + assert.equal(game.ofType('text').length, 0, 'label removed on reveal'); + }); + + it('can whisper discoveries to the GM and ping players', () => { + const game = readyGame(); + game.command('!hexploration set announce gm'); + game.command('!hexploration set pingDiscoveries on'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const hex = game.objects.get(game.hexState().pages.page1.hexes['2,3'].id); + game.command('!hexploration name Cave', [hex]); + game.command('!hexploration reveal', [hex]); + assert.ok(game.chat.some((c) => c.text.startsWith('/w gm') && /Cave/.test(c.text))); + assert.equal(game.pings.length, 1); + }); +}); + +describe('maintenance', () => { + it('forgets hexes deleted by hand', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + const before = hexCount(game); + game.deleteObj(game.objects.get(game.hexState().pages.page1.hexes['1,1'].id)); + assert.equal(hexCount(game), before - 1); + }); + + it('rescan adopts hexes the mod does not know about', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + const before = hexCount(game); + game.hexState().pages.page1.hexes = {}; + game.command('!hexploration rescan'); + assert.equal(hexCount(game), before); + assert.match(game.lastChat(), new RegExp(`Adopted: ${before}`)); + }); + + it('calibrate re-files hexes when the grid moves', () => { + const game = readyGame(); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); + const before = hexCount(game); + const [x, y] = hexToPixel(JG_V, 2, 2); + const token = game.add('graphic', { + _pageid: 'page1', + _subtype: 'token', + layer: 'objects', + left: x + 3, + top: y - 2, + }); + game.command('!hexploration calibrate', [token]); + assert.match(game.lastChat(), /Grid calibrated/); + assert.equal(hexCount(game), before); + game.command('!hexploration calibrate reset'); + assert.match(game.lastChat(), /Calibration removed/); + }); + + it('page settings override the global settings', () => { + const game = readyGame(); + game.command('!hexploration page set revealDistance 0'); + assert.equal(game.hexState().pages.page1.settings.revealDistance, 0); + game.command('!hexploration page set fillColor red'); + assert.match(game.lastChat(), /can be set per page/); + game.command('!hexploration page clear'); + assert.equal(Object.keys(game.hexState().pages.page1.settings).length, 0); + }); + + it('rejects invalid settings', () => { + const game = readyGame(); + game.command('!hexploration set fillColor not a colour!'); + assert.match(game.lastChat(), /not a valid value/); + game.command('!hexploration set revealDistance -3'); + assert.match(game.lastChat(), /not a valid value/); + }); + + it('shows status, help and the language list', () => { + const game = readyGame(); + game.command('!hexploration status'); + assert.match(game.lastChat(), /Jumpgate/); + game.command('!hexploration help'); + assert.match(game.lastChat(), /calibrate reset/); + game.command('!hexploration set language'); + assert.match(game.lastChat(), /Choose a Language/); + }); +}); + +describe('Legacy games and v1 upgrade', () => { + it('draws Legacy paths in a Legacy game', () => { + const game = readyGame({ jumpgate: false }); + game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400, false)]); + assert.ok(hexCount(game) > 0); + assert.equal(game.ofType('pathv2').length, 0); + assert.ok(game.ofType('path').every((p) => typeof p.attrs._path === 'string')); + }); + + it('migrates v1 state and keeps v1 commands working', () => { + const v1State = { + Hexploration: { + pageHexes: { page1: {} }, + hexIdMap: {}, + config: { + fillColor: '#FFFF88', + labelColor: '#333333', + strokeColor: '#DDDD88', + strokeWidth: 0, + revealDistance: 2, + }, + }, + }; + const game = createSandbox({ jumpgate: false, state: v1State }); + // A v1 hex path at 1,1 with a name. + const [x, y] = hexToPixel(LEGACY_V, 1, 1); + const path = game.add('path', { + _pageid: 'page1', + layer: 'objects', + _path: '[]', + left: x, + top: y, + width: 75, + height: 88, + }); + v1State.Hexploration.pageHexes.page1['1,1'] = { id: path.id, name: 'Old Mill' }; + v1State.Hexploration.hexIdMap[path.id] = ['page1', '1,1']; + game.ready(); + + const s = game.hexState(); + assert.equal(s.schemaVersion, 2); + assert.equal(s.config.revealDistance, 2); + assert.equal(s.config.fillColor, '#FFFF88'); + assert.equal(s.pages.page1.hexes['1,1'].name, 'Old Mill'); + assert.ok(game.chat.some((c) => /have been upgraded/.test(c.text))); + + game.command('!hexploration_showMenuMain'); + assert.match(game.lastChat(), /Inverse Fill/); + game.command('!hexploration_configModifyProperty color&�&𛈇&𶐎'); + assert.equal(s.config.strokeColor, '#111111'); + game.command('!hexploration_configModifyProperty revealDistance&&3'); + assert.equal(s.config.revealDistance, 3); + }); + + it('prunes hexes whose paths vanished while the API was off', () => { + const state = { + Hexploration: { + pageHexes: { page1: { '1,1': { id: '-gone' } } }, + hexIdMap: { '-gone': ['page1', '1,1'] }, + config: {}, + }, + }; + const game = readyGame({ state }); + assert.equal(hexCount(game), 0); + assert.ok(game.chat.some((c) => /no longer exist/.test(c.text))); + }); +}); diff --git a/Hexploration/tests/polygon.test.mjs b/Hexploration/tests/polygon.test.mjs new file mode 100644 index 0000000000..023f9a15a2 --- /dev/null +++ b/Hexploration/tests/polygon.test.mjs @@ -0,0 +1,168 @@ +import assert from 'node:assert/strict'; +import { describe, it } from 'node:test'; + +import { + boundingBox, + distinctVertices, + legacyPathToRings, + pathToRings, + pathV2ToRings, + pointInRing, + pointInShape, + polygonPathProps, + ringCentre, +} from '../src/polygon.js'; + +const near = (a, b, eps = 1e-6) => Math.abs(a - b) < eps; + +describe('pointInRing', () => { + const square = [ + [0, 0], + [10, 0], + [10, 10], + [0, 10], + ]; + it('detects inside and outside points', () => { + assert.ok(pointInRing([5, 5], square)); + assert.ok(!pointInRing([15, 5], square)); + assert.ok(!pointInRing([-1, -1], square)); + }); + + it('treats an inner ring as a hole', () => { + const hole = [ + [3, 3], + [7, 3], + [7, 7], + [3, 7], + ]; + assert.ok(!pointInShape([5, 5], [square, hole])); + assert.ok(pointInShape([1, 1], [square, hole])); + }); +}); + +describe('pathV2ToRings', () => { + it('places a polygon by its centre', () => { + const [ring] = pathV2ToRings({ + shape: 'pol', + points: '[[0,0],[100,0],[100,50],[0,50],[0,0]]', + x: 500, + y: 300, + }); + const box = boundingBox(ring); + assert.deepEqual(box, { left: 450, top: 275, right: 550, bottom: 325 }); + }); + + it('normalises points that do not start at 0,0', () => { + const [ring] = pathV2ToRings({ + shape: 'pol', + points: '[[20,30],[120,30],[120,80]]', + x: 100, + y: 100, + }); + assert.deepEqual(boundingBox(ring), { left: 50, top: 75, right: 150, bottom: 125 }); + }); + + it('expands a rectangle from its two corners, including negative sizes', () => { + const [ring] = pathV2ToRings({ shape: 'rec', points: '[[0,0],[-70,-140]]', x: 35, y: 70 }); + assert.equal(ring.length, 4); + assert.deepEqual(boundingBox(ring), { left: 0, top: 0, right: 70, bottom: 140 }); + }); + + it('approximates an ellipse', () => { + const [ring] = pathV2ToRings({ shape: 'eli', points: '[[0,0],[200,100]]', x: 100, y: 50 }); + assert.ok(ring.length >= 16); + assert.ok(pointInRing([100, 50], ring)); + assert.ok(!pointInRing([5, 5], ring)); + }); + + it('rotates about the centre', () => { + const [ring] = pathV2ToRings({ + shape: 'rec', + points: '[[0,0],[100,20]]', + x: 0, + y: 0, + rotation: 90, + }); + const box = boundingBox(ring); + assert.ok(near(box.left, -10) && near(box.right, 10)); + assert.ok(near(box.top, -50) && near(box.bottom, 50)); + }); + + it('returns nothing for bad JSON', () => { + assert.deepEqual(pathV2ToRings({ shape: 'pol', points: 'nope' }), []); + }); +}); + +describe('legacyPathToRings', () => { + it('places a path by left/top and applies scale', () => { + const [ring] = legacyPathToRings({ + _path: '[["M",0,0],["L",100,0],["L",100,100],["L",0,100],["L",0,0]]', + left: 200, + top: 200, + width: 100, + height: 100, + scaleX: 2, + scaleY: 1, + }); + assert.deepEqual(boundingBox(ring), { left: 100, top: 150, right: 300, bottom: 250 }); + }); + + it('samples freehand curves', () => { + const [ring] = legacyPathToRings({ + _path: '[["M",0,0],["Q",50,0,100,0],["Q",100,50,100,100],["L",0,100]]', + left: 50, + top: 50, + width: 100, + height: 100, + }); + assert.ok(ring.length > 4); + assert.ok(pointInRing([50, 50], ring)); + }); + + it('expands mapWidth and mapHeight', () => { + const [ring] = legacyPathToRings( + { + _path: '[["M",0,0],["L","mapWidth",0],["L","mapWidth","mapHeight"],["L",0,"mapHeight"]]', + left: 350, + top: 350, + width: 700, + height: 700, + }, + { width: 10, height: 10 } + ); + assert.deepEqual(boundingBox(ring), { left: 0, top: 0, right: 700, bottom: 700 }); + }); + + it('routes by type', () => { + assert.equal(pathToRings({ type: 'pathv2', shape: 'rec', points: '[[0,0],[1,1]]' }).length, 1); + assert.equal(pathToRings({ type: 'path', _path: '[]' }).length, 0); + }); +}); + +describe('polygonPathProps', () => { + const hex = [ + [110, 100], + [105, 108], + [95, 108], + [90, 100], + [95, 92], + [105, 92], + ]; + + it('round-trips through pathv2', () => { + const props = polygonPathProps(hex, true); + assert.equal(props.shape, 'pol'); + const [ring] = pathV2ToRings(props); + const centre = ringCentre(ring); + assert.ok(near(centre[0], 100, 1e-3) && near(centre[1], 100, 1e-3)); + assert.equal(distinctVertices(ring).length, 6); + }); + + it('round-trips through a Legacy path', () => { + const props = polygonPathProps(hex, false); + const [ring] = legacyPathToRings(props); + const centre = ringCentre(ring); + assert.ok(near(centre[0], 100, 1e-3) && near(centre[1], 100, 1e-3)); + assert.equal(distinctVertices(ring).length, 6); + }); +}); diff --git a/Hexploration/tests/roll20-stub.mjs b/Hexploration/tests/roll20-stub.mjs new file mode 100644 index 0000000000..126704d2e7 --- /dev/null +++ b/Hexploration/tests/roll20-stub.mjs @@ -0,0 +1,198 @@ +// A small stand-in for the Roll20 API sandbox, enough to load the built +// Hexploration.js and drive it from tests. Each call to createSandbox() gives +// an isolated game. + +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import vm from 'node:vm'; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); +const BUNDLE = fs.readFileSync(path.join(__dirname, '..', 'Hexploration.js'), 'utf8'); + +/** + * Creates an isolated Roll20-like sandbox with the bundle loaded. + * + * @param {object} [options] Options. + * @param {boolean} [options.jumpgate=true] Game engine. + * @param {boolean} [options.foreground=true] Whether the foreground layer is accepted. + * @param {object} [options.state] Initial persistent state. + * @param {object} [options.globalconfig] One-Click useroptions. + * @returns {object} Sandbox controls. + */ +export function createSandbox({ + jumpgate = true, + foreground = true, + state = {}, + globalconfig = {}, +} = {}) { + let nextId = 1; + const objects = new Map(); + const handlers = new Map(); + const chat = []; + const logs = []; + const pings = []; + const timers = []; + + const fire = (event, ...args) => { + for (const fn of handlers.get(event) || []) { + fn(...args); + } + }; + + class Obj { + constructor(type, attrs) { + this.attrs = { ...attrs, _type: type }; + if ('pageid' in this.attrs && !('_pageid' in this.attrs)) { + this.attrs._pageid = this.attrs.pageid; + } + if (!this.attrs._id) { + this.attrs._id = `-id${nextId++}`; + } + } + get id() { + return this.attrs._id; + } + get(key) { + if (key === 'id') { + return this.attrs._id; + } + if (key in this.attrs) { + return this.attrs[key]; + } + return this.attrs[`_${key}`]; + } + set(key, value) { + const updates = typeof key === 'object' ? key : { [key]: value }; + const prev = { ...this.attrs }; + Object.assign(this.attrs, updates); + // Roll20 does not raise change events for API changes. + void prev; + } + remove() { + if (objects.delete(this.attrs._id)) { + fire(`destroy:${this.attrs._type}`, this); + } + } + } + + const sandbox = { + state, + globalconfig, + log: (msg) => logs.push(String(msg)), + on: (event, fn) => { + if (!handlers.has(event)) { + handlers.set(event, []); + } + handlers.get(event).push(fn); + }, + getObj: (type, id) => { + const obj = objects.get(id); + return obj && obj.attrs._type === type ? obj : undefined; + }, + findObjs: (filter) => + [...objects.values()].filter((obj) => + Object.entries(filter).every( + ([k, v]) => obj.get(k.replace(/^_/, '')) === v || obj.attrs[k] === v + ) + ), + createObj: (type, attrs) => { + if (type === 'pathv2' && !jumpgate) { + return undefined; + } + const obj = new Obj(type, attrs); + if (attrs.layer === 'foreground' && !foreground) { + obj.attrs.layer = 'objects'; + } + objects.set(obj.id, obj); + return obj; + }, + sendChat: (who, text) => chat.push({ who, text }), + sendPing: (...args) => pings.push(args), + playerIsGM: (id) => objects.get(id)?.attrs.gm === true, + Campaign: () => campaign, + setTimeout: (fn) => timers.push(fn), + console, + }; + sandbox.globalThis = sandbox; + + const campaign = new Obj('campaign', { + _id: 'root', + _release: jumpgate ? 'jumpgate' : 'legacy', + playerpageid: 'page1', + playerspecificpages: false, + }); + + vm.createContext(sandbox); + vm.runInContext(BUNDLE, sandbox); + + const api = { + sandbox, + objects, + chat, + logs, + pings, + add(type, attrs) { + const obj = new Obj(type, attrs); + objects.set(obj.id, obj); + return obj; + }, + flush() { + while (timers.length > 0) { + timers.shift()(); + } + }, + ready() { + fire('ready'); + api.flush(); + }, + command(content, selected = [], playerid = 'gm1') { + fire('chat:message', { + type: 'api', + content, + playerid, + selected: selected.map((o) => ({ _id: o.id, _type: o.attrs._type })), + }); + api.flush(); + }, + move(token, left, top, lastmove) { + const prev = { ...token.attrs }; + token.attrs.left = left; + token.attrs.top = top; + token.attrs.lastmove = lastmove ?? `${prev.left},${prev.top}`; + fire('change:graphic', token, prev); + api.flush(); + }, + edit(obj, changes) { + const prev = { ...obj.attrs }; + Object.assign(obj.attrs, changes); + fire(`change:${obj.attrs._type}`, obj, prev); + api.flush(); + }, + deleteObj(obj) { + obj.remove(); + }, + ofType(type) { + return [...objects.values()].filter((o) => o.attrs._type === type); + }, + lastChat() { + return chat.at(-1)?.text || ''; + }, + hexState() { + return sandbox.state.Hexploration; + }, + }; + + // A GM, a player, and a Hex (V) page. + api.add('player', { _id: 'gm1', displayname: 'The GM', gm: true, _lastpage: 'page1' }); + api.add('player', { _id: 'p1', displayname: 'Player One' }); + api.add('page', { + _id: 'page1', + name: 'Hex Map', + grid_type: 'hex', + snapping_increment: 1, + width: 20, + height: 15, + }); + return api; +} From f7103d9b634019195f5bbd8a842b8a9886e1d7bf Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 02:21:43 +0000 Subject: [PATCH 04/24] docs(Hexploration): Document version 2 The README covers installation, commands, settings, how revealing works, Jumpgate and Legacy behaviour and the API for other mods, and credits Ada Lindberg as the original author alongside the new maintainer. CHANGELOG, DEVELOPERS, MOD_FILE_MAP and TESTING follow the same layout as the other rebuilt mods; TESTING includes the in-game checklist and test game setup. Signed-off-by: Steve Roberts --- Hexploration/CHANGELOG.md | 66 +++++++++ Hexploration/DEVELOPERS.md | 158 +++++++++++++++++++++ Hexploration/MOD_FILE_MAP.md | 105 ++++++++++++++ Hexploration/README.md | 263 +++++++++++++++++------------------ Hexploration/TESTING.md | 114 +++++++++++++++ 5 files changed, 569 insertions(+), 137 deletions(-) create mode 100644 Hexploration/CHANGELOG.md create mode 100644 Hexploration/DEVELOPERS.md create mode 100644 Hexploration/MOD_FILE_MAP.md create mode 100644 Hexploration/TESTING.md diff --git a/Hexploration/CHANGELOG.md b/Hexploration/CHANGELOG.md new file mode 100644 index 0000000000..97fa1bc971 --- /dev/null +++ b/Hexploration/CHANGELOG.md @@ -0,0 +1,66 @@ +# Changelog + +## 2.0.0 + +A full rewrite by MidNiteShadow7 of Ada Lindberg's Hexploration, which no longer worked in Jumpgate games. + +### Fixed + +- Works in Jumpgate: shapes drawn in Jumpgate (`pathv2`) can be filled, hexes are drawn as `pathv2`, and deleted Jumpgate hexes are forgotten. +- Hexes line up with Jumpgate's regular hex grid. Legacy pages keep the exact version 1 spacing so existing maps stay aligned. +- Hexes on the far right and bottom of the page are now covered by Inverse Fill. +- A token near the edge of a hex is now placed in the correct hex. +- Moving a token on the GM layer, or a monster controlled only by the GM, no longer reveals the map. +- Tokens dragged quickly across the map no longer skip the hexes in between. +- Bar, marker and other non-movement changes no longer trigger reveals. +- No more crashes when a hex, its label or its icon was deleted by hand, when Name Hex is used on something that is not a hex, or when Fill is used with a token selected. +- Location names are HTML-escaped in chat. +- Players can no longer run the commands; they are GM only. +- Large fills are drawn in batches so they do not trip the API's long-running script watchdog. + +### Added + +- Legacy support continues alongside Jumpgate; the engine is detected automatically. +- Hex Layer setting: draw on the foreground layer (above tokens) or the token layer. Auto tries the foreground layer first and falls back to the token layer. +- Reveal Along Path: the whole route a token is dragged along is revealed, including waypoints. +- Large tokens reveal every hex they cover. +- Tokens That Reveal setting: player tokens (default), character tokens (the version 1 behaviour) or all tokens. +- Glimpse reveal mode: hexes within sight turn see-through and clear when entered. +- Line of Sight can be switched off. +- Mark Location and Unmark commands for hidden location tokens. The version 1 `white-tower` marker still works. +- Announce Discoveries (everyone, GM only, off) and Ping Discoveries settings. +- Hide Covered Tokens: player-visible names, bars and auras of tokens under covered hexes are switched off until they are uncovered, because Roll20 draws them above the hexes. +- Reveal and Conceal for selected hexes, shapes and tokens; Reveal Page; Reset Page; Explore. +- Undo for the last fill, inverse fill or conceal, including the shapes it used. +- Per-page overrides for the reveal settings. +- Rescan: rebuilds a page's hex list after a page or game is copied, re-linking name labels and location tokens. +- Calibrate: lines the hex grid up with tokens snapped to hex centres. +- Status card for the current page. +- Help and Command Deck handouts in the Journal. +- 24 languages. +- `Hexploration.revealAround(token)` API for other Mods, and automatic support for tokens moved by TokenMod. +- Hex Layer, Tokens That Reveal and Language on the One-Click settings page. + +### Changed + +- Primary command is now `!hexploration` with subcommands. The version 1 `!hexploration_*` commands still work. +- No longer depends on PathMath, MatrixMath, Vector Math or HTML Builder. +- New installs default to dark hexes with a sight distance of 1. Upgraded games keep their settings. +- Version 1 state is migrated automatically; hexes whose paths no longer exist are forgotten on startup. +- Rebuilt with Rollup and Prettier; source split into ES modules with unit and end-to-end tests. + +## 1.3 + +- Fixed a couple of state bugs. + +## 1.2 + +- Maximum reveal distance, line-of-sight enforcement and icons for hexes. + +## 1.1 + +- Chat menu, hex colours, reveal distance, named hexes and inverse fill. + +## 1.0 + +- Initial release. diff --git a/Hexploration/DEVELOPERS.md b/Hexploration/DEVELOPERS.md new file mode 100644 index 0000000000..22fee2fddf --- /dev/null +++ b/Hexploration/DEVELOPERS.md @@ -0,0 +1,158 @@ +# Hexploration — Developer Guide + +## Project Layout + +| Path | Purpose | +| --------------------------- | ------------------------------------------------------------------------- | +| `src/` | ES module source. `src/index.js` is the Rollup entry point. | +| `src/locales/locale/*.js` | Translations. `en-US.js` is the source; the others are generated. | +| `tests/` | Node test runner suites (`*.test.mjs`) and the Roll20 API stub. | +| `scripts/` | Build, version bump and locale sync scripts. | +| `Hexploration.js` | Generated bundle for the One-Click library. Do not edit. | +| `/Hexploration.js` | Generated snapshot for each released version. | +| `1.0/` … `1.3/` | Ada Lindberg's original releases, kept for the One-Click version history. | +| `script.json` | One-Click metadata and useroptions. | + +## Module Responsibilities + +| Module | Responsibility | +| -------------- | ----------------------------------------------------------------------------------------------- | +| `index.js` | Event registration, startup (`checkInstall`), public `Hexploration` API, TokenMod observer. | +| `commands.js` | `!hexploration` and v1 command parsing and routing, chat menus and cards. | +| `constants.js` | Build placeholders, command names, defaults, limits and colours. | +| `state.js` | Persistent state, config validation, v1 migration, hex records and the in-memory path index. | +| `grid.js` | Pure hex geometry: offset/cube conversion, pixel lookup, distance, lines, ranges, calibration. | +| `polygon.js` | Pure path maths: Legacy `path` and Jumpgate `pathv2` to page-space rings, point-in-polygon. | +| `paths.js` | Roll20 path I/O for both path types, hex drawing and layer fallback. | +| `context.js` | Builds a page's grid (with calibration) and the page context used by commands. | +| `hexes.js` | Fill, inverse fill, conceal, reset, undo, rescan, calibrate and startup pruning. | +| `reveal.js` | Which tokens reveal, route and footprint calculation, line of sight, glimpse and announcements. | +| `locations.js` | Named hexes, GM labels, hidden location tokens and pending locations. | +| `cover.js` | Hides player-visible names, bars and auras of tokens under covered hexes, and restores them. | +| `journals.js` | Help and Command Deck handouts. | +| `chat.js` | Chat cards, buttons, whispers and errors. | +| `i18n.js` | Translation lookup (`t`, `tRaw`), locale normalisation and text direction. | +| `utils.js` | Small helpers: HTML escaping, parsing, colour validation, engine detection, batching. | + +`grid.js` and `polygon.js` must stay free of Roll20 globals so they can be unit tested directly. + +## State Structure + +`state.Hexploration`: + +```js +{ + schemaVersion: 2, + version: '2.0.0', + config: { language, hexLayer, fillColor, strokeColor, labelColor, glimpseColor, + strokeWidth, maxDistance, revealDistance, lineOfSight, revealPath, + revealBy, revealMode, announce, pingDiscoveries }, + pages: { + [pageId]: { + hexes: { 'row,col': { id, type, row, col, name?, nameId?, iconId?, maxDistance?, glimpsed? } }, + settings: { /* per-page overrides, PAGE_SETTING_KEYS only */ }, + calibration: null | { colStep, rowStep, originX, originY }, + }, + }, + pendingLocations: { [tokenId]: pageId }, + coveredTokens: { [tokenId]: { pageId, saved: { showplayers_name, showplayers_bar1, … } } }, + lastFill: null | { pageId, kind, time, created: [{ key, id }], restyled: [...], icons: [...], sources: [...] }, + notices: { useroptions: { /* last applied One-Click values */ } }, +} +``` + +The path ID → hex lookup is an in-memory `Map` rebuilt from `pages` on first use, so it can never drift from the stored hexes. + +### v1 migration + +v1 stored `pageHexes[pageId]['row,col'] = { id, name, nameId, iconId, maxDistance }`, a parallel `hexIdMap`, and a flat `config`. `migrateState()` converts this on startup, keeping the v1 colours, border width and reveal distance (v1 defaulted to 0). Hex keys keep the same meaning because Legacy grid spacing is unchanged. + +## Hex Geometry + +Hexes use offset coordinates `[row, col]`, matching v1's keys: + +- **Hex (V)** (`grid_type: 'hex'`): pointy-top hexes, odd rows shifted right by half a column. +- **Hex (H)** (`grid_type: 'hexr'`): flat-top hexes, odd columns shifted down by half a row. + +The grid is a regular hex lattice scaled by `colStep` and `rowStep`, so conversion, rounding, distance and line drawing are done exactly in cube coordinates for both Legacy's stretched hexes and Jumpgate's regular ones. + +| Profile | Hex (V) colStep / rowStep / origin | Hex (H) colStep / rowStep / origin | +| -------- | ---------------------------------- | ---------------------------------- | +| Legacy | 75.199 / 66.966 / (37.5, 44) | 69.585 / 79.689 / (47, 40.5) | +| Jumpgate | 70 / 60.622 / (35, 40.415) | 60.622 / 70 / (40.415, 35) | + +Legacy values are v1's measurements. Jumpgate values come from the Jumpgate client's hex grid: regular hexes 70 px across the flats (corner radius 70/√3), with the first hex's bounding box at the page's top-left corner. Jumpgate pages also have `grid_offset_x` / `grid_offset_y` (set by the map alignment tool); the x offset moves the grid right and the y offset moves it **up** (Jumpgate's engine y axis points up). Per-page calibration overrides all four values. + +All values are multiplied by the page's `snapping_increment` (1 when snapping is off). + +## Paths in Jumpgate and Legacy + +- Jumpgate draws `pathv2` (`shape`, `points`, `x`, `y`, `rotation`). Points are relative to their bounding box, which is centred on `x`,`y`. `rec` and `eli` store two corner points. +- Legacy draws `path` (`_path`, `left`, `top`, `width`, `height`, `scaleX`, `scaleY`, `rotation`). `_path` may contain `M`, `L`, `Q` and `C` commands and the `mapWidth`/`mapHeight` placeholders. +- The engine is read from `Campaign().get('_release')` (falling back to `release`). +- Hexes are drawn as closed six-point `pol` paths (`pathv2`) or `M`/`L` paths (`path`). +- `destroy:pathv2` is only registered in Jumpgate games, after `ready`. + +## Build System + +```bash +npm install +npm run build # bump patch version, then build +npm run build -- 2.1.0 # set an explicit version, then build +npm run build -- --no-bump # rebuild without changing the version +npm test # unit and end-to-end tests (build first) +npm run format +``` + +`scripts/build.mjs` writes `Hexploration.js` and `/Hexploration.js`. `rollup.config.js` replaces `__SCRIPT_NAME__`, `__BUILD_VERSION__` and `__BUILD_DATE__` in `constants.js` and wraps the bundle in `const HexplorationMod = (() => { … })();`. The public API is published on `globalThis.Hexploration` from `index.js`. + +### Versioning + +`scripts/bump-version.mjs` updates `script.json` and `package.json` and keeps the last five stable versions in `previousversions`. Prerelease versions are never added to the history. + +## Tests + +- `tests/grid.test.mjs` and `tests/polygon.test.mjs` import the pure modules directly. +- `tests/hexploration.test.mjs` loads the built bundle into `tests/roll20-stub.mjs`, a minimal Roll20 sandbox (objects, events, chat, timers), and drives real commands and token moves. It fails if the Mod logs an error. + +The stub does not reproduce Roll20 rendering, layer behaviour or permissions; use `TESTING.md` in a real game for those. + +## Internationalisation (i18n) + +- `t(key, locale, vars)` returns a string with `{placeholder}` interpolation; `tRaw` returns arrays and objects (used for handout lists). Both fall back to en-US. +- Add new keys to `src/locales/locale/en-US.js` only, then run: + +```bash +npm run sync-locales # translate missing keys in every locale +npm run regenerate-locales # re-translate everything (slow) +``` + +The sync script uses Google Translate with placeholder masking. Review generated text before release. + +## Adding a New Command + +1. Add a handler in `commands.js` and a `case` in `routeCommand`. +2. Add `help.` (and any `messages.`, `errors.`, `hints.` keys) to `en-US.js`. +3. Add it to `showHelp`, the handout command table in `journals.js`, the README and `MOD_FILE_MAP.md`. +4. Add a button to the menu and Command Deck if it is a common action. +5. Add an end-to-end test. + +## Coding Standards + +- Modern JavaScript (ES2020+), strict mode via the Rollup IIFE wrapper. +- Prettier: single quotes, trailing commas (ES5), 100-character lines. +- JSDoc on every function. +- Functional style; no classes. +- One concern per module; no circular imports (`context.js` exists to keep `hexes.js` and `locations.js` independent). +- All user-facing errors whisper the problem and how to fix it. Stack traces go to the API console only. +- Everything a GM types is validated; everything shown in chat or handouts is HTML-escaped. +- Event handlers are wrapped so an exception is logged rather than stopping the sandbox. Batched work catches per item, because an exception in a timer callback would stop the sandbox. + +## Roll20 API Notes + +- `state.Hexploration` is the only persistent storage. +- API changes do not raise `change:` events, so moves made by other Mods are invisible. TokenMod's `ObserveTokenChange` is used when present; other Mods can call `Hexploration.revealAround`. +- `lastmove` holds the start point and waypoints of the latest drag. It is only trusted when it starts at the token's previous position. +- Creating an object on an unsupported layer may silently put it elsewhere, so the created object's layer is checked after `createObj`. +- Large fills are drawn `BATCH_SIZE` hexes per event-loop turn. +- Roll20 draws nameplates, bars and auras above the foreground layer, so `cover.js` switches a covered token's `showplayers_*` flags off and saves them in `coveredTokens`. Pages are refreshed after every fill, reveal, undo, rescan, calibration and hand-deleted hex; single tokens on move, layer change and `add:graphic`. diff --git a/Hexploration/MOD_FILE_MAP.md b/Hexploration/MOD_FILE_MAP.md new file mode 100644 index 0000000000..2671702abd --- /dev/null +++ b/Hexploration/MOD_FILE_MAP.md @@ -0,0 +1,105 @@ +# Hexploration — Mod File Map + +A quick reference for where to find each feature in the source. + +## Entry Point & Startup + +| Task | File | Key function | +| ---------------------------------------- | -------------- | -------------------------------------------- | +| Roll20 event registration | `src/index.js` | `registerEventHandlers` | +| Jumpgate-only events | `src/index.js` | `registerEngineHandlers` | +| Startup, migration, pruning, handouts | `src/index.js` | `checkInstall` | +| Public API (`Hexploration.revealAround`) | `src/index.js` | `publishApi` | +| TokenMod move support | `src/index.js` | `observeOtherMods` | +| Hand-deleted hexes and pages | `src/index.js` | `handlePathDestroyed`, `handlePageDestroyed` | + +## Command Routing + +| Task | File | Key function | +| --------------------------------- | ----------------- | -------------------------------------------------------- | +| Handle chat input (GM only) | `src/commands.js` | `handleInput` | +| Route `!hexploration` subcommands | `src/commands.js` | `routeCommand` | +| v1 commands | `src/commands.js` | `routeLegacy` | +| Sort the selection | `src/commands.js` | `readSelection` | +| Menu, settings, status, help | `src/commands.js` | `showMainMenu`, `showSettings`, `showStatus`, `showHelp` | + +## Filling and Maintenance + +| Task | File | Key function | +| ----------------------------- | -------------- | ----------------------------------- | +| Cells inside / outside shapes | `src/hexes.js` | `cellsInPaths`, `cellsOutsidePaths` | +| Draw hexes in batches | `src/hexes.js` | `fillCells`, `drawHex` | +| Remove a hex | `src/hexes.js` | `removeHex` | +| Reset page | `src/hexes.js` | `clearPage` | +| Undo last fill | `src/hexes.js` | `undoLastFill` | +| Rescan a page | `src/hexes.js` | `rescanPage` | +| Calibrate | `src/hexes.js` | `calibratePage`, `resetCalibration` | +| Startup clean-up | `src/hexes.js` | `pruneMissingHexes` | + +## Revealing + +| Task | File | Key function | +| ----------------------------- | --------------- | -------------------------------------------- | +| Token change event | `src/reveal.js` | `handleTokenChange` | +| Which tokens reveal | `src/reveal.js` | `tokenReveals` | +| Route and footprint | `src/reveal.js` | `travelledCells` | +| Sight, line of sight, glimpse | `src/reveal.js` | `revealFromCells`, `isBlocked`, `glimpseHex` | +| Reveal one hex / announce | `src/reveal.js` | `revealHex`, `announceDiscovery` | +| Reveal page | `src/reveal.js` | `revealPage` | + +## Hiding Covered Tokens + +| Task | File | Key function | +| -------------------------------- | -------------- | -------------------------------- | +| Hide / restore one token | `src/cover.js` | `refreshToken`, `restoreDetails` | +| Refresh a whole page | `src/cover.js` | `refreshPage` | +| Restore all (setting turned off) | `src/cover.js` | `restoreAll` | + +## Locations + +| Task | File | Key function | +| ------------------------- | ------------------ | ---------------------------------- | +| Name a hex / GM label | `src/locations.js` | `setHexName`, `removeLabel` | +| Mark and unmark tokens | `src/locations.js` | `markLocations`, `unmarkLocations` | +| Tokens waiting for a fill | `src/locations.js` | `findLocationTokens` | +| Attach / detach an icon | `src/locations.js` | `attachIcon`, `detachIcon` | + +## Geometry + +| Task | File | Key function | +| ----------------------------------- | ---------------- | ----------------------------------------------------- | +| Grid profiles (Legacy / Jumpgate) | `src/grid.js` | `GRID_PROFILES`, `createGrid` | +| Pixel ↔ hex | `src/grid.js` | `hexToPixel`, `pixelToHex` | +| Distance, neighbours, ranges, lines | `src/grid.js` | `hexDistance`, `neighbours`, `hexesWithin`, `hexLine` | +| Page coverage, token footprint | `src/grid.js` | `hexesCoveringPage`, `hexesUnderToken` | +| Calibration maths | `src/grid.js` | `calibrateGrid` | +| Shape outlines (path / pathv2) | `src/polygon.js` | `pathToRings` | +| Hex path geometry | `src/polygon.js` | `polygonPathProps` | +| Page grid and context | `src/context.js` | `buildPageGrid`, `getPageContext` | + +## Roll20 Paths + +| Task | File | Key function | +| -------------------------- | -------------- | ------------------------------- | +| Find a path of either type | `src/paths.js` | `getPathObject` | +| Draw a hex, layer fallback | `src/paths.js` | `createHexPath`, `getHexLayer` | +| Read / recreate a shape | `src/paths.js` | `readPathProps`, `recreatePath` | + +## State & Config + +| Task | File | Key function | +| -------------------------- | -------------- | ------------------------------------------------------- | +| Load and migrate state | `src/state.js` | `initialiseState`, `migrateState` | +| Validate settings | `src/state.js` | `validateConfigValue`, `mergeConfig` | +| One-Click useroptions | `src/state.js` | `applyGlobalConfig` | +| Page overrides | `src/state.js` | `getPageSettings`, `setPageSetting` | +| Hex records and path index | `src/state.js` | `getHex`, `putHex`, `deleteHexRecord`, `getHexByPathId` | + +## Journals, Chat and Text + +| Task | File | Key function | +| --------------------- | ----------------------------- | --------------------------------------------------- | +| Help and Command Deck | `src/journals.js` | `installHandouts`, `buildHelpHtml`, `buildDeckHtml` | +| Chat cards and errors | `src/chat.js` | `whisper`, `whisperError`, `buildCard` | +| Translations | `src/i18n.js` | `t`, `tRaw` | +| English strings | `src/locales/locale/en-US.js` | — | diff --git a/Hexploration/README.md b/Hexploration/README.md index e054061359..a828fa341e 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -1,141 +1,130 @@ # Hexploration -_v1.3 Updates:_ -* Fixed a couple state bugs. +A Roll20 Mod that covers a hex map with opaque hexes and uncovers them as the party explores. + +Draw a shape over the area to hide, fill it with hexes, and every hex a player token moves through (and, if you like, the hexes around it) is revealed. Hidden locations can be tucked under hexes and are announced when they are found. + +**Version 2.0.0 is a full rewrite that works in Jumpgate and Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder, and existing version 1 hex maps and commands keep working. + +![Hexploration demo (version 1)](Hexploration.gif) + +## Installation + +1. Install **Hexploration** from the Roll20 One-Click library, or upload `Hexploration.js` to the game's API Scripts. +2. Save. On startup the Mod creates two handouts in the Journal: + - **Hexploration - Help**: full instructions. + - **Hexploration - Command Deck**: one-click buttons for every action. + +If you are upgrading from version 1, you can remove PathMath, MatrixMath, Vector Math and HTML Builder unless another Mod uses them. + +## Quick Start + +1. Open a page whose grid is **Hex (V)** or **Hex (H)**. +2. Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide. +3. Select the shapes and click **Fill** in the Command Deck, or type `!hexploration fill`. +4. Optionally, select tokens for important places and click **Mark Location** before filling. They are hidden under the hexes and announced when discovered. +5. Move a player token. The hexes it passes through, and those within its sight distance, are revealed. + +Type `!hexploration` for the chat menu or `!hexploration help` for the command list. -This script allows GMs to draw a polygon on a hex-gridded map and fill in -each hex inside that polygon with an opaque hexagon. It's great for hex-based -maps where the PCs must explore and discover each area hex by hex. +## Commands + +Only GMs can use these commands. + +| Command | What it does | +| --------------------------------------------- | ----------------------------------------------------------------------------------- | +| `!hexploration` | Show the menu. | +| `!hexploration fill` | Cover the selected shapes with hexes. | +| `!hexploration fill inverse` | Cover the whole page except inside the selected shapes. | +| `!hexploration undo` | Undo the last fill, inverse fill or conceal, and restore the shapes it used. | +| `!hexploration reveal` | Reveal the selected hexes, and the hexes under the selected shapes and tokens. | +| `!hexploration reveal page` | Reveal every hex on the page without announcements. | +| `!hexploration conceal` | Cover the area under the selected shapes and tokens with hexes again. | +| `!hexploration explore` | Reveal around the selected tokens as if they had just moved there. | +| `!hexploration reset page` | Remove every hex on the page (asks first). | +| `!hexploration name ` | Name the selected hexes, or the hexes under the selected tokens. Empty clears it. | +| `!hexploration mark` / `unmark` | Turn the selected tokens into hidden locations, or back. | +| `!hexploration set [ ]` | Change a setting, or show all settings. | +| `!hexploration page set ` | Override a reveal setting on the current page only. | +| `!hexploration page clear` | Remove the current page's overrides. | +| `!hexploration rescan` | Rebuild the page's hex list, for example after copying a page or game. | +| `!hexploration calibrate` / `calibrate reset` | Line the hex grid up with tokens snapped to hex centres, or remove the calibration. | +| `!hexploration status` | Show what the Mod knows about the current page. | +| `!hexploration journal rebuild` | Rebuild the Help and Command Deck handouts. | +| `!hexploration help` | List the commands. | + +### Version 1 commands + +The version 1 commands still work, including the `Hexploration_menu` macro: + +| Version 1 | Version 2 | +| ----------------------------------------- | ---------------------------- | +| `!hexploration_showMenuMain` | `!hexploration` | +| `!hexploration_fillPoly` | `!hexploration fill` | +| `!hexploration_fillInversePoly` | `!hexploration fill inverse` | +| `!hexploration_hexModifyProperty name&&…` | `!hexploration name …` | +| `!hexploration_configModifyProperty …` | `!hexploration set …` | + +## How Revealing Works + +- Only tokens on the token layer reveal hexes. **Tokens That Reveal** chooses which: tokens controlled by a player (the default, so the GM can move monsters freely), tokens that represent any character (the version 1 behaviour), or all tokens. +- A token reveals every hex it covers, so large tokens reveal several. With **Reveal Along Path** on, it also reveals every hex on the route it was dragged along, waypoints included. +- **Sight Distance** reveals the hexes around each of those hexes. With **Line of Sight** on, a hex is only revealed if no covered hex lies in between. +- **Hex Reveal Distance** is stored on hexes as they are drawn: those hexes can only be revealed from within that many hexes. Use it for terrain that hides what lies behind it. +- **Reveal Mode: Glimpse** turns hexes within sight see-through instead of removing them; they are removed when a token enters them. +- Roll20 draws token names, bars and auras above hexes. With **Hide Covered Tokens** on (the default), tokens under a covered hex have their player-visible name, bars and auras switched off until they are uncovered, so hidden monsters do not give themselves away. +- The Roll20 API does not report token moves made by other Mods. Moves made by TokenMod are picked up automatically. For other Mods, select the tokens and use `!hexploration explore`, or call the API below. + +## Settings + +| Key | Setting | Default | Per page | Description | +| ------------------- | -------------------- | -------------------- | -------- | ------------------------------------------------------------------------------ | +| `hexLayer` | Hex Layer | `auto` | | `auto`, `foreground` or `objects`. Auto tries the foreground layer first. | +| `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. `rgba()` makes see-through hexes. | +| `strokeColor` | Border Colour | `#444444` | | Outline colour of new hexes. | +| `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. | +| `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. | +| `strokeWidth` | Border Width | `1` | | Outline width in pixels (0–20). | +| `maxDistance` | Hex Reveal Distance | none | | Stored on new hexes; they reveal only from within this many hexes. | +| `revealDistance` | Sight Distance | `1` | ✓ | Hexes revealed around a moving token (0–20). | +| `lineOfSight` | Line of Sight | `on` | ✓ | Covered hexes block sight. | +| `revealPath` | Reveal Along Path | `on` | ✓ | Reveal the whole route a token is dragged along. | +| `revealBy` | Tokens That Reveal | `players` | ✓ | `players`, `characters` or `all`. | +| `revealMode` | Reveal Mode | `clear` | ✓ | `clear` or `glimpse`. | +| `announce` | Announce Discoveries | `all` | ✓ | `all`, `gm` or `off`. | +| `pingDiscoveries` | Ping Discoveries | `off` | ✓ | Ping players to discovered locations. | +| `hideCoveredTokens` | Hide Covered Tokens | `on` | | Switch off player-visible names, bars and auras of tokens under covered hexes. | +| `language` | Language | `en-US` | | One of 24 languages. `!hexploration set language` lists them. | + +**Hex Layer**, **Tokens That Reveal** and **Language** can also be set on the Mod's settings page in the API Scripts screen. + +Games upgraded from version 1 keep their colours, border width and sight distance. + +## Jumpgate and Legacy -## General Usage - -This script's actions and configurations are accessible through its menu -displayed in the chat (Visible only to the GM). -To open the script's menu, activate the 'Hexploration_menu' macro installed -by the script. - -Note that this script only works for maps whose grid types are set to either -'Hex (V)' or 'Hex (H)'. The opaque hexes will be aligned to the page's hex -grid. - -When you move a token representing a character into an area concealed by a hex, -the hex will be revealed. If the script's reveal distance is set greater than 0, -then adjacent hexes out to that distance (in hex units) will also be revealed. - -Watch https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif -for a short demo of the basics of how the script works. - -### Rendering Hexes - -To create a hex-filled area, first draw one or more polygons containing the -area you want filled with hexes. Then select the polygons and press the -'Fill Polygon' action from the script's menu. That's it! - -### Naming Hexes - -Hexes can be named to represent locations that are concealing. The names of -the hexes will be shown on the GM layer, invisible to the PCs. When a named -hex is revealed, it will announce that its location has been discovered in the -chat. - -There are two ways to name locations hidden by hexes: - -Before rendering the hexes using the 'Fill Polygon' action, create named tokens -with the 'white-tower' status representing the locations you want to conceal -with the hexes. This will also set the icon for the hex to that of the named -token. - -To name a hex that's already been rendered, select the hex and set its name -using the 'Name Hex' action from the menu. - -### Setting a Hex's Icon - -Hexes can be assigned a named icon. The icon will be hidden on the GM layer, -and it and its name will be revealed when its hex is revealed. - -To make a hex with an icon, create a named token with the 'white-tower' status -representing the location you want to conceal within a hex. Then fill the area -containing that token with hexes. It will be automatically concealed and -assigned to the hex it was in. - -## Actions - -The script contains the following actions available from the script's chat menu: - -### Fill Polygon - -This renders hexes within one more more polygon areas. -Select one or more polygons, then use this action to fill their areas with -hexes. - -### Inverse Fill - -This works like the 'Fill Polygon' action, except that it renders hexes -everywhere on the page except inside the selected polygons' areas instead. - -### Name Hex - -This allows you to name a hex after it has been rendered. Select the hex you -want to name, then use this action to specify a name for it. - -## Configurations - -The script contains the following configurations that can be set from the -script's chat menu: - -### Drawing configs - -These configurations set properties for hexes as you are drawing them. - -#### Hex Color - -This allows you to specify the color, border color, and label color of hexes. - -#### Border Width - -This sets the width of the border outlines on hexes. - -#### Hex Reveal Distance - -If this is set, then a character can only reveal the hexes being drawn if they -are within the specified number of hexes away from them. - -E.g., if a hex is drawn while this config is set to 3, then a character must be -within 3 hexes from it to reveal it. The hex will not be revealed if the -character is 4 or more hexes away from it, even if the global reveal distance -is set very high. - -If this is not set, then the hex can be revealed from a theoretically infinite -distance away (out to the line of sight distance). - -### Global configs - -These configs apply globally throughout the use of this script. - -#### Line of Sight - -This is the global reveal distance. It specifies how far out (in units) hexes -are revealed when a character token is moved. - -## Help - -My scripts are provided 'as-is', without warranty of any kind, expressed or implied. - -That said, if you experience any issues while using this script, -need help using it, or if you have a neat suggestion for a new feature, -please shoot me a PM: -https://app.roll20.net/users/46544/ada-l - -When messaging me about an issue, please be sure to include any error messages that -appear in your API Console Log, any configurations you've got set up for the -script in the VTT, and any options you've got set up for the script on your -game's API Scripts page. The more information you provide me, the better the -chances I'll be able to help. - -## Show Support - -If you would like to show your appreciation and support for the work I do in writing, -updating, maintaining, and providing tech support my API scripts, -please consider buying one of my art packs from the Roll20 marketplace: - -https://marketplace.roll20.net/browse/publisher/165/ada-lindberg +- Hexploration detects the engine and draws `pathv2` shapes in Jumpgate and `path` shapes in Legacy games. Shapes drawn in either editor can be filled. +- With **Hex Layer** on `auto`, hexes go on the foreground layer, above tokens. If the game rejects that layer, the token layer is used instead and the GM is told. +- Jumpgate draws regular hexes, which differ slightly from Legacy's. If hexes do not line up with a page's grid, snap a token to a hex centre, select it and run `!hexploration calibrate`. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size as well. +- Copying a page or game gives its hexes new IDs. Run `!hexploration rescan` on the page to pick them up again, together with their name labels and location tokens. + +## API for Other Mods + +```js +// Reveal around a token as if it had just moved there. +// Pass its previous position to reveal along the route as well. +Hexploration.revealAround(token, { left: oldLeft, top: oldTop }); +Hexploration.revealAround(tokenId); +Hexploration.version; // "2.0.0" +``` + +## Credits + +Original Mod by [Ada Lindberg](https://app.roll20.net/users/46544/ada-l). Ada's art packs are on the [Roll20 Marketplace](https://marketplace.roll20.net/browse/publisher/165/ada-lindberg). + +Version 2 maintained by [MidNiteShadow7](https://app.roll20.net/users/16506286/midniteshadow7) ([GitHub](https://github.com/steverobertsuk)). + +If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log. + +## License + +This script is licensed under the MIT License. diff --git a/Hexploration/TESTING.md b/Hexploration/TESTING.md new file mode 100644 index 0000000000..5557eed661 --- /dev/null +++ b/Hexploration/TESTING.md @@ -0,0 +1,114 @@ +# Hexploration — Testing Guide + +## Automated Tests + +```bash +npm run build -- --no-bump +npm test +``` + +These cover the hex geometry, path parsing for both path types, and end-to-end command and movement scenarios against a stubbed Roll20 API. They cannot check rendering, real layer behaviour or Jumpgate's grid, so run the manual checklist below in real games before release. + +--- + +## Test Games + +| Game | Engine | Needed for | +| --------------------- | -------------------------------- | --------------------------------- | +| **Jumpgate** | Jumpgate, Experimental sandbox | Everything below | +| **Legacy** | Legacy | Legacy drawing and the v1 upgrade | +| **Legacy → Jumpgate** | Jumpgate copy of the Legacy game | Upgrading a copied game (Rescan) | + +Each game needs: + +- Page **Hex V**: Hex (V), cell size 1, about 30 × 20, with a hex map image lined up to the grid. +- Page **Hex H**: Hex (H), cell size 1. +- Page **Hex V Scaled**: Hex (V), cell size 2 (or 0.5). +- Page **Square**: square grid. +- Two PCs controlled by a player, one NPC controlled by nobody, and one player-controlled token that does not represent a character. +- Optionally a player account in the game, to check what players see. + +For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMath, Vector Math and HTML Builder), fill a few areas, name some hexes and add a `white-tower` location token. Then copy it to Jumpgate before upgrading either game. + +--- + +## Setup + +- [ ] Install `Hexploration.js` and save. The API console shows `-=> Hexploration v2.0.0 … (Jumpgate) <=-` (or `(Legacy)`). +- [ ] The GM receives the "Hexploration is ready." whisper. +- [ ] The Journal contains **Hexploration - Help** and **Hexploration - Command Deck**, neither visible to players. +- [ ] Every button in the Command Deck works. +- [ ] A player typing `!hexploration` gets no response. + +## Grid Alignment (Jumpgate) — do this first + +- [ ] On **Hex V**, draw a rectangle and Fill. Hexes line up with the page grid across the whole map, not just the top-left. +- [ ] Repeat on **Hex H** and **Hex V Scaled**. +- [ ] If hexes drift: snap a token to a hex centre and run `!hexploration calibrate`; then with two tokens in neighbouring hexes of one row (V) or column (H). Note the column and row steps reported so the Jumpgate defaults in `src/grid.js` can be corrected. +- [ ] `!hexploration calibrate reset` restores the default grid. + +## Filling + +- [ ] Fill a polygon, rectangle, ellipse and freehand shape. Only hexes whose centres are inside are drawn; the shape is removed. +- [ ] Rotated shapes fill correctly. +- [ ] Hexes are on the foreground layer (Hex Layer: Auto) and cover tokens for players. +- [ ] `!hexploration set hexLayer objects`, Fill: new hexes on the token layer. +- [ ] Inverse Fill covers the whole page, including the right and bottom edges, except inside the shape. +- [ ] A full-page Inverse Fill on a large page completes without the API restarting. +- [ ] Filling over existing hexes restyles them and keeps their names. +- [ ] Undo removes the hexes and restores the shape. A second Undo says there is nothing to undo. +- [ ] Fill with nothing selected, or a token selected, whispers an error with a hint. +- [ ] Fill on **Square** whispers "This page does not use a hex grid." + +## Revealing + +- [ ] Drag a player token: every hex along the route is revealed, plus those within Sight Distance. +- [ ] Drag with waypoints: hexes along each leg are revealed. +- [ ] Move with the arrow keys: the hex moved into is revealed. +- [ ] Moving the NPC, or any token on the GM layer, reveals nothing. +- [ ] `!hexploration set revealBy characters`: the NPC (if it represents a character) now reveals. +- [ ] A 2 × 2 or 3 × 3 token reveals every hex it covers. +- [ ] With Line of Sight on, hexes behind a hex drawn with Hex Reveal Distance 0 stay hidden until it is entered. +- [ ] Glimpse mode: hexes within sight turn see-through; entering them removes them. +- [ ] `!hexploration explore` with tokens selected reveals around them. +- [ ] An NPC with player-visible name and bars moved under a hex shows neither to players; revealing its hex restores them. `set hideCoveredTokens off` restores every hidden token. +- [ ] A TokenMod move (`!token-mod --set left|+70`) reveals hexes. +- [ ] Reveal, Conceal, Reveal Page and Reset Page (with confirmation) behave as described. +- [ ] Page overrides (`!hexploration page set revealDistance 3`) apply only on that page; `page clear` removes them. + +## Locations + +- [ ] Mark Location on a token, then Fill over it: the token moves to the GM layer. +- [ ] Mark Location on a token already under a hex hides it immediately. +- [ ] A `white-tower` token is hidden when filled over. +- [ ] Revealing the hex returns the token to the token layer with its name shown and announces it. +- [ ] Name Hex shows a GM-only label; revealing announces the name and removes the label. +- [ ] Announce Discoveries: GM only whispers to the GM; Off sends nothing. +- [ ] Ping Discoveries moves the players' view. +- [ ] A name containing `` appears literally in chat. + +## Maintenance + +- [ ] Delete a hex by hand; `!hexploration status` count drops; nothing errors. +- [ ] Duplicate a page with hexes, run Rescan on the copy: hexes, labels and locations are picked up; moving a token reveals them. +- [ ] Restart the sandbox after deleting hexes while it was off: the startup whisper reports them as forgotten. + +## Upgrading from Version 1 (Legacy game) + +- [ ] Replace v1.3 with v2.0.0. The startup whisper says the maps were upgraded. +- [ ] Existing hexes reveal when tokens move; names and location tokens are announced. +- [ ] Colours, border width and reveal distance match the v1 settings. +- [ ] The `Hexploration_menu` macro opens the new menu; the v1 Fill buttons in old macros still work. +- [ ] Removing PathMath, MatrixMath, Vector Math and HTML Builder causes no errors. + +## Legacy → Jumpgate Copy + +- [ ] In the copy, the startup whisper reports forgotten hexes (their IDs changed). +- [ ] Rescan on each page adopts the hexes and re-links labels and location tokens. +- [ ] New fills in the copy draw `pathv2` hexes that line up with the existing ones (calibrate if not). + +## Languages + +- [ ] `!hexploration set language fr`: menus, messages and both handouts switch to French. +- [ ] `!hexploration set language he`: handouts read right to left. +- [ ] Setting Language on the One-Click settings page applies on restart and is not re-applied over a later chat change. From 5477c676e57a5da9cd20d7a71a4369745d64d666 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 02:21:44 +0000 Subject: [PATCH 05/24] chore(Hexploration): Build version 2.0.0 Updates script.json for the One-Click library (version 2.0.0, no dependencies, new description, authors and useroptions for hex layer, revealing tokens and language) and adds the built Hexploration.js with its identical 2.0.0 snapshot. Signed-off-by: Steve Roberts --- Hexploration/2.0.0/Hexploration.js | 7387 ++++++++++++++++++++++++++++ Hexploration/Hexploration.js | 7387 ++++++++++++++++++++++++++++ Hexploration/script.json | 91 +- 3 files changed, 14854 insertions(+), 11 deletions(-) create mode 100644 Hexploration/2.0.0/Hexploration.js create mode 100644 Hexploration/Hexploration.js diff --git a/Hexploration/2.0.0/Hexploration.js b/Hexploration/2.0.0/Hexploration.js new file mode 100644 index 0000000000..87a8b34aff --- /dev/null +++ b/Hexploration/2.0.0/Hexploration.js @@ -0,0 +1,7387 @@ +/** + * NOTE: GENERATED FILE - DO NOT EDIT DIRECTLY. + * NOTE: Source files live under src/ and are bundled with `npm run build`. + * ------------------------------------------------ + * Name: Hexploration + * Script: Hexploration.js + * Version: 2.0.0 + * Built: 2026-10-29T02:20:55.900Z + */ +const HexplorationMod = (() => { + 'use strict'; + + // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. + const SCRIPT_NAME = 'Hexploration'; + const SCRIPT_VERSION = '2.0.0'; + const SCRIPT_LAST_UPDATED = '2026-10-29T02:20:55.900Z'; + + const DEFAULT_LOCALE$1 = 'en-US'; + + const STATE_KEY = 'Hexploration'; + const SCHEMA_VERSION = 2; + const COMMAND = '!hexploration'; + + // v1 commands, kept so existing macros and the Hexploration_menu macro still work. + const LEGACY_COMMANDS = { + '!hexploration_fillPoly': 'fill', + '!hexploration_fillInversePoly': 'fillInverse', + '!hexploration_showMenuMain': 'menu', + '!hexploration_configModifyProperty': 'legacyConfig', + '!hexploration_hexModifyProperty': 'legacyHex', + }; + + // Separator v1 used between the arguments of its config and hex commands. + const LEGACY_ARG_SEPARATOR = '&&'; + + const HANDOUT_HELP_NAME = 'Hexploration - Help'; + const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; + + const AUTHOR_LINKS = { + original: { + name: 'Ada Lindberg', + profile: 'https://app.roll20.net/users/46544/ada-l', + marketplace: 'https://marketplace.roll20.net/browse/publisher/165/ada-lindberg', + }, + maintainer: { + name: 'MidNiteShadow7', + profile: 'https://app.roll20.net/users/16506286/midniteshadow7', + github: 'https://github.com/steverobertsuk', + }, + }; + + const DEMO_GIF_URL = + 'https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif'; + + // Roll20 layer identifiers. + const LAYER_TOKEN = 'objects'; + const LAYER_GM = 'gmlayer'; + const LAYER_FOREGROUND = 'foreground'; + + // Roll20 object types for drawn shapes. Jumpgate draws pathv2; Legacy draws path. + const PATH_TYPE_LEGACY = 'path'; + const PATH_TYPE_V2 = 'pathv2'; + const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + + // Status marker v1 used to flag location tokens. Still honoured as a fallback. + const LOCATION_MARKER = 'white-tower'; + + // Option lists for settings. + const HEX_LAYER_OPTIONS = ['auto', 'foreground', 'objects']; + const REVEAL_BY_OPTIONS = ['players', 'characters', 'all']; + const REVEAL_MODE_OPTIONS = ['clear', 'glimpse']; + const ANNOUNCE_OPTIONS = ['all', 'gm', 'off']; + + // Default configuration for new installs. Migrated v1 games keep their own values. + const DEFAULT_CONFIG = { + language: DEFAULT_LOCALE$1, + hexLayer: 'auto', + fillColor: '#222222', + strokeColor: '#444444', + labelColor: '#FFFFFF', + glimpseColor: 'rgba(34,34,34,0.5)', + strokeWidth: 1, + revealDistance: 1, + maxDistance: null, + lineOfSight: true, + revealPath: true, + revealBy: 'players', + revealMode: 'clear', + announce: 'all', + pingDiscoveries: false, + hideCoveredTokens: true, + }; + + // Player-visible token properties switched off while a token is under a + // covered hex, because Roll20 draws nameplates, bars and auras above the + // foreground layer. Saved values are restored when the token is uncovered. + const COVERED_TOKEN_PROPS = [ + 'showplayers_name', + 'showplayers_bar1', + 'showplayers_bar2', + 'showplayers_bar3', + 'showplayers_aura1', + 'showplayers_aura2', + ]; + + // Settings that can be overridden for a single page. + const PAGE_SETTING_KEYS = [ + 'revealDistance', + 'lineOfSight', + 'revealPath', + 'revealBy', + 'revealMode', + 'announce', + 'pingDiscoveries', + ]; + + // Limits that keep a single command from creating an unreasonable number of objects. + const MAX_REVEAL_DISTANCE = 20; + const MAX_STROKE_WIDTH = 20; + const MAX_FILL_HEXES = 20000; + const MAX_NAME_LENGTH = 100; + + // Hexes are created and removed in batches so large fills do not trip the + // API's long-running script watchdog. + const BATCH_SIZE = 100; + + // How close (as a fraction of the column step) a path's centre must be to a + // hex centre for Rescan to adopt it as a hex. + const RESCAN_CENTRE_TOLERANCE = 0.2; + + // How close (in pixels) a text label must be to a hex centre to be adopted as its name. + const RESCAN_LABEL_TOLERANCE = 6; + + // Colour palette for chat cards and handouts. + const COLOR_HEADER_BG = '#1b2a1f'; + const COLOR_HEADER_TEXT = '#e8dcb5'; + const COLOR_CARD_BG_TOP = '#22352a'; + const COLOR_CARD_BG_BOTTOM = '#14211a'; + const COLOR_BORDER = '#3c5a45'; + const COLOR_TEXT = '#e4e0d0'; + const COLOR_MUTED = '#9aa89c'; + const COLOR_ACCENT = '#d9a441'; + const COLOR_BUTTON_BG = '#b5832a'; + const COLOR_BUTTON_TEXT = '#ffffff'; + const COLOR_WARNING_BG = '#fef3c7'; + const COLOR_WARNING_BORDER = '#92400e'; + const COLOR_WARNING_TEXT = '#92400e'; + const COLOR_ERROR_BG = '#fee2e2'; + const COLOR_ERROR_BORDER = '#991b1b'; + const COLOR_ERROR_TEXT = '#991b1b'; + + /** + * Returns true when a value is a plain non-null, non-array object. + * + * @param {*} value Value to test. + * @returns {boolean} True when the value is a record. + */ + function isRecord(value) { + return value !== null && typeof value === 'object' && !Array.isArray(value); + } + + /** + * Converts a value to trimmed text, treating null and undefined as empty. + * + * @param {*} value Value to convert. + * @returns {string} Trimmed string. + */ + function toText(value) { + return value === null || value === undefined ? '' : String(value).trim(); + } + + /** + * Escapes HTML special characters. + * + * @param {*} text Text to escape. + * @returns {string} Escaped text. + */ + function escapeHtml(text) { + return String(text) + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); + } + + /** + * Parses a whole number, rejecting anything that is not entirely digits + * (with an optional leading minus sign). + * + * @param {*} raw Raw input. + * @returns {number|null} Parsed integer, or null when invalid. + */ + function parseStrictInt(raw) { + const text = toText(raw); + return /^-?\d+$/.test(text) ? Number(text) : null; + } + + /** + * Parses a yes/no style value. + * + * @param {*} raw Raw input. + * @returns {boolean|null} Parsed boolean, or null when not recognised. + */ + function parseBoolean(raw) { + if (typeof raw === 'boolean') { + return raw; + } + const text = toText(raw).toLowerCase(); + if (['on', 'true', 'yes', '1'].includes(text)) { + return true; + } + if (['off', 'false', 'no', '0'].includes(text)) { + return false; + } + return null; + } + + /** + * Returns true when a value is a colour Roll20 accepts for path fill and stroke: + * #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(), rgba(), transparent, or a CSS colour name. + * + * @param {*} raw Colour text. + * @returns {boolean} True when valid. + */ + function isValidColor(raw) { + const text = toText(raw); + return ( + /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text) || + /^rgba?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+%?\s*)?\)$/i.test(text) || + /^[a-z]{3,20}$/i.test(text) + ); + } + + /** + * Clamps a number into a range. + * + * @param {number} value Value. + * @param {number} min Minimum. + * @param {number} max Maximum. + * @returns {number} Clamped value. + */ + function clamp(value, min, max) { + return Math.min(max, Math.max(min, value)); + } + + let jumpgateCache = null; + + /** + * Returns true when the game runs on Jumpgate. Roll20 has exposed this as + * both `_release` and `release`, so both are checked. + * + * @returns {boolean} True for Jumpgate games. + */ + function isJumpgate() { + if (jumpgateCache === null) { + const campaign = Campaign(); + const release = toText(campaign.get('_release') || campaign.get('release')).toLowerCase(); + jumpgateCache = release === 'jumpgate'; + } + return jumpgateCache; + } + + /** + * Returns the page a player is viewing: their own page when split from the + * party, otherwise the player ribbon page. + * + * @param {string} playerId Roll20 player ID. + * @returns {string} Page ID. + */ + function getPlayerPageId(playerId) { + const campaign = Campaign(); + if (playerIsGM(playerId)) { + const player = getObj('player', playerId); + const lastPage = player?.get('_lastpage'); + if (lastPage) { + return lastPage; + } + } + const specific = campaign.get('playerspecificpages'); + if (isRecord(specific) && specific[playerId]) { + return specific[playerId]; + } + return campaign.get('playerpageid'); + } + + /** + * Returns the player IDs who control a token, directly or through the + * character it represents. + * + * @param {Graphic} token Roll20 token. + * @returns {string[]} Controller IDs (may include 'all'). + */ + function getTokenControllers(token) { + const ids = new Set(); + const add = (list) => { + for (const id of toText(list).split(',')) { + if (id.trim()) { + ids.add(id.trim()); + } + } + }; + add(token.get('controlledby')); + const characterId = token.get('represents'); + if (characterId) { + add(getObj('character', characterId)?.get('controlledby')); + } + return [...ids]; + } + + /** + * Returns true when a token carries a status marker, matching both plain + * markers ("white-tower") and numbered ones ("white-tower@2"). + * + * @param {Graphic} token Roll20 token. + * @param {string} marker Marker tag. + * @returns {boolean} True when the marker is present. + */ + function tokenHasMarker(token, marker) { + return toText(token.get('statusmarkers')) + .split(',') + .some((tag) => tag.split('@')[0] === marker); + } + + /** + * Splits work into batches run on successive event-loop turns, so large jobs + * do not trip the API sandbox's long-running script watchdog. + * + * @param {Array} items Items to process. + * @param {number} size Batch size. + * @param {(item: *, index: number) => void} work Called for each item. + * @param {(errors: number) => void} [done] Called once every item has been + * processed, with the number of items whose work threw. + * @returns {void} + */ + function runInBatches(items, size, work, done) { + let index = 0; + let errors = 0; + // Errors are caught per item: an exception thrown from a timer callback + // would otherwise stop the whole API sandbox. + const step = () => { + const end = Math.min(items.length, index + size); + for (; index < end; index++) { + try { + work(items[index], index); + } catch (err) { + errors++; + log(`Hexploration: batch item failed: ${err?.message || err}`); + } + } + if (index < items.length) { + setTimeout(step, 0); + } else if (done) { + try { + done(errors); + } catch (err) { + log(`Hexploration: batch completion failed: ${err?.message || err}`); + } + } + }; + step(); + } + + const CHAT_CARD_STYLE = [ + 'width:100%', + 'border-radius:4px', + 'box-shadow:1px 1px 3px rgba(0,0,0,0.4)', + 'text-align:left', + 'margin:2px auto', + `border:1px solid ${COLOR_BORDER}`, + `color:${COLOR_TEXT}`, + `background-image:-webkit-linear-gradient(135deg,${COLOR_CARD_BG_TOP} 0%,${COLOR_CARD_BG_BOTTOM} 100%)`, + `background-color:${COLOR_CARD_BG_BOTTOM}`, + 'overflow:hidden', + ].join(';'); + + const CHAT_HEADER_STYLE = [ + `background:${COLOR_HEADER_BG}`, + `color:${COLOR_HEADER_TEXT}`, + 'padding:4px 8px', + `border-bottom:2px solid ${COLOR_ACCENT}`, + 'font-variant:small-caps', + 'font-weight:bold', + 'font-size:1.05em', + 'text-align:center', + 'letter-spacing:0.05em', + ].join(';'); + + const CHAT_CONTENT_STYLE = 'padding:5px 8px;line-height:1.5'; + + const BUTTON_STYLE = [ + `background:${COLOR_BUTTON_BG}`, + `color:${COLOR_BUTTON_TEXT}`, + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const BUTTON_SECONDARY_STYLE = [ + 'background:#2c4034', + `color:${COLOR_TEXT}`, + 'border:1px solid #4d6b56', + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const SECTION_LABEL_STYLE = [ + `color:${COLOR_MUTED}`, + 'font-size:0.8em', + 'text-transform:uppercase', + 'letter-spacing:0.08em', + 'margin-top:4px', + 'margin-bottom:2px', + ].join(';'); + + const DIVIDER_STYLE = `border:none;border-top:1px solid ${COLOR_BORDER};margin:4px 0`; + + /** + * Returns the whisper target for a player, falling back to all GMs. + * + * Double quotes are stripped so the name is safe inside /w "name". + * + * @param {string} [playerId] Roll20 player ID. + * @returns {string} Whisper target text. + */ + function whisperTarget(playerId) { + const player = playerId ? getObj('player', playerId) : null; + if (!player) { + return 'gm'; + } + return `"${String(player.get('displayname') || playerId).replaceAll('"', '')}"`; + } + + /** + * Sends a styled card whispered to a player, or to every GM when no player is given. + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} title Card header text. + * @param {string|string[]} content HTML body content. + * @returns {void} + */ + function whisper(playerId, title, content) { + const body = Array.isArray(content) ? content.join('') : content; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${buildCard(title, body)}`, null, { + noarchive: true, + }); + } + + /** + * Sends a warning whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message Warning text. + * @returns {void} + */ + function whisperWarning(playerId, message) { + const style = [ + `background:${COLOR_WARNING_BG}`, + `color:${COLOR_WARNING_TEXT}`, + `border:1px solid ${COLOR_WARNING_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const html = `
    ${escapeHtml(message)}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Sends an error whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message What went wrong. + * @param {string} [hint] How to fix it. + * @returns {void} + */ + function whisperError(playerId, message, hint) { + const style = [ + `background:${COLOR_ERROR_BG}`, + `color:${COLOR_ERROR_TEXT}`, + `border:1px solid ${COLOR_ERROR_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const hintHtml = hint + ? `
    ${escapeHtml(hint)}
    ` + : ''; + const html = `
    ${escapeHtml(message)}${hintHtml}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Builds a styled chat card. + * + * @param {string} title Header text (escaped). + * @param {string} body Body HTML (trusted). + * @returns {string} HTML string. + */ + function buildCard(title, body) { + return [ + `
    `, + `
    ${escapeHtml(title)}
    `, + `
    ${body}
    `, + '
    ', + ].join(''); + } + + /** + * Builds a primary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a secondary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildSecondaryButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a section label. + * + * @param {string} text Label text. + * @returns {string} HTML string. + */ + function buildSectionLabel(text) { + return `
    ${escapeHtml(text)}
    `; + } + + /** + * Builds a horizontal divider. + * + * @returns {string} HTML string. + */ + function buildDivider() { + return `
    `; + } + + /** + * Builds a label/value row. The value may be trusted HTML (e.g. a button). + * + * @param {string} label Label text (escaped). + * @param {string} valueHtml Value HTML. + * @returns {string} HTML string. + */ + function buildRow(label, valueHtml) { + return [ + '', + ``, + ``, + '
    ${escapeHtml(label)}${valueHtml}
    ', + ].join(''); + } + + /** + * Builds a small colour swatch with its value. + * + * @param {string} color CSS colour. + * @returns {string} HTML string. + */ + function buildSwatch(color) { + const safe = escapeHtml(color); + return ` ${safe}`; + } + + // Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, + // so the whole module can be unit tested in Node. + // + // Hexes are addressed by offset coordinates [row, col], matching the keys v1 + // stored in state. "vertical" is Roll20's Hex (V) grid (pointy-top hexes, odd + // rows shifted right by half a hex). "horizontal" is Hex (H) (flat-top hexes, + // odd columns shifted down by half a hex). Internally the maths converts to + // cube coordinates, which make distance, rounding and line drawing exact. + + const SQRT3 = Math.sqrt(3); + + const ORIENTATION_VERTICAL = 'vertical'; + const ORIENTATION_HORIZONTAL = 'horizontal'; + + // Pixel spacing of a 1-unit hex grid. + // + // Legacy values were measured from the Legacy editor's grid by the v1 author + // and are kept exactly so existing v1 hexes stay aligned. Legacy hexes are + // slightly stretched rather than regular. + // + // Jumpgate draws mathematically regular hexes from the 70 px grid unit: the + // distance across the flats is one unit, so the corner radius is 70/√3. The + // first hex's bounding box sits at the page's top-left corner. (Taken from the + // Jumpgate client's hex grid, which builds cells with radius gridCellSize/√3.) + // Pages that still do not line up can be corrected with `!hexploration calibrate`. + const LEGACY_V = { + colStep: 75.19856198446, + rowStep: 66.965827824268, + originX: 37.5, + originY: 44, + }; + const LEGACY_H = { + colStep: 69.585127490377, + rowStep: 79.688789983504, + originX: 47, + originY: 40.5, + }; + const JUMPGATE_UNIT = 70; + + const GRID_PROFILES = { + legacy: { + [ORIENTATION_VERTICAL]: LEGACY_V, + [ORIENTATION_HORIZONTAL]: LEGACY_H, + }, + jumpgate: { + [ORIENTATION_VERTICAL]: { + colStep: JUMPGATE_UNIT, + rowStep: (JUMPGATE_UNIT * SQRT3) / 2, + originX: JUMPGATE_UNIT / 2, + originY: JUMPGATE_UNIT / SQRT3, + }, + [ORIENTATION_HORIZONTAL]: { + colStep: (JUMPGATE_UNIT * SQRT3) / 2, + rowStep: JUMPGATE_UNIT, + originX: JUMPGATE_UNIT / SQRT3, + originY: JUMPGATE_UNIT / 2, + }, + }, + }; + + /** + * Maps a Roll20 page grid_type to a hex orientation. + * + * @param {string} gridType Page grid_type ('hex' or 'hexr'). + * @returns {string|null} Orientation, or null when the grid is not hexagonal. + */ + function orientationForGridType(gridType) { + if (gridType === 'hex') { + return ORIENTATION_VERTICAL; + } + if (gridType === 'hexr') { + return ORIENTATION_HORIZONTAL; + } + return null; + } + + /** + * Builds a grid description for a page. + * + * @param {object} options Grid options. + * @param {string} options.gridType Page grid_type. + * @param {number} [options.scale=1] Page snapping_increment (cell size in units). + * @param {boolean} [options.jumpgate=false] True for Jumpgate geometry. + * @param {number} [options.offsetX=0] Jumpgate page grid_offset_x, in pixels. + * @param {number} [options.offsetY=0] Jumpgate page grid_offset_y, in pixels. Jumpgate + * measures it upwards, so a positive value moves the grid up the page. + * @param {object|null} [options.calibration] Per-page pixel overrides from calibrate. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function createGrid({ + gridType, + scale = 1, + jumpgate = false, + offsetX = 0, + offsetY = 0, + calibration = null, + }) { + const orientation = orientationForGridType(gridType); + if (!orientation) { + return null; + } + + const unit = Number(scale) > 0 ? Number(scale) : 1; + const profile = GRID_PROFILES[jumpgate ? 'jumpgate' : 'legacy'][orientation]; + const grid = { + orientation, + colStep: profile.colStep * unit, + rowStep: profile.rowStep * unit, + originX: profile.originX * unit + (jumpgate ? Number(offsetX) || 0 : 0), + originY: profile.originY * unit - (jumpgate ? Number(offsetY) || 0 : 0), + }; + + if (calibration) { + for (const key of ['colStep', 'rowStep', 'originX', 'originY']) { + if ( + Number.isFinite(calibration[key]) && + (key.startsWith('origin') || calibration[key] > 0) + ) { + grid[key] = calibration[key]; + } + } + } + + return grid; + } + + /** + * Returns true when an integer is odd, including negative values. + * + * @param {number} n Integer. + * @returns {boolean} True when odd. + */ + function isOdd(n) { + return (n & 1) === 1; + } + + /** + * Builds the state key for a hex. + * + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {string} Key in "row,col" form. + */ + function hexKey(row, col) { + return `${row},${col}`; + } + + /** + * Parses a "row,col" hex key. + * + * @param {string} key Hex key. + * @returns {number[]|null} [row, col], or null when malformed. + */ + function parseHexKey(key) { + const parts = String(key).split(','); + if (parts.length !== 2) { + return null; + } + const row = Number(parts[0]); + const col = Number(parts[1]); + return Number.isInteger(row) && Number.isInteger(col) ? [row, col] : null; + } + + /** + * Converts offset coordinates to cube coordinates. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [q, r, s]. + */ + function offsetToCube(grid, row, col) { + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = col - (row - (row & 1)) / 2; + r = row; + } else { + q = col; + r = row - (col - (col & 1)) / 2; + } + return [q, r, -q - r]; + } + + /** + * Converts cube coordinates to offset coordinates. + * + * @param {object} grid Grid object. + * @param {number[]} cube [q, r, s]. + * @returns {number[]} [row, col]. + */ + function cubeToOffset(grid, cube) { + const [q, r] = cube; + if (grid.orientation === ORIENTATION_VERTICAL) { + return [r, q + (r - (r & 1)) / 2]; + } + return [r + (q - (q & 1)) / 2, q]; + } + + /** + * Rounds fractional cube coordinates to the nearest hex. + * + * @param {number[]} cube Fractional [q, r, s]. + * @returns {number[]} Integer [q, r, s]. + */ + function cubeRound(cube) { + let q = Math.round(cube[0]); + let r = Math.round(cube[1]); + let s = Math.round(cube[2]); + const dq = Math.abs(q - cube[0]); + const dr = Math.abs(r - cube[1]); + const ds = Math.abs(s - cube[2]); + + if (dq > dr && dq > ds) { + q = -r - s; + } else if (dr > ds) { + r = -q - s; + } else { + s = -q - r; + } + // Normalise -0 so keys never contain "-0". + return [q + 0, r + 0, s + 0]; + } + + /** + * Returns the pixel centre of a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [x, y]. + */ + function hexToPixel(grid, row, col) { + if (grid.orientation === ORIENTATION_VERTICAL) { + return [ + grid.originX + (col + (isOdd(row) ? 0.5 : 0)) * grid.colStep, + grid.originY + row * grid.rowStep, + ]; + } + return [ + grid.originX + col * grid.colStep, + grid.originY + (row + (isOdd(col) ? 0.5 : 0)) * grid.rowStep, + ]; + } + + /** + * Returns the hex containing a pixel position. + * + * The grid is treated as a regular hex lattice scaled by colStep and rowStep, + * so this is exact for both regular (Jumpgate) and stretched (Legacy) hexes. + * + * @param {object} grid Grid object. + * @param {number} x Pixel x. + * @param {number} y Pixel y. + * @returns {number[]} [row, col]. + */ + function pixelToHex(grid, x, y) { + const colF = (x - grid.originX) / grid.colStep; + const rowF = (y - grid.originY) / grid.rowStep; + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = colF - rowF / 2; + r = rowF; + } else { + q = colF; + r = rowF - colF / 2; + } + return cubeToOffset(grid, cubeRound([q, r, -q - r])); + } + + /** + * Returns the number of hex steps between two hexes. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number} Distance in hexes. + */ + function hexDistance(grid, a, b) { + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + return Math.max(Math.abs(ca[0] - cb[0]), Math.abs(ca[1] - cb[1]), Math.abs(ca[2] - cb[2])); + } + + /** + * Returns every hex within a distance of a hex (excluding the hex itself), + * nearest first. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {number} radius Distance in hexes. + * @returns {number[][]} Array of [row, col]. + */ + function hexesWithin(grid, row, col, radius) { + const result = []; + const [q, r] = offsetToCube(grid, row, col); + for (let dist = 1; dist <= radius; dist++) { + for (let dq = -dist; dq <= dist; dq++) { + for (let dr = Math.max(-dist, -dq - dist); dr <= Math.min(dist, -dq + dist); dr++) { + const ds = -dq - dr; + if (Math.max(Math.abs(dq), Math.abs(dr), Math.abs(ds)) === dist) { + result.push(cubeToOffset(grid, [q + dq, r + dr, -(q + dq) - (r + dr)])); + } + } + } + } + return result; + } + + /** + * Returns the hexes on a straight line between two hexes, both ends included. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexLine(grid, a, b) { + const n = hexDistance(grid, a, b); + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + if (n === 0) { + return [[a[0], a[1]]]; + } + + // A tiny nudge stops the line landing exactly on hex edges, where rounding + // would otherwise pick a side inconsistently. + const nudge = [1e-6, 2e-6, -3e-6]; + const result = []; + for (let i = 0; i <= n; i++) { + const t = i / n; + const cube = [0, 1, 2].map((k) => ca[k] + nudge[k] + (cb[k] - ca[k]) * t); + result.push(cubeToOffset(grid, cubeRound(cube))); + } + return result; + } + + /** + * Returns the hexes strictly between two hexes on a straight line. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesBetween(grid, a, b) { + return hexLine(grid, a, b).slice(1, -1); + } + + /** + * Returns the hexes crossed by a pixel-space line segment, in travel order. + * + * @param {object} grid Grid object. + * @param {number[]} from [x, y]. + * @param {number[]} to [x, y]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesAlongSegment(grid, from, to) { + return hexLine(grid, pixelToHex(grid, from[0], from[1]), pixelToHex(grid, to[0], to[1])); + } + + /** + * Returns the six corner points of a hex in pixels. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of six [x, y] points, clockwise. + */ + function hexCorners(grid, row, col) { + const [cx, cy] = hexToPixel(grid, row, col); + const corners = []; + for (let i = 0; i < 6; i++) { + if (grid.orientation === ORIENTATION_VERTICAL) { + const angle = ((30 + 60 * i) * Math.PI) / 180; + corners.push([ + cx + (Math.cos(angle) / SQRT3) * grid.colStep, + cy + ((Math.sin(angle) * 2) / 3) * grid.rowStep, + ]); + } else { + const angle = (60 * i * Math.PI) / 180; + corners.push([ + cx + ((Math.cos(angle) * 2) / 3) * grid.colStep, + cy + (Math.sin(angle) / SQRT3) * grid.rowStep, + ]); + } + } + return corners; + } + + /** + * Returns every hex whose centre lies inside a bounding box. + * + * @param {object} grid Grid object. + * @param {object} box Box with left, top, right and bottom in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesInBox(grid, box) { + const [r0, c0] = pixelToHex(grid, box.left, box.top); + const [r1, c1] = pixelToHex(grid, box.right, box.bottom); + const result = []; + for (let row = Math.min(r0, r1) - 1; row <= Math.max(r0, r1) + 1; row++) { + for (let col = Math.min(c0, c1) - 1; col <= Math.max(c0, c1) + 1; col++) { + const [x, y] = hexToPixel(grid, row, col); + if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) { + result.push([row, col]); + } + } + } + return result; + } + + /** + * Returns every hex needed to cover a page completely, including the partial + * hexes along its edges. + * + * @param {object} grid Grid object. + * @param {number} widthPx Page width in pixels. + * @param {number} heightPx Page height in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesCoveringPage(grid, widthPx, heightPx) { + // A hex overlaps the page when its centre is within its own half-size of + // the page edge. Slivers thinner than a quarter pixel are ignored. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const padX = (vertical ? grid.colStep / 2 : (grid.colStep * 2) / 3) - 0.25; + const padY = (vertical ? (grid.rowStep * 2) / 3 : grid.rowStep / 2) - 0.25; + return hexesInBox(grid, { + left: -padX, + top: -padY, + right: widthPx + padX, + bottom: heightPx + padY, + }); + } + + /** + * Returns the hexes a token covers: every hex whose centre lies under the + * token, plus the hex under its centre. + * + * @param {object} grid Grid object. + * @param {number} x Token centre x. + * @param {number} y Token centre y. + * @param {number} width Token width in pixels. + * @param {number} height Token height in pixels. + * @returns {number[][]} Array of [row, col], centre hex first. + */ + function hexesUnderToken(grid, x, y, width, height) { + const centre = pixelToHex(grid, x, y); + // Shrink slightly so a token that only touches a neighbour's centre does not claim it. + const halfW = Math.max(0, width / 2 - 2); + const halfH = Math.max(0, height / 2 - 2); + const covered = hexesInBox(grid, { + left: x - halfW, + top: y - halfH, + right: x + halfW, + bottom: y + halfH, + }); + const centreKey = hexKey(centre[0], centre[1]); + return [centre, ...covered.filter(([r, c]) => hexKey(r, c) !== centreKey)]; + } + + /** + * Derives a calibration from tokens the GM has snapped to hex centres. + * + * One token corrects the grid origin. Two tokens in neighbouring cells of the + * same row (Hex V) or column (Hex H) also correct the hex spacing, keeping the + * current ratio between column and row spacing. + * + * @param {object} grid Current grid object. + * @param {number[][]} points Token centres [[x, y], ...]. + * @returns {object|null} Calibration, or null when the points cannot be used. + */ + function calibrateGrid(grid, points) { + if (!Array.isArray(points) || points.length === 0) { + return null; + } + + let { colStep, rowStep } = grid; + if (points.length >= 2) { + const [a, b] = points; + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const along = vertical ? Math.abs(b[0] - a[0]) : Math.abs(b[1] - a[1]); + const across = vertical ? Math.abs(b[1] - a[1]) : Math.abs(b[0] - a[0]); + const currentStep = vertical ? colStep : rowStep; + const steps = Math.round(along / currentStep); + if (steps < 1 || across > currentStep / 4) { + return null; + } + const ratio = rowStep / colStep; + if (vertical) { + colStep = along / steps; + rowStep = colStep * ratio; + } else { + rowStep = along / steps; + colStep = rowStep / ratio; + } + } + + const scaled = { ...grid, colStep, rowStep }; + const [px, py] = points[0]; + const [row, col] = pixelToHex(scaled, px, py); + const [cx, cy] = hexToPixel(scaled, row, col); + const calibration = { + colStep, + rowStep, + originX: grid.originX + (px - cx), + originY: grid.originY + (py - cy), + }; + + // Keep the origin inside the first cell so offsets stay small and stable. + // Shifting by two rows/columns preserves the odd/even offset pattern. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const wrapX = vertical ? colStep : colStep * 2; + const wrapY = vertical ? rowStep * 2 : rowStep; + calibration.originX = ((calibration.originX % wrapX) + wrapX) % wrapX; + calibration.originY = ((calibration.originY % wrapY) + wrapY) % wrapY; + return calibration; + } + + const TRANSLATION$4 = { + titles: { + ready: 'Heeksplorasie is gereed.', + settings: 'Heksplorasie-instellings', + languages: "Kies 'n taal", + pageSettings: 'Bladsyinstellings: {page}', + status: 'Heksplorasiestatus: {page}', + help: 'Heksplorasie-opdragte', + confirm: 'Bevestig asseblief', + }, + discovery: { + title: 'Ligging ontdek', + }, + menu: { + draw: 'Teken', + reveal: 'Openbaar en versteek', + locations: 'Liggings', + tools: 'Gereedskap', + layerInUse: 'Nuwe hekse word op die {layer} geteken.', + pageSettingsHelp: + 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', + }, + buttons: { + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + undo: 'Ontdoen vul', + reveal: 'Onthul', + conceal: 'Versteek', + explore: 'Verken', + revealPage: 'Onthul bladsy', + resetPage: 'Stel bladsy terug', + mark: 'Merk ligging', + unmark: 'Ontmerk', + name: 'Noem Hex', + settings: 'Instellings', + pageSettings: 'Bladsy-instellings', + status: 'Status', + rescan: 'Skandeer weer', + calibrate: 'Kalibreer', + calibrateReset: 'Stel Kalibrasie terug', + help: 'Help', + change: 'Verander', + menu: 'Spyskaart', + clearOverrides: 'Vee oorskrywings uit', + confirmReset: 'Ja, verwyder alle hekse', + }, + prompts: { + name: 'Liggingnaam (laat leeg om skoon te maak)', + }, + values: { + on: 'Aan', + off: 'Af', + none: 'Geen', + hexLayer: { + auto: 'Outo (voorgrond indien beskikbaar)', + foreground: 'voorgrond laag', + objects: 'tekenlaag', + }, + revealBy: { + players: 'Speler tokens', + characters: 'Karaktertekens', + all: 'Alle tekens', + }, + revealMode: { + clear: 'Duidelik', + glimpse: 'Glimpie', + }, + announce: { + all: 'Almal', + gm: 'Slegs GM', + off: 'Af', + }, + orientation: { + vertical: 'Heks (V)', + horizontal: 'Heks (H)', + }, + fillKind: { + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + conceal: 'Versteek', + }, + }, + settings: { + language: { + label: 'Taal', + desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', + }, + hexLayer: { + label: 'Hex laag', + desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', + }, + fillColor: { + label: 'Vul kleur', + desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Rand Kleur', + desc: 'Kleur van die buitelyn van nuwe hekse.', + }, + labelColor: { + label: 'Etiket Kleur', + desc: 'Kleur van die GM-net naametikette op benoemde hekse.', + }, + glimpseColor: { + label: 'Glimp kleur', + desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + }, + strokeWidth: { + label: 'Grens breedte', + desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + }, + revealDistance: { + label: 'Sigafstand', + desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + }, + lineOfSight: { + label: 'Siglyn', + desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + }, + revealPath: { + label: 'Openbaar Langs Pad', + desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + }, + revealBy: { + label: 'Tekens wat openbaar', + desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + }, + revealMode: { + label: 'Onthullingsmodus', + desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + }, + announce: { + label: 'Kondig ontdekkings aan', + desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + }, + pingDiscoveries: { + label: 'Ping Ontdekkings', + desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + }, + }, + status: { + engine: 'Spel enjin', + grid: 'Rooster', + layer: 'Hex laag', + hexes: 'Hekse', + named: 'Benoemde hekse', + icons: 'Liggingtekens', + glimpsed: 'Geskimpte hekkies', + pending: "Liggings wat wag vir 'n vulling", + calibrated: 'Gekalibreer', + overrides: 'Bladsy ignoreer', + undo: 'Ontdoen beskikbaar', + }, + messages: { + filled: + 'Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.', + revealed: '{count} hekkies geopenbaar.', + revealedPage: 'Alle {count} hekse op die bladsy is geopenbaar.', + confirmReset: + 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: '{count} hekse van die bladsy verwyder.', + undone: + 'Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.', + named: '{count} heksies genaamd "{name}".', + unnamed: 'Naam verwyder van {count} hekse.', + marked: + '{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.', + unmarked: '{count} tekens is nie meer liggings nie.', + settingChanged: '{setting} gestel na {value}.', + rescanned: + "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + calibrated: + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + calibrationReset: + 'Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', + migrated: + "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + pruned: + '{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + readyHint: + 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + }, + warnings: { + foregroundUnavailable: + 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', + someFailed: + '{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.', + }, + errors: { + noPage: 'Kon nie die bladsy vind om aan te werk nie.', + notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + noPolygons: 'Kies een of meer getekende vorms om te vul.', + emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', + tooMany: 'Dit sal {count} hexes skep, wat te veel in een slag is.', + nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', + nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', + noTokens: 'Kies eers een of meer tekens.', + noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', + unknownCommand: 'Onbekende opdrag: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', + invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', + calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + unexpected: 'Iets het verkeerd geloop: {message}', + }, + hints: { + noPage: 'Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.', + notHex: 'Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.', + noPolygons: + "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", + emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", + tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', + noHexes: + 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + unknownCommand: 'Tik !hexploration help om die opdragte te lys.', + unknownSetting: 'Tik !hexploration set om elke instelling te sien.', + calibrateNeedsTokens: + "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + calibrateFailed: + 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + unexpected: 'Besonderhede is in die API-konsole-logboek.', + }, + help: { + menu: 'Wys die spyskaart.', + fill: 'Bedek die geselekteerde getekende vorms met hekse.', + fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', + undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', + reveal: + 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', + revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', + conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', + explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', + resetPage: 'Verwyder elke heks op die bladsy (vra eers).', + name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', + mark: 'Verander die geselekteerde tekens in versteekte liggings.', + unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', + set: "Verander 'n instelling, of wys alle instellings.", + pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se ignorering.', + rescan: + "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + calibrate: + 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', + status: 'Wys wat Hexploration van die huidige bladsy weet.', + journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + help: 'Wys hierdie lys.', + handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', + }, + deck: { + subtitle: 'Beveldek', + drawDesc: + "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + revealDesc: + 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', + locationsDesc: + "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + toolsDesc: + 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', + footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', + }, + handout: { + versionLabel: 'Weergawe', + subtitle: 'Heks-vir-heks verkenning vir Roll20', + footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', + overview: { + heading: 'Oorsig', + body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", + }, + quickStart: { + heading: 'Vinnige Begin', + steps: [ + "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", + 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', + 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', + 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + ], + }, + commands: { + heading: 'Opdragte', + intro: + "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", + colCommand: 'Bevel', + colDesc: 'Wat dit doen', + }, + revealing: { + heading: 'Hoe onthulling werk', + points: [ + 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", + "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", + "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", + "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + ], + }, + locations: { + heading: 'Genoemde hekse en liggings', + points: [ + "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", + 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', + "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + ], + }, + settings: { + heading: 'Instellings', + intro: + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beskrywing', + perPage: '(Kan per bladsy gestel word.)', + }, + jumpgate: { + heading: 'Jumpgate en Legacy', + points: [ + 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', + 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', + "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + ], + }, + upgrading: { + heading: 'Opgradering vanaf weergawe 1', + points: [ + "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", + 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', + "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + ], + colV1: 'Weergawe 1 opdrag', + colV2: 'Weergawe 2 opdrag', + }, + troubleshooting: { + heading: 'Probleemoplossing', + points: [ + "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", + "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", + "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", + 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', + ], + }, + languages: { + heading: 'Tale', + body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + }, + credits: { + heading: 'Krediete', + original: 'Oorspronklike mod deur', + maintainer: 'Weergawe 2 onderhou deur', + marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', + support: + "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: "L'exploració està a punt.", + settings: "Configuració d'exploració", + languages: 'Trieu un idioma', + pageSettings: 'Configuració de la pàgina: {page}', + status: "Estat de l'exploració: {page}", + help: "Comandes d'exploració", + confirm: 'Si us plau, confirmeu', + }, + discovery: { + title: 'Localització descoberta', + }, + menu: { + draw: 'Dibuixa', + reveal: 'Revela i amaga', + locations: 'Ubicacions', + tools: 'Eines', + layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + pageSettingsHelp: + "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", + }, + buttons: { + fill: 'Omplir', + fillInverse: 'Farciment invers', + undo: 'Desfer el farciment', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explora', + revealPage: 'Revela la pàgina', + resetPage: 'Restableix la pàgina', + mark: 'Marca la ubicació', + unmark: 'Desmarca', + name: 'Nom Hex', + settings: 'Configuració', + pageSettings: 'Configuració de la pàgina', + status: 'Estat', + rescan: 'Torna a escanejar', + calibrate: 'Calibrar', + calibrateReset: 'Restableix la calibració', + help: 'Ajuda', + change: 'Canviar', + menu: 'Menú', + clearOverrides: 'Esborra les substitucions', + confirmReset: 'Sí, traieu tots els hexagones', + }, + prompts: { + name: 'Nom de la ubicació (deixeu en blanc per esborrar)', + }, + values: { + on: 'Encès', + off: 'Apagat', + none: 'Cap', + hexLayer: { + auto: 'Automàtic (en primer pla si està disponible)', + foreground: 'capa de primer pla', + objects: 'capa de testimoni', + }, + revealBy: { + players: 'Fitxes de jugador', + characters: 'Fitxes de personatges', + all: 'Totes les fitxes', + }, + revealMode: { + clear: 'Clar', + glimpse: "Un cop d'ull", + }, + announce: { + all: 'Tothom', + gm: 'Només GM', + off: 'Apagat', + }, + orientation: { + vertical: 'Hexadecimal (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Omplir', + fillInverse: 'Farciment invers', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Llengua', + desc: 'Idioma per a menús, missatges i fullets.', + }, + hexLayer: { + label: 'Capa hexagonal', + desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + }, + fillColor: { + label: 'Color de farciment', + desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color de la vora', + desc: 'Color del contorn dels nous hexagonals.', + }, + labelColor: { + label: "Color de l'etiqueta", + desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', + }, + glimpseColor: { + label: "Color d'ull", + desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', + }, + strokeWidth: { + label: 'Amplada de la vora', + desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', + }, + maxDistance: { + label: 'Distància de revelació hexagonal', + desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", + }, + revealDistance: { + label: 'Distància de visió', + desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + }, + lineOfSight: { + label: 'Línia de visió', + desc: 'Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.', + }, + revealPath: { + label: 'Revela al llarg del camí', + desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + }, + revealBy: { + label: 'Fitxes que revelen', + desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + }, + revealMode: { + label: 'Mode de revelació', + desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + }, + announce: { + label: 'Anunciar descobriments', + desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', + }, + pingDiscoveries: { + label: 'Ping Descobriments', + desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', + }, + }, + status: { + engine: 'Motor de joc', + grid: 'Quadrícula', + layer: 'Capa hexagonal', + hexes: 'Hexes', + named: 'Hexagones anomenats', + icons: "Fitxes d'ubicació", + glimpsed: 'Hexagones albirats', + pending: "Ubicacions a l'espera d'omplir-se", + calibrated: 'Calibrat', + overrides: 'Anul·lació de la pàgina', + undo: 'Desfer disponible', + }, + messages: { + filled: + 'Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.', + revealed: '{count} hexadecimals revelats.', + revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + confirmReset: + 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: '{count} hexadecimals eliminats de la pàgina.', + undone: + 'Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.', + named: '{count} hexadecimals anomenats "{name}".', + unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + marked: + "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", + unmarked: 'Les fitxes {count} ja no són ubicacions.', + settingChanged: "{setting} s'ha establert en {value}.", + rescanned: + "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + calibrated: + 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.', + calibrationReset: + "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', + migrated: + "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + pruned: + "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + readyHint: + 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + }, + warnings: { + foregroundUnavailable: + 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + someFailed: + "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + }, + errors: { + noPage: "No s'ha pogut trobar la pàgina per treballar.", + notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', + emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", + tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", + nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', + nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer un o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToUndo: 'No hi ha cap emplenament per desfer.', + unknownCommand: 'Ordre desconeguda: {command}', + unknownSetting: 'Configuració desconeguda: {key}', + unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', + invalidValue: '"{value}" no és un valor vàlid per a {key}.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', + unexpected: "S'ha produït un error: {message}", + }, + hints: { + noPage: 'Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.', + notHex: + 'Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.', + noPolygons: + "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", + emptyArea: + 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', + tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", + noHexes: + 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', + unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', + calibrateNeedsTokens: + "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + calibrateFailed: + "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + unexpected: "Els detalls es troben al registre de la consola de l'API.", + }, + help: { + menu: 'Mostra el menú.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', + undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + reveal: + 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + mark: 'Converteix les fitxes seleccionades en llocs ocults.', + unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + set: 'Canvia un paràmetre o mostra tots els paràmetres.', + pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', + pageClear: 'Elimina les substitucions de la pàgina actual.', + rescan: + 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', + calibrate: + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + calibrateReset: 'Elimineu el calibratge de la pàgina actual.', + status: 'Mostra què sap Hexploration sobre la pàgina actual.', + journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + help: 'Mostra aquesta llista.', + handout: 'Les instruccions completes es troben al fullet "{name}".', + }, + deck: { + subtitle: 'Comandament de la plataforma', + drawDesc: + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + revealDesc: + "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + locationsDesc: + 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', + toolsDesc: + 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', + footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', + }, + handout: { + versionLabel: 'Versió', + subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', + footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', + overview: { + heading: 'Visió general', + body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + demo: 'Mira una petita demostració (de la versió 1)', + }, + quickStart: { + heading: 'Inici ràpid', + steps: [ + 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', + "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", + "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", + 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', + ], + }, + commands: { + heading: 'Ordres', + intro: + 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', + colCommand: 'Comandament', + colDesc: 'Què fa', + }, + revealing: { + heading: 'Com funciona la revelació', + points: [ + 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", + "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", + "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + ], + }, + locations: { + heading: 'Hexes i ubicacions anomenades', + points: [ + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", + "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", + "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + ], + }, + settings: { + heading: 'Configuració', + intro: + "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + colKey: 'clau', + colName: 'Configuració', + colDesc: 'Descripció', + perPage: '(Es pot configurar per pàgina.)', + }, + jumpgate: { + heading: 'Jumpgate i Legacy', + points: [ + 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', + "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", + "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + ], + }, + upgrading: { + heading: 'Actualització de la versió 1', + points: [ + 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', + "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', + ], + colV1: 'Comandament de la versió 1', + colV2: 'Comandament de la versió 2', + }, + troubleshooting: { + heading: 'Resolució de problemes', + points: [ + 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', + 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', + 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', + "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", + ], + }, + languages: { + heading: 'Idiomes', + body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + }, + credits: { + heading: 'Crèdits', + original: 'Mod original de', + maintainer: 'Versió 2 mantinguda per', + marketplace: "Els paquets d'art de l'Ada al mercat Roll20", + support: + "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'H探索已準備就緒。', + settings: 'H探索設置', + languages: '選擇語言', + pageSettings: '頁面設定：{page}', + status: 'H探索狀態：{page}', + help: '探索命令', + confirm: '請確認', + }, + discovery: { + title: '發現地點', + }, + menu: { + draw: '畫', + reveal: '顯示和隱藏', + locations: '地點', + tools: '工具', + layerInUse: '正在 {layer} 上繪製新的六角形。', + pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', + }, + buttons: { + fill: '充滿', + fillInverse: '反向填充', + undo: '撤銷填充', + reveal: '揭示', + conceal: '隱藏', + explore: '探索', + revealPage: '顯示頁面', + resetPage: '重置頁面', + mark: '標記位置', + unmark: '取消標記', + name: '名稱十六進位', + settings: '設定', + pageSettings: '頁面設定', + status: '地位', + rescan: '重新掃描', + calibrate: '校準', + calibrateReset: '重置校準', + help: '幫助', + change: '改變', + menu: '選單', + clearOverrides: '清除覆蓋', + confirmReset: '是的，刪除所有六角形', + }, + prompts: { + name: '地點名稱（留空以清除）', + }, + values: { + on: '在', + off: '離開', + none: '沒有任何', + hexLayer: { + auto: '自動（前景，如果可用）', + foreground: '前景層', + objects: '令牌層', + }, + revealBy: { + players: '玩家代幣', + characters: 'Character tokens', + all: '所有代幣', + }, + revealMode: { + clear: '清除', + glimpse: '一瞥', + }, + announce: { + all: '每個人', + gm: '限通用汽車', + off: '離開', + }, + orientation: { + vertical: '六角 (V)', + horizontal: '六角 (H)', + }, + fillKind: { + fill: '充滿', + fillInverse: '反向填充', + conceal: '隱藏', + }, + }, + settings: { + language: { + label: '語言', + desc: '選單、訊息和講義的語言。', + }, + hexLayer: { + label: '六角層', + desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + }, + fillColor: { + label: '填充顏色', + desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', + }, + strokeColor: { + label: '邊框顏色', + desc: '新六邊形輪廓的顏色。', + }, + labelColor: { + label: '標籤顏色', + desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + }, + glimpseColor: { + label: '瞥見顏色', + desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', + }, + strokeWidth: { + label: '邊框寬度', + desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + }, + maxDistance: { + label: '十六進位顯示距離', + desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', + }, + revealDistance: { + label: '視距', + desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + }, + lineOfSight: { + label: '視線', + desc: '啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。', + }, + revealPath: { + label: '沿路徑顯示', + desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + }, + revealBy: { + label: '揭示的代幣', + desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', + }, + revealMode: { + label: '揭示模式', + desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', + }, + announce: { + label: '宣布發現', + desc: '當發現指定位置時誰會看到聊天訊息。', + }, + pingDiscoveries: { + label: '平發現', + desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + }, + }, + status: { + engine: '遊戲引擎', + grid: '網格', + layer: '六角層', + hexes: '六角形', + named: '命名六角形', + icons: '位置標記', + glimpsed: '瞥見的六角形', + pending: '等待填補的地點', + calibrated: '已校準', + overrides: '頁面覆蓋', + undo: '可以撤銷', + }, + messages: { + filled: '填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。', + revealed: '{count} 十六進位顯示。', + revealedPage: '顯示頁面上的所有 {count} 十六進位。', + confirmReset: + '從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。', + resetPage: '從頁面中刪除了 {count} 十六進位。', + undone: '上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。', + named: '{count} 名為「{name}」的十六進位。', + unnamed: '從 {count} 十六進位清除名稱。', + marked: '{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。', + unmarked: '{count} 標記不再是位置。', + settingChanged: '{setting} 設定為 {value}。', + rescanned: + '重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_', + calibrated: + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', + calibrationReset: '校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', + pruned: + '{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', + readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', + }, + warnings: { + foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', + someFailed: '無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。', + }, + errors: { + noPage: '找不到要處理的頁面。', + notHex: '此頁面不使用六角網格。', + noPolygons: '選擇一個或多個要填滿的繪製形狀。', + emptyArea: '所選區域不包含任何六角形中心。', + tooMany: '這會建立 {count} 六角形，一次性就太多了。', + nothingToConceal: '選擇要隱藏的繪製形狀或標記。', + nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + noTokens: '首先選擇一個或多個令牌。', + noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + nothingToUndo: '沒有可撤消的填充。', + unknownCommand: '未知指令：{command}', + unknownSetting: '未知設定：{key}', + unknownPageSetting: '每頁可設定的設定：{keys}', + invalidValue: '“{value}”對於 {key} 不是有效值。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateFailed: '這些令牌不能用於校準。', + unexpected: '出了點問題：{message}', + }, + hints: { + noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', + notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', + emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', + tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', + noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + unknownCommand: '鍵入 !hexploration help 以列出指令。', + unknownSetting: '輸入 !hexploration set 查看每個設定。', + calibrateNeedsTokens: + '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + unexpected: '詳細資訊位於 API 控制台日誌中。', + }, + help: { + menu: '顯示選單。', + fill: '用六角形覆蓋選定的繪製形狀。', + fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + revealPage: '顯示頁面上的每個十六進制，無需公告。', + conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', + explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', + mark: '將選取的標記變成隱藏位置。', + unmark: '停止將選定的標記隱藏在位置。', + set: '更改設定或顯示所有設定。', + pageSet: '僅覆蓋目前頁面上的顯示設定。', + pageClear: '刪除目前頁面的覆蓋。', + rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrateReset: '刪除目前頁面的校準。', + status: '顯示 Hexploration 對目前頁面的了解。', + journal: '重建幫助和命令平台講義。', + help: '顯示此清單。', + handout: '完整說明位於「{name}」講義。', + }, + deck: { + subtitle: '指揮台', + drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', + revealDesc: + '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', + footer: '有關完整說明，請參閱“{help}”講義。', + }, + handout: { + versionLabel: '版本', + subtitle: 'Roll20 的逐十六進位探索', + footer: '使用“{deck}”講義進行一鍵式控制項。', + overview: { + heading: '概述', + body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + demo: '觀看簡短的演示（來自版本 1）', + }, + quickStart: { + heading: '快速入門', + steps: [ + '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', + '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', + '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + ], + }, + commands: { + heading: '命令', + intro: + '只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。', + colCommand: '命令', + colDesc: '它的作用', + }, + revealing: { + heading: '揭示如何運作', + points: [ + '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', + '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', + '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + ], + }, + locations: { + heading: '命名六角形和位置', + points: [ + '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', + 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', + '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', + ], + }, + settings: { + heading: '設定', + intro: + '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + colKey: '鑰匙', + colName: '環境', + colDesc: '描述', + perPage: '（可按頁設定。）', + }, + jumpgate: { + heading: '跳躍門和遺產', + points: [ + 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', + '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', + 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + ], + }, + upgrading: { + heading: '從版本 1 升級', + points: [ + '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', + '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', + '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', + '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', + ], + colV1: '版本 1 指令', + colV2: '版本 2 指令', + }, + troubleshooting: { + heading: '故障排除', + points: [ + '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: '語言', + body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + }, + credits: { + heading: '製作人員', + original: '原始模組由', + maintainer: '版本 2 維護者', + marketplace: 'Roll20 Marketplace 上的 Ada 藝術包', + support: + '如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Heexploration je připraven.', + settings: 'Nastavení Heexploration', + languages: 'Vyberte jazyk', + pageSettings: 'Nastavení stránky: {page}', + status: 'Stav průzkumu: {page}', + help: 'Příkazy pro průzkum', + confirm: 'Prosím potvrďte', + }, + discovery: { + title: 'Místo objeveno', + }, + menu: { + draw: 'Remíza', + reveal: 'Odhalit a skrýt', + locations: 'Místa', + tools: 'Nástroje', + layerInUse: 'Na {layer} se kreslí nové hexy.', + pageSettingsHelp: + 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', + }, + buttons: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + undo: 'Vrátit zpět výplň', + reveal: 'Odhalit', + conceal: 'Skrývat', + explore: 'Prozkoumat', + revealPage: 'Odhalit stránku', + resetPage: 'Obnovit stránku', + mark: 'Označte umístění', + unmark: 'Zrušit označení', + name: 'Jméno Hex', + settings: 'Nastavení', + pageSettings: 'Nastavení stránky', + status: 'Postavení', + rescan: 'Znovu naskenujte', + calibrate: 'Kalibrovat', + calibrateReset: 'Resetovat kalibraci', + help: 'Pomoc', + change: 'Přeměna', + menu: 'Menu', + clearOverrides: 'Vymazat přepisy', + confirmReset: 'Ano, Odebrat všechny hexy', + }, + prompts: { + name: 'Název místa (pro vymazání ponechte prázdné)', + }, + values: { + on: 'Na', + off: 'Vypnuto', + none: 'Žádný', + hexLayer: { + auto: 'Auto (popředí, pokud je k dispozici)', + foreground: 'vrstva popředí', + objects: 'vrstva tokenů', + }, + revealBy: { + players: 'Hráčské žetony', + characters: 'Žetony postav', + all: 'Všechny tokeny', + }, + revealMode: { + clear: 'Jasný', + glimpse: 'Záblesk', + }, + announce: { + all: 'Každý', + gm: 'Pouze GM', + off: 'Vypnuto', + }, + orientation: { + vertical: 'Hexadecimální (V)', + horizontal: 'Hexadecimální (H)', + }, + fillKind: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + conceal: 'Skrývat', + }, + }, + settings: { + language: { + label: 'Jazyk', + desc: 'Jazyk pro nabídky, zprávy a letáky.', + }, + hexLayer: { + label: 'Hexadecimální vrstva', + desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', + }, + fillColor: { + label: 'Barva výplně', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Barva ohraničení', + desc: 'Barva obrysu nových hexů.', + }, + labelColor: { + label: 'Barva štítku', + desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', + }, + glimpseColor: { + label: 'Barva záblesku', + desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', + }, + strokeWidth: { + label: 'Šířka okraje', + desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', + }, + maxDistance: { + label: 'Hexadecimální vzdálenost odhalení', + desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', + }, + revealDistance: { + label: 'Pohledová vzdálenost', + desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', + }, + lineOfSight: { + label: 'Zornost', + desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', + }, + revealPath: { + label: 'Odhalení Po cestě', + desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', + }, + revealBy: { + label: 'Tokeny, které odhalují', + desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', + }, + revealMode: { + label: 'Režim odhalení', + desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', + }, + announce: { + label: 'Oznamte objevy', + desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', + }, + pingDiscoveries: { + label: 'Ping Discovery', + desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', + }, + }, + status: { + engine: 'Herní engine', + grid: 'Mřížka', + layer: 'Hexadecimální vrstva', + hexes: 'Hexy', + named: 'Pojmenované hexy', + icons: 'Tokeny polohy', + glimpsed: 'Zahlédnuté hexy', + pending: 'Místa čekající na zaplnění', + calibrated: 'Zkalibrováno', + overrides: 'Přepíše stránku', + undo: 'Zpět k dispozici', + }, + messages: { + filled: + 'Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.', + revealed: '{count} odhalených hexů.', + revealedPage: 'Všechny {count} hexy na stránce odhaleny.', + confirmReset: + 'Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: '{count} hexy odstraněny ze stránky.', + undone: + 'Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.', + named: '{count} hexy s názvem „{name}“.', + unnamed: 'Název byl vymazán z {count} hexů.', + marked: + '{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.', + unmarked: '{count} tokeny již nejsou umístění.', + settingChanged: '{setting} nastaveno na {value}.', + rescanned: + 'Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.', + calibrated: + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + calibrationReset: + 'Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', + migrated: + 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', + pruned: + '{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + readyHint: + 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', + }, + warnings: { + foregroundUnavailable: + 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', + someFailed: '{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.', + }, + errors: { + noPage: 'Nelze najít stránku, na které by se dalo pracovat.', + notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + tooMany: 'To by vytvořilo {count} hexů, což je příliš mnoho najednou.', + nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', + nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', + noTokens: 'Nejprve vyberte jeden nebo více žetonů.', + noHexes: 'Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).', + nothingToUndo: 'Neexistuje žádná výplň, kterou lze vrátit zpět.', + unknownCommand: 'Neznámý příkaz: {command}', + unknownSetting: 'Neznámé nastavení: {key}', + unknownPageSetting: 'Nastavení, která lze nastavit na stránce: {keys}', + invalidValue: '„{value}“ není platná hodnota pro {key}.', + calibrateNeedsTokens: 'Vyberte jeden nebo dva žetony přichycené na středy hexů.', + calibrateFailed: 'Tyto tokeny nelze použít ke kalibraci.', + unexpected: 'Něco se pokazilo: {message}', + }, + hints: { + noPage: 'Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.', + notHex: 'Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.', + noPolygons: + 'Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.', + emptyArea: 'Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.', + tooMany: 'Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.', + noHexes: 'Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.', + unknownCommand: 'Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.', + unknownSetting: 'Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.', + calibrateNeedsTokens: + 'Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.', + calibrateFailed: + 'Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.', + unexpected: 'Podrobnosti jsou v protokolu konzoly API.', + }, + help: { + menu: 'Ukaž menu.', + fill: 'Zakryjte vybrané nakreslené tvary hexy.', + fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', + undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', + reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', + revealPage: 'Odhalte každé hex na stránce bez oznámení.', + conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', + explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', + resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', + name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', + mark: 'Proměňte vybrané žetony na skrytá místa.', + unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + set: 'Změňte nastavení nebo zobrazte všechna nastavení.', + pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', + pageClear: 'Odstraňte přepsání aktuální stránky.', + rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + calibrate: + 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', + calibrateReset: 'Odstraňte kalibraci aktuální stránky.', + status: 'Ukažte, co Heexploration ví o aktuální stránce.', + journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + help: 'Zobrazit tento seznam.', + handout: 'Úplné pokyny jsou v letáku „{name}“.', + }, + deck: { + subtitle: 'Velitelský balíček', + drawDesc: + 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', + revealDesc: + 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', + locationsDesc: + 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', + toolsDesc: + 'Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.', + footer: 'Úplné pokyny naleznete v letáku „{help}“.', + }, + handout: { + versionLabel: 'Verze', + subtitle: 'Průzkum hex po hexu pro Roll20', + footer: 'Pro ovládání jedním kliknutím použijte leták „{deck}“.', + overview: { + heading: 'Přehled', + body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', + demo: 'Podívejte se na krátkou ukázku (od verze 1)', + }, + quickStart: { + heading: 'Rychlý start', + steps: [ + 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', + 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', + 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', + ], + }, + commands: { + heading: 'Příkazy', + intro: + 'Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.', + colCommand: 'Příkaz', + colDesc: 'Co to dělá', + }, + revealing: { + heading: 'Jak funguje odhalování', + points: [ + 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', + 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', + 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', + 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + ], + }, + locations: { + heading: 'Pojmenované hexy a umístění', + points: [ + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', + 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', + 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', + 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', + ], + }, + settings: { + heading: 'Nastavení', + intro: + 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + colKey: 'Klíč', + colName: 'Nastavení', + colDesc: 'Popis', + perPage: '(Lze nastavit na stránku.)', + }, + jumpgate: { + heading: 'Jumpgate a Legacy', + points: [ + 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', + 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', + ], + }, + upgrading: { + heading: 'Upgrade z verze 1', + points: [ + 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', + 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', + 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', + 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', + ], + colV1: 'Příkaz verze 1', + colV2: 'Příkaz verze 2', + }, + troubleshooting: { + heading: 'Odstraňování problémů', + points: [ + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', + 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', + ], + }, + languages: { + heading: 'Jazyky', + body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + }, + credits: { + heading: 'Kredity', + original: 'Původní mod od', + maintainer: 'Verze 2 spravovaná společností', + marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', + support: + 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration er klar.', + settings: 'Indstillinger for Hexploration', + languages: 'Vælg et sprog', + pageSettings: 'Sideindstillinger: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandoer', + confirm: 'Bekræft venligst', + }, + discovery: { + title: 'Sted opdaget', + }, + menu: { + draw: 'Tegne', + reveal: 'Afsløre og skjul', + locations: 'Steder', + tools: 'Værktøjer', + layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', + pageSettingsHelp: + 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', + }, + buttons: { + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + undo: 'Fortryd Fyld', + reveal: 'Afsløre', + conceal: 'Skjule', + explore: 'Udforske', + revealPage: 'Afsløre side', + resetPage: 'Nulstil side', + mark: 'Marker placering', + unmark: 'Fjern markering', + name: 'Navn Hex', + settings: 'Indstillinger', + pageSettings: 'Sideindstillinger', + status: 'Status', + rescan: 'Scan igen', + calibrate: 'Kalibrer', + calibrateReset: 'Nulstil kalibrering', + help: 'Hjælp', + change: 'Forandring', + menu: 'Menu', + clearOverrides: 'Ryd tilsidesættelser', + confirmReset: 'Ja, Fjern alle Hexes', + }, + prompts: { + name: 'Placeringsnavn (lad tom for at rydde)', + }, + values: { + on: 'På', + off: 'Slukket', + none: 'Ingen', + hexLayer: { + auto: 'Auto (forgrund, hvis tilgængelig)', + foreground: 'forgrundslaget', + objects: 'symbollag', + }, + revealBy: { + players: 'Spillerpoletter', + characters: 'Karakter tokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Klar', + glimpse: 'Glimt', + }, + announce: { + all: 'Alle sammen', + gm: 'Kun GM', + off: 'Slukket', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + conceal: 'Skjule', + }, + }, + settings: { + language: { + label: 'Sprog', + desc: 'Sprog til menuer, beskeder og uddelingskopier.', + }, + hexLayer: { + label: 'Hex lag', + desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + }, + fillColor: { + label: 'Fyld farve', + desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfarve', + desc: 'Farve på omridset af nye sekskanter.', + }, + labelColor: { + label: 'Etiket farve', + desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + }, + glimpseColor: { + label: 'Glimt farve', + desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', + }, + strokeWidth: { + label: 'Border Bredde', + desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', + }, + revealDistance: { + label: 'Synsafstand', + desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + }, + lineOfSight: { + label: 'Synslinie', + desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', + }, + revealPath: { + label: 'Afsløre langs stien', + desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + }, + revealBy: { + label: 'Tokens, der afslører', + desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', + }, + announce: { + label: 'Annoncer opdagelser', + desc: 'Hvem ser chatbeskeden, når en navngivet placering opdages.', + }, + pingDiscoveries: { + label: 'Ping opdagelser', + desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', + }, + }, + status: { + engine: 'Spil motor', + grid: 'Gitter', + layer: 'Hex lag', + hexes: 'Hekser', + named: 'Navngivne hexes', + icons: 'Placeringstokens', + glimpsed: 'Glimpede sekskanter', + pending: 'Steder, der venter på udfyldning', + calibrated: 'Kalibreret', + overrides: 'Side tilsidesætter', + undo: 'Fortryd tilgængelig', + }, + messages: { + filled: + 'Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.', + revealed: '{count} hexes afsløret.', + revealedPage: 'Alle {count} hexes på siden afsløret.', + confirmReset: + 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: '{count} sekskanter fjernet fra siden.', + undone: + 'Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.', + named: '{count} hexes med navnet "{name}".', + unnamed: 'Navnet er ryddet fra {count} hexes.', + marked: + '{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.', + unmarked: '{count} tokens er ikke længere placeringer.', + settingChanged: '{setting} indstillet til {value}.', + rescanned: + 'Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.', + calibrated: + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.', + calibrationReset: + 'Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.', + journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + migrated: + 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', + pruned: + '{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + readyHint: + 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + }, + warnings: { + foregroundUnavailable: + 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', + someFailed: '{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.', + }, + errors: { + noPage: 'Kunne ikke finde siden at arbejde på.', + notHex: 'Denne side bruger ikke et hex-gitter.', + noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', + emptyArea: 'Det valgte område indeholder ingen hex-centre.', + tooMany: 'Det ville skabe {count} hexes, hvilket er for mange på én gang.', + nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', + nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + noTokens: 'Vælg først et eller flere tokens.', + noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + nothingToUndo: 'Der er ingen udfyldning at fortryde.', + unknownCommand: 'Ukendt kommando: {command}', + unknownSetting: 'Ukendt indstilling: {key}', + unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', + invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', + unexpected: 'Noget gik galt: {message}', + }, + hints: { + noPage: 'Åbn den side, du vil arbejde på, eller vælg noget på den.', + notHex: 'Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.', + noPolygons: + 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', + emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', + tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', + noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', + unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', + calibrateNeedsTokens: + 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + calibrateFailed: + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + unexpected: 'Detaljer er i API-konsolloggen.', + }, + help: { + menu: 'Vis menuen.', + fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', + undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', + reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', + revealPage: 'Afslør hver hex på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', + resetPage: 'Fjern hver hex på siden (spørg først).', + name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + mark: 'Gør de valgte tokens til skjulte placeringer.', + unmark: 'Stop de valgte tokens med at være skjulte placeringer.', + set: 'Skift en indstilling, eller vis alle indstillinger.', + pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', + pageClear: 'Fjern den aktuelle sides tilsidesættelser.', + rescan: + 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + calibrate: + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + calibrateReset: 'Fjern den aktuelle sides kalibrering.', + status: 'Vis, hvad Hexploration ved om den aktuelle side.', + journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + help: 'Vis denne liste.', + handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', + }, + deck: { + subtitle: 'Kommandodæk', + drawDesc: + 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', + revealDesc: + 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', + locationsDesc: + 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + toolsDesc: + 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', + footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-udforskning for Roll20', + footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + overview: { + heading: 'Oversigt', + body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + demo: 'Se en kort demo (fra version 1)', + }, + quickStart: { + heading: 'Hurtig start', + steps: [ + 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', + 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', + 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', + 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', + 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', + ], + }, + commands: { + heading: 'Kommandoer', + intro: + "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", + colCommand: 'Kommando', + colDesc: 'Hvad den gør', + }, + revealing: { + heading: 'Sådan fungerer afsløring', + points: [ + 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', + 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', + 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', + 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + ], + }, + locations: { + heading: 'Navngivne Hekser og Steder', + points: [ + 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', + 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', + ], + }, + settings: { + heading: 'Indstillinger', + intro: + "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + colKey: 'Nøgle', + colName: 'Indstilling', + colDesc: 'Beskrivelse', + perPage: '(Kan indstilles pr. side.)', + }, + jumpgate: { + heading: 'Jumpgate og Legacy', + points: [ + 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', + 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + ], + }, + upgrading: { + heading: 'Opgradering fra version 1', + points: [ + 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', + 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', + 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', + ], + colV1: 'Version 1 kommando', + colV2: 'Version 2 kommando', + }, + troubleshooting: { + heading: 'Fejlfinding', + points: [ + 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', + 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', + 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', + 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', + ], + }, + languages: { + heading: 'Sprog', + body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + }, + credits: { + heading: 'Credits', + original: 'Original mod af', + maintainer: 'Version 2 vedligeholdes af', + marketplace: 'Adas kunstpakker på Roll20 Marketplace', + support: + 'Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.', + }, + }, + }; + + var localeNl = {}; + + var localeEnUS = { + titles: { + ready: 'Hexploration is ready.', + settings: 'Hexploration Settings', + languages: 'Choose a Language', + pageSettings: 'Page Settings: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration Commands', + confirm: 'Please Confirm', + }, + discovery: { + title: 'Location Discovered', + }, + menu: { + draw: 'Draw', + reveal: 'Reveal and Hide', + locations: 'Locations', + tools: 'Tools', + layerInUse: 'New hexes are being drawn on the {layer}.', + pageSettingsHelp: + 'These settings apply to this page only. Settings marked ★ override the global settings.', + }, + buttons: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + undo: 'Undo Fill', + reveal: 'Reveal', + conceal: 'Conceal', + explore: 'Explore', + revealPage: 'Reveal Page', + resetPage: 'Reset Page', + mark: 'Mark Location', + unmark: 'Unmark', + name: 'Name Hex', + settings: 'Settings', + pageSettings: 'Page Settings', + status: 'Status', + rescan: 'Rescan', + calibrate: 'Calibrate', + calibrateReset: 'Reset Calibration', + help: 'Help', + change: 'Change', + menu: 'Menu', + clearOverrides: 'Clear Overrides', + confirmReset: 'Yes, Remove All Hexes', + }, + prompts: { + name: 'Location name (leave empty to clear)', + }, + values: { + on: 'On', + off: 'Off', + none: 'None', + hexLayer: { + auto: 'Auto (foreground if available)', + foreground: 'foreground layer', + objects: 'token layer', + }, + revealBy: { + players: 'Player tokens', + characters: 'Character tokens', + all: 'All tokens', + }, + revealMode: { + clear: 'Clear', + glimpse: 'Glimpse', + }, + announce: { + all: 'Everyone', + gm: 'GM only', + off: 'Off', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + conceal: 'Conceal', + }, + }, + settings: { + language: { + label: 'Language', + desc: 'Language for menus, messages and handouts.', + }, + hexLayer: { + label: 'Hex Layer', + desc: 'Where new hexes are drawn. Auto tries the foreground layer (above tokens) and falls back to the token layer if the game does not support it.', + }, + fillColor: { + label: 'Fill Colour', + desc: 'Colour of new hexes. Use rgba() for see-through hexes, for example rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Border Colour', + desc: 'Colour of the outline of new hexes.', + }, + labelColor: { + label: 'Label Colour', + desc: 'Colour of the GM-only name labels on named hexes.', + }, + glimpseColor: { + label: 'Glimpse Colour', + desc: 'Colour hexes change to when glimpsed (Glimpse reveal mode). Use a see-through rgba() colour.', + }, + strokeWidth: { + label: 'Border Width', + desc: 'Width of the outline of new hexes, in pixels (0 to 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Applied to hexes as they are drawn: a token must be within this many hexes to reveal them, however far it can see. Leave empty for no limit.', + }, + revealDistance: { + label: 'Sight Distance', + desc: 'How many hexes around a moving token are revealed (0 to 20). 0 reveals only the hexes the token passes through.', + }, + lineOfSight: { + label: 'Line of Sight', + desc: 'When on, a hex is only revealed if no covered hex lies between it and the token.', + }, + revealPath: { + label: 'Reveal Along Path', + desc: 'When on, every hex a token passes through while being dragged (including waypoints) is revealed, not just where it stops.', + }, + revealBy: { + label: 'Tokens That Reveal', + desc: 'Which tokens on the token layer reveal hexes: tokens controlled by a player, tokens that represent any character, or every token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear removes hexes within sight. Glimpse makes them see-through instead; they are removed when a token enters them.', + }, + announce: { + label: 'Announce Discoveries', + desc: 'Who sees the chat message when a named location is discovered.', + }, + pingDiscoveries: { + label: 'Ping Discoveries', + desc: 'When on, players are pinged to a named location when it is discovered.', + }, + hideCoveredTokens: { + label: 'Hide Covered Tokens', + desc: 'Roll20 draws names, bars and auras above hexes. When on, tokens under a covered hex have their player-visible name, bars and auras switched off, and switched back on when they are uncovered.', + }, + }, + status: { + engine: 'Game engine', + grid: 'Grid', + layer: 'Hex layer', + hexes: 'Hexes', + named: 'Named hexes', + icons: 'Location tokens', + glimpsed: 'Glimpsed hexes', + pending: 'Locations waiting for a fill', + calibrated: 'Calibrated', + overrides: 'Page overrides', + undo: 'Undo available', + }, + messages: { + filled: + 'Fill complete. Hexes drawn: {created}. Restyled: {restyled}. Locations hidden: {icons}.', + revealed: 'Hexes revealed: {count}.', + revealedPage: 'Every hex on the page revealed ({count}).', + confirmReset: + 'Remove every hex from "{page}" ({count})? Location tokens return to the token layer. Undo cannot reverse this.', + resetPage: 'Hexes removed from the page: {count}.', + undone: 'Last fill undone. Hexes removed: {removed}. Restyled hexes restored: {restored}.', + named: 'Hexes named "{name}": {count}.', + unnamed: 'Names cleared: {count}.', + marked: + 'Locations hidden in existing hexes: {attached}. Waiting for the next fill that covers them: {pending}.', + unmarked: 'Tokens that are no longer locations: {count}.', + settingChanged: '{setting} set to {value}.', + rescanned: + 'Rescan complete. Kept: {kept}. Adopted: {adopted}. Re-filed: {moved}. Missing and forgotten: {dropped}. Labels re-linked: {labels}. Location tokens re-linked: {icons}.', + calibrated: + 'Grid calibrated (column step {colStep}px, row step {rowStep}px). Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + calibrationReset: + 'Calibration removed. Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + 'Your Hexploration 1.x hex maps have been upgraded. If this game was copied from a Legacy game, run Rescan on each hex map page.', + pruned: + 'Saved hexes that no longer exist and were forgotten: {dropped}. If this game or page was copied, run Rescan on the page to pick its hexes up again.', + readyHint: + 'Type !hexploration for the menu, or open the "Hexploration - Command Deck" handout.', + }, + warnings: { + foregroundUnavailable: + 'This game does not support drawing on the foreground layer, so hexes were drawn on the token layer.', + someFailed: 'Hexes that could not be drawn: {count}. Check the API console for details.', + }, + errors: { + noPage: 'Could not find the page to work on.', + notHex: 'This page does not use a hex grid.', + noPolygons: 'Select one or more drawn shapes to fill.', + emptyArea: 'The selected area does not contain any hex centres.', + tooMany: 'That would create too many hexes in one go ({count}).', + nothingToConceal: 'Select drawn shapes or tokens to conceal.', + nothingToReveal: 'Select hexes, drawn shapes or tokens to reveal.', + noTokens: 'Select one or more tokens first.', + noHexes: 'Select one or more hexes (or tokens standing on hexes) first.', + nothingToUndo: 'There is no fill to undo.', + unknownCommand: 'Unknown command: {command}', + unknownSetting: 'Unknown setting: {key}', + unknownPageSetting: 'Settings that can be set per page: {keys}', + invalidValue: '"{value}" is not a valid value for {key}.', + calibrateNeedsTokens: 'Select one or two tokens snapped to hex centres.', + calibrateFailed: 'Those tokens cannot be used to calibrate.', + unexpected: 'Something went wrong: {message}', + }, + hints: { + noPage: 'Open the page you want to work on, or select something on it.', + notHex: 'Set the page grid to Hex (V) or Hex (H) in Page Settings.', + noPolygons: + 'Draw a polygon, rectangle, ellipse or freehand shape around the area, select it, then try again.', + emptyArea: 'Draw a larger shape, or check the page grid settings.', + tooMany: 'Fill a smaller area, or split the area into several shapes.', + noHexes: 'Hexes are on the foreground or token layer; switch to that layer to select them.', + unknownCommand: 'Type !hexploration help to list the commands.', + unknownSetting: 'Type !hexploration set to see every setting.', + calibrateNeedsTokens: + 'Snap a token to the centre of a hex and select it. Select a second token snapped to a neighbouring hex in the same row (Hex V) or column (Hex H) to correct the hex size too.', + calibrateFailed: + 'Two tokens must be in the same row (Hex V) or the same column (Hex H), at least one hex apart.', + unexpected: 'Details are in the API console log.', + }, + help: { + menu: 'Show the menu.', + fill: 'Cover the selected drawn shapes with hexes.', + fillInverse: 'Cover the whole page except inside the selected shapes.', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: 'Reveal the selected hexes, and the hexes under the selected shapes and tokens.', + revealPage: 'Reveal every hex on the page without announcements.', + conceal: 'Cover the area under the selected shapes and tokens with hexes again.', + explore: 'Reveal around the selected tokens as if they had just moved there.', + resetPage: 'Remove every hex on the page (asks first).', + name: 'Name the selected hexes, or the hexes under the selected tokens. Leave the name empty to clear it.', + mark: 'Turn the selected tokens into hidden locations.', + unmark: 'Stop the selected tokens being hidden locations.', + set: 'Change a setting, or show all settings.', + pageSet: 'Override a reveal setting on the current page only.', + pageClear: 'Remove the current page’s overrides.', + rescan: 'Rebuild the page’s hex list, for example after copying a page or game.', + calibrate: 'Line the hex grid up with one or two selected tokens snapped to hex centres.', + calibrateReset: 'Remove the current page’s calibration.', + status: 'Show what Hexploration knows about the current page.', + journal: 'Rebuild the Help and Command Deck handouts.', + help: 'Show this list.', + handout: 'Full instructions are in the "{name}" handout.', + }, + deck: { + subtitle: 'Command Deck', + drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', + revealDesc: + 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', + locationsDesc: + 'Select tokens to hide them as locations under hexes. Select hexes or tokens to name a hex.', + toolsDesc: + 'Settings, page overrides, status, rescanning copied pages and calibrating the grid.', + footer: 'See the "{help}" handout for full instructions.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex exploration for Roll20', + footer: 'Use the "{deck}" handout for one-click controls.', + overview: { + heading: 'Overview', + body: 'Hexploration covers a hex map with opaque hexes. As the party moves, the hexes they pass through (and, if you like, the hexes around them) are removed, so the map is uncovered one hex at a time. Hidden locations can be placed under hexes and are announced when found. It works in Jumpgate and Legacy games, on Hex (V) and Hex (H) grids of any size.', + demo: 'Watch a short demo (from version 1)', + }, + quickStart: { + heading: 'Quick Start', + steps: [ + 'Open a page whose grid is set to Hex (V) or Hex (H).', + 'Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide.', + 'Select the shapes and click Fill in the Command Deck (or type !hexploration fill). The shapes are replaced by hexes.', + 'Optional: before filling, select tokens for important places and click Mark Location. They are hidden under the hexes and announced when discovered.', + 'Move a player token. Every hex it passes through, and the hexes within its Sight Distance, are revealed.', + ], + }, + commands: { + heading: 'Commands', + intro: + 'Only GMs can use these commands. Most act on the selected objects; the rest act on the page you are viewing.', + colCommand: 'Command', + colDesc: 'What it does', + }, + revealing: { + heading: 'How Revealing Works', + points: [ + 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', + 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', + 'Sight Distance reveals the hexes around each of those hexes. With Line of Sight on, a hex is only revealed if no covered hex lies in between.', + 'Hex Reveal Distance is stored on hexes as they are drawn. Those hexes are only revealed from within that many hexes, however far a token can see. Use it for mountains or forests that hide what is behind them.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them.', + 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + ], + }, + locations: { + heading: 'Named Hexes and Locations', + points: [ + 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', + 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', + 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', + ], + }, + settings: { + heading: 'Settings', + intro: + 'Change settings with !hexploration set (or the Settings button). Hex Layer, Tokens That Reveal and Language can also be set on the Mod’s settings page.', + colKey: 'Key', + colName: 'Setting', + colDesc: 'Description', + perPage: '(Can be set per page.)', + }, + jumpgate: { + heading: 'Jumpgate and Legacy', + points: [ + 'Hexploration works out which engine the game uses and draws the matching kind of shape. Shapes drawn in either editor can be filled.', + 'With Hex Layer set to Auto, hexes are drawn on the foreground layer, above tokens, so players cannot see what is underneath. If the foreground layer is not available, the token layer is used instead.', + 'Jumpgate draws mathematically regular hexes, which are a slightly different shape from Legacy hexes. If the hexes do not line up with a page’s grid, snap a token to a hex centre, select it and click Calibrate. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size too.', + 'When a page or game is copied, its hexes get new IDs. Run Rescan on the page to pick them up again, together with their name labels and location tokens.', + ], + }, + upgrading: { + heading: 'Upgrading from Version 1', + points: [ + 'Version 2 no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. You can remove them unless another mod uses them.', + 'Existing hex maps, names, location tokens and settings are upgraded automatically on the first start.', + 'The version 1 commands, including the Hexploration_menu macro, still work.', + 'Version 1 let any token that represented a character reveal hexes. Set Tokens That Reveal to Character tokens to keep that behaviour.', + ], + colV1: 'Version 1 command', + colV2: 'Version 2 command', + }, + troubleshooting: { + heading: 'Troubleshooting', + points: [ + 'Nothing happens when a token moves: check the token is on the token layer and matches Tokens That Reveal, and that the page has hexes (!hexploration status).', + 'Hexes are offset from the grid: use Calibrate, then check with a token on a few hexes across the map.', + 'Hexes stopped revealing after copying a page or game: run Rescan on the page.', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: 'Languages', + body: 'Choose a language with !hexploration set language. Available languages:', + }, + credits: { + heading: 'Credits', + original: 'Original mod by', + maintainer: 'Version 2 maintained by', + marketplace: 'Ada’s art packs on the Roll20 Marketplace', + support: + 'If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log.', + }, + }, + }; + + var localeFi = {}; + + var localeFr = {}; + + var localeDe = {}; + + var localeEl = {}; + + var localeHe = {}; + + var localeHu = {}; + + var localeIt = {}; + + var localeJa = {}; + + var localeKo = {}; + + var localePl = {}; + + var localePtPT = {}; + + var localePtBR = {}; + + var localeRu = {}; + + var localeEs = {}; + + var localeSv = {}; + + var localeTr = {}; + + var localeUk = {}; + + const DEFAULT_LOCALE = 'en-US'; + + const LOCALE_DEFINITIONS = Object.freeze([ + { + code: 'af', + name: 'Afrikaans', + direction: 'ltr', + translationFile: 'locale/af.js', + flag: '🇿🇦', + flagLabel: 'Flag of South Africa', + }, + { + code: 'ca', + name: 'Catalan', + nativeName: 'Català', + direction: 'ltr', + translationFile: 'locale/ca.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'zh-TW', + name: 'Chinese (Traditional)', + nativeName: '正體中文', + direction: 'ltr', + translationFile: 'locale/zh-TW.js', + aliases: ['zh'], + flag: '🇹🇼', + flagLabel: 'Flag of Taiwan', + }, + { + code: 'cs', + name: 'Czech', + nativeName: 'Čeština', + direction: 'ltr', + translationFile: 'locale/cs.js', + flag: '🇨🇿', + flagLabel: 'Flag of Czechia', + }, + { + code: 'da', + name: 'Danish', + nativeName: 'Dansk', + direction: 'ltr', + translationFile: 'locale/da.js', + flag: '🇩🇰', + flagLabel: 'Flag of Denmark', + }, + { + code: 'nl', + name: 'Dutch', + nativeName: 'Nederlands', + direction: 'ltr', + translationFile: 'locale/nl.js', + flag: '🇳🇱', + flagLabel: 'Flag of the Netherlands', + }, + { + code: 'en-US', + name: 'English', + nativeName: 'English', + direction: 'ltr', + translationFile: 'locale/en-US.js', + aliases: ['en'], + flag: '🇺🇸', + flagLabel: 'Flag of the United States', + }, + { + code: 'fi', + name: 'Finnish', + nativeName: 'Suomeksi', + direction: 'ltr', + translationFile: 'locale/fi.js', + flag: '🇫🇮', + flagLabel: 'Flag of Finland', + }, + { + code: 'fr', + name: 'French', + nativeName: 'Français', + direction: 'ltr', + translationFile: 'locale/fr.js', + flag: '🇫🇷', + flagLabel: 'Flag of France', + }, + { + code: 'de', + name: 'German', + nativeName: 'Deutsch', + direction: 'ltr', + translationFile: 'locale/de.js', + flag: '🇩🇪', + flagLabel: 'Flag of Germany', + }, + { + code: 'el', + name: 'Greek', + nativeName: 'Ελληνικά', + direction: 'ltr', + translationFile: 'locale/el.js', + flag: '🇬🇷', + flagLabel: 'Flag of Greece', + }, + { + code: 'he', + name: 'Hebrew', + nativeName: 'עברית', + direction: 'rtl', + translationFile: 'locale/he.js', + flag: '🇮🇱', + flagLabel: 'Flag of Israel', + }, + { + code: 'hu', + name: 'Hungarian', + nativeName: 'Magyar', + direction: 'ltr', + translationFile: 'locale/hu.js', + flag: '🇭🇺', + flagLabel: 'Flag of Hungary', + }, + { + code: 'it', + name: 'Italian', + nativeName: 'Italiano', + direction: 'ltr', + translationFile: 'locale/it.js', + flag: '🇮🇹', + flagLabel: 'Flag of Italy', + }, + { + code: 'ja', + name: 'Japanese', + nativeName: '日本語', + direction: 'ltr', + translationFile: 'locale/ja.js', + flag: '🇯🇵', + flagLabel: 'Flag of Japan', + }, + { + code: 'ko', + name: 'Korean', + nativeName: '한국어', + direction: 'ltr', + translationFile: 'locale/ko.js', + flag: '🇰🇷', + flagLabel: 'Flag of South Korea', + }, + { + code: 'pl', + name: 'Polish', + nativeName: 'Polski', + direction: 'ltr', + translationFile: 'locale/pl.js', + flag: '🇵🇱', + flagLabel: 'Flag of Poland', + }, + { + code: 'pt-PT', + name: 'Portuguese (Portugal)', + nativeName: 'Português - Portugal', + direction: 'ltr', + translationFile: 'locale/pt-PT.js', + aliases: ['pt'], + flag: '🇵🇹', + flagLabel: 'Flag of Portugal', + }, + { + code: 'pt-BR', + name: 'Portuguese (Brazil)', + nativeName: 'Português - Brasil', + direction: 'ltr', + translationFile: 'locale/pt-BR.js', + flag: '🇧🇷', + flagLabel: 'Flag of Brazil', + }, + { + code: 'ru', + name: 'Russian', + nativeName: 'Русский', + direction: 'ltr', + translationFile: 'locale/ru.js', + flag: '🇷🇺', + flagLabel: 'Flag of Russia', + }, + { + code: 'es', + name: 'Spanish', + nativeName: 'Español', + direction: 'ltr', + translationFile: 'locale/es.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'sv', + name: 'Swedish', + nativeName: 'Svenska', + direction: 'ltr', + translationFile: 'locale/sv.js', + flag: '🇸🇪', + flagLabel: 'Flag of Sweden', + }, + { + code: 'tr', + name: 'Turkish', + nativeName: 'Türkçe', + direction: 'ltr', + translationFile: 'locale/tr.js', + flag: '🇹🇷', + flagLabel: 'Flag of Turkey', + }, + { + code: 'uk', + name: 'Ukrainian', + nativeName: 'Українська', + direction: 'ltr', + translationFile: 'locale/uk.js', + flag: '🇺🇦', + flagLabel: 'Flag of Ukraine', + }, + ]); + + const SUPPORTED_LOCALES = Object.freeze(LOCALE_DEFINITIONS.map(({ code }) => code)); + const VALID_LOCALES = new Set(SUPPORTED_LOCALES); + const LOCALE_ALIASES = Object.freeze( + LOCALE_DEFINITIONS.reduce((aliases, locale) => { + for (const alias of locale.aliases || []) { + aliases[alias] = locale.code; + } + return aliases; + }, {}) + ); + const LOCALE_LABELS = Object.freeze( + LOCALE_DEFINITIONS.reduce((labels, locale) => { + const displayName = locale.nativeName + ? `${locale.code} - ${locale.name} (${locale.nativeName})` + : `${locale.code} - ${locale.name}`; + labels[locale.code] = displayName; + return labels; + }, {}) + ); + SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); + + const TRANSLATIONS = { + af: TRANSLATION$4, + ca: TRANSLATION$3, + 'zh-TW': TRANSLATION$2, + cs: TRANSLATION$1, + da: TRANSLATION, + nl: localeNl, + 'en-US': localeEnUS, + fi: localeFi, + fr: localeFr, + de: localeDe, + el: localeEl, + he: localeHe, + hu: localeHu, + it: localeIt, + ja: localeJa, + ko: localeKo, + pl: localePl, + 'pt-PT': localePtPT, + 'pt-BR': localePtBR, + ru: localeRu, + es: localeEs, + sv: localeSv, + tr: localeTr, + uk: localeUk, + }; + + /** + * Returns the canonical locale for a supported locale string or alias. + * Matching is case-insensitive after exact matches are checked. + * + * @param {string} lang Locale string or alias (e.g. 'en', 'fr', 'zh-TW'). + * @returns {string} Canonical locale code, or an empty string when unsupported. + */ + function normalizeLocale(lang) { + const s = typeof lang === 'string' ? lang.trim() : ''; + if (VALID_LOCALES.has(s)) { + return s; + } + if (LOCALE_ALIASES[s]) { + return LOCALE_ALIASES[s]; + } + const normalized = s.toLowerCase(); + const found = Array.from(VALID_LOCALES).find((locale) => locale.toLowerCase() === normalized); + return ( + found || + Object.entries(LOCALE_ALIASES).find(([alias]) => alias.toLowerCase() === normalized)?.[1] || + '' + ); + } + + /** + * Returns a valid canonical locale, falling back to the default when unsupported. + * + * @param {string} lang Locale string to validate. + * @returns {string} Validated canonical locale. + */ + function getLocale(lang) { + return normalizeLocale(lang) || DEFAULT_LOCALE; + } + + /** + * Navigates a nested object following dot-separated key path segments. + * + * @param {object} obj Root object. + * @param {string[]} parts Key path segments. + * @returns {*} Value at the path, or undefined. + */ + function getNestedValue(obj, parts) { + let current = obj; + for (const part of parts) { + if (current == null || typeof current !== 'object') { + return undefined; + } + current = current[part]; + } + return current; + } + + /** + * Returns the raw translated value (string, array or object) for a key, + * falling back to en-US when the key is missing in the requested locale. + * + * @param {string} key Dot-separated translation key. + * @param {string} locale Locale code. + * @returns {*} Raw value, or undefined when not found. + */ + function tRaw(key, locale) { + const lang = getLocale(locale); + const parts = key.split('.'); + const value = getNestedValue(TRANSLATIONS[lang], parts); + return value === undefined && lang !== DEFAULT_LOCALE + ? getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts) + : value; + } + + /** + * Returns the text direction CSS for a locale. + * + * @param {string} locale Locale code. + * @returns {string} CSS declarations, empty for left-to-right locales. + */ + function getDirectionStyle(locale) { + const lang = getLocale(locale); + const def = LOCALE_DEFINITIONS.find((d) => d.code === lang); + return def?.direction === 'rtl' ? 'direction:rtl;text-align:right;' : ''; + } + + /** + * Returns the translated string for a dot-separated key, interpolating {placeholder} vars. + * Falls back to en-US when the key is missing in the requested locale. + * No HTML escaping is performed — callers must pre-escape HTML-unsafe values. + * + * @param {string} key Dot-separated translation key (e.g. 'errors.noTokensSelected'). + * @param {string} locale Locale code. + * @param {object} [vars] Interpolation variables mapped to {placeholder} names. + * @returns {string} Translated and interpolated string. Returns the key when not found. + */ + function t(key, locale, vars = {}) { + const lang = getLocale(locale); + const parts = key.split('.'); + let value = getNestedValue(TRANSLATIONS[lang], parts); + + if (value === undefined && lang !== DEFAULT_LOCALE) { + value = getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts); + } + + if (typeof value !== 'string') { + return key; + } + + return value.replaceAll(/\{(\w+)\}/g, (_, k) => (k in vars ? String(vars[k]) : `{${k}}`)); + } + + // --------------------------------------------------------------------------- + // Config validation (pure) + // --------------------------------------------------------------------------- + + /** + * Validates one configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Result; `value` is the normalised value when valid. + */ + function validateConfigValue(key, raw) { + const ok = (value) => ({ valid: true, value }); + const bad = { valid: false }; + + switch (key) { + case 'language': { + const lang = normalizeLocale(raw); + return lang ? ok(lang) : bad; + } + case 'hexLayer': + return HEX_LAYER_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealBy': + return REVEAL_BY_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealMode': + return REVEAL_MODE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'announce': + return ANNOUNCE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'fillColor': + case 'strokeColor': + case 'labelColor': + case 'glimpseColor': + return isValidColor(raw) ? ok(toText(raw)) : bad; + case 'strokeWidth': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 ? bad : ok(clamp(n, 0, MAX_STROKE_WIDTH)); + } + case 'revealDistance': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'maxDistance': { + if (raw === null || raw === undefined || ['', '-', 'none', 'off'].includes(toText(raw))) { + return ok(null); + } + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'lineOfSight': + case 'revealPath': + case 'pingDiscoveries': + case 'hideCoveredTokens': { + const b = parseBoolean(raw); + return b === null ? bad : ok(b); + } + default: + return bad; + } + } + + /** + * Merges a possibly incomplete or invalid config with defaults. + * + * @param {object} config Config to merge. + * @param {object} [defaults] Defaults to fall back on. + * @returns {object} Complete config. + */ + function mergeConfig(config, defaults = DEFAULT_CONFIG) { + const c = isRecord(config) ? config : {}; + const merged = {}; + for (const key of Object.keys(DEFAULT_CONFIG)) { + const result = key in c ? validateConfigValue(key, c[key]) : { valid: false }; + merged[key] = result.valid ? result.value : defaults[key]; + } + return merged; + } + + /** + * Keeps only valid per-page overrides. + * + * @param {object} settings Raw page settings. + * @returns {object} Clean page settings. + */ + function mergePageSettings(settings) { + const clean = {}; + if (!isRecord(settings)) { + return clean; + } + for (const key of PAGE_SETTING_KEYS) { + if (key in settings) { + const result = validateConfigValue(key, settings[key]); + if (result.valid) { + clean[key] = result.value; + } + } + } + return clean; + } + + // --------------------------------------------------------------------------- + // State shape and migration (pure) + // --------------------------------------------------------------------------- + + /** + * Creates an empty v2 state object. + * + * @returns {object} Fresh state. + */ + function createDefaultState() { + return { + schemaVersion: SCHEMA_VERSION, + version: SCRIPT_VERSION, + config: { ...DEFAULT_CONFIG }, + pages: {}, + pendingLocations: {}, + lastFill: null, + coveredTokens: {}, + notices: {}, + }; + } + + /** + * Normalises one stored hex record. + * + * @param {string} key "row,col" key. + * @param {object} raw Stored record. + * @returns {object|null} Clean hex record, or null when unusable. + */ + function normaliseHex(key, raw) { + const coords = parseHexKey(key); + if (!coords || !isRecord(raw) || !toText(raw.id)) { + return null; + } + const hex = { + id: toText(raw.id), + type: raw.type === 'pathv2' ? 'pathv2' : raw.type === 'path' ? 'path' : null, + row: coords[0], + col: coords[1], + }; + if (toText(raw.name)) { + hex.name = toText(raw.name); + } + if (toText(raw.nameId)) { + hex.nameId = toText(raw.nameId); + } + if (toText(raw.iconId)) { + hex.iconId = toText(raw.iconId); + } + const maxDistance = validateConfigValue('maxDistance', raw.maxDistance); + if (maxDistance.valid && maxDistance.value !== null) { + hex.maxDistance = maxDistance.value; + } + if (raw.glimpsed === true) { + hex.glimpsed = true; + } + return hex; + } + + /** + * Normalises a page's stored data. + * + * @param {object} raw Stored page data. + * @returns {object} Clean page data. + */ + function normalisePage(raw) { + const page = { hexes: {}, settings: {}, calibration: null }; + if (!isRecord(raw)) { + return page; + } + if (isRecord(raw.hexes)) { + for (const [key, value] of Object.entries(raw.hexes)) { + const hex = normaliseHex(key, value); + if (hex) { + page.hexes[`${hex.row},${hex.col}`] = hex; + } + } + } + page.settings = mergePageSettings(raw.settings); + if (isRecord(raw.calibration)) { + const cal = {}; + for (const k of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(raw.calibration[k])) { + cal[k] = raw.calibration[k]; + } + } + page.calibration = Object.keys(cal).length === 4 ? cal : null; + } + return page; + } + + /** + * Converts any stored state (v1, v2 or damaged) into a clean v2 state. + * + * v1 stored hexes in `pageHexes[pageId]["row,col"]` with a parallel `hexIdMap`, + * and a flat config. Its defaults differed (no reveal distance), so missing + * v1 values fall back to v1 behaviour rather than the new defaults. + * + * @param {*} raw Stored state. + * @returns {{state: object, migratedFrom: number|null}} Clean state and the + * schema it was migrated from (null when no migration was needed). + */ + function migrateState(raw) { + const fresh = createDefaultState(); + if (!isRecord(raw)) { + return { state: fresh, migratedFrom: null }; + } + + if (isRecord(raw.pageHexes) && !isRecord(raw.pages)) { + const v1Defaults = { ...DEFAULT_CONFIG, revealDistance: 0, strokeWidth: 0 }; + fresh.config = mergeConfig(raw.config, v1Defaults); + for (const [pageId, hexes] of Object.entries(raw.pageHexes)) { + const page = normalisePage({ hexes }); + if (Object.keys(page.hexes).length > 0) { + fresh.pages[pageId] = page; + } + } + return { state: fresh, migratedFrom: 1 }; + } + + fresh.config = mergeConfig(raw.config); + if (isRecord(raw.pages)) { + for (const [pageId, page] of Object.entries(raw.pages)) { + fresh.pages[pageId] = normalisePage(page); + } + } + if (isRecord(raw.pendingLocations)) { + for (const [tokenId, pageId] of Object.entries(raw.pendingLocations)) { + if (toText(pageId)) { + fresh.pendingLocations[tokenId] = toText(pageId); + } + } + } + if (isRecord(raw.lastFill)) { + fresh.lastFill = raw.lastFill; + } + if (isRecord(raw.coveredTokens)) { + for (const [tokenId, entry] of Object.entries(raw.coveredTokens)) { + if (isRecord(entry) && toText(entry.pageId) && isRecord(entry.saved)) { + fresh.coveredTokens[tokenId] = { + pageId: toText(entry.pageId), + saved: { ...entry.saved }, + }; + } + } + } + if (isRecord(raw.notices)) { + fresh.notices = { ...raw.notices }; + } + return { state: fresh, migratedFrom: null }; + } + + // --------------------------------------------------------------------------- + // Persistent state access (Roll20) + // --------------------------------------------------------------------------- + + let pathIndex = null; + + /** + * Loads, migrates and validates the persistent state. Call once on ready. + * + * @returns {number|null} The schema migrated from, or null. + */ + function initialiseState() { + const { state: clean, migratedFrom } = migrateState(state[STATE_KEY]); + clean.version = SCRIPT_VERSION; + state[STATE_KEY] = clean; + pathIndex = null; + return migratedFrom; + } + + /** + * Returns the persistent state, creating it when missing. + * + * @returns {object} State branch. + */ + function getState() { + if (!isRecord(state[STATE_KEY]) || state[STATE_KEY].schemaVersion !== SCHEMA_VERSION) { + initialiseState(); + } + return state[STATE_KEY]; + } + + /** + * Returns the global configuration. + * + * @returns {object} Config. + */ + function getConfig() { + return getState().config; + } + + /** + * Sets one global configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setConfigValue(key, raw) { + if (!(key in DEFAULT_CONFIG)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getState().config[key] = result.value; + } + return result; + } + + /** + * Imports Roll20 One-Click useroptions into the persisted config. + * + * @returns {void} + */ + function applyGlobalConfig() { + if (typeof globalconfig === 'undefined' || !isRecord(globalconfig)) { + return; + } + const branch = globalconfig[STATE_KEY.toLowerCase()] || globalconfig[STATE_KEY]; + if (!isRecord(branch)) { + return; + } + const options = isRecord(branch.useroptions) ? branch.useroptions : branch; + const s = getState(); + // useroptions only change when the GM edits them, so remember what was last + // applied and only re-apply on change; otherwise chat changes would be + // overwritten on every restart. + const applied = isRecord(s.notices.useroptions) ? s.notices.useroptions : {}; + for (const key of ['hexLayer', 'revealBy', 'language']) { + if (key in options && options[key] !== applied[key]) { + setConfigValue(key, options[key]); + applied[key] = options[key]; + } + } + s.notices.useroptions = applied; + } + + /** + * Returns a page's stored data. + * + * @param {string} pageId Page ID. + * @param {boolean} [create=false] Create the record when missing. + * @returns {object|null} Page data. + */ + function getPageData(pageId, create = false) { + const s = getState(); + if (!s.pages[pageId] && create) { + s.pages[pageId] = { hexes: {}, settings: {}, calibration: null }; + } + return s.pages[pageId] || null; + } + + /** + * Returns the IDs of every page with stored data. + * + * @returns {string[]} Page IDs. + */ + function getPageIds() { + return Object.keys(getState().pages); + } + + /** + * Removes a page's stored data entirely. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function deletePageData(pageId) { + const s = getState(); + const page = s.pages[pageId]; + if (page && pathIndex) { + for (const hex of Object.values(page.hexes)) { + pathIndex.delete(hex.id); + } + } + delete s.pages[pageId]; + } + + /** + * Returns the settings in force on a page: global config plus page overrides. + * + * @param {string} pageId Page ID. + * @returns {object} Effective settings. + */ + function getPageSettings(pageId) { + const page = getPageData(pageId); + return { ...getConfig(), ...(page ? page.settings : {}) }; + } + + /** + * Sets a per-page override. + * + * @param {string} pageId Page ID. + * @param {string} key Setting key (must be in PAGE_SETTING_KEYS). + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setPageSetting(pageId, key, raw) { + if (!PAGE_SETTING_KEYS.includes(key)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getPageData(pageId, true).settings[key] = result.value; + } + return result; + } + + /** + * Clears all per-page overrides. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function clearPageSettings(pageId) { + const page = getPageData(pageId); + if (page) { + page.settings = {}; + } + } + + /** + * Stores or clears a page's grid calibration. + * + * @param {string} pageId Page ID. + * @param {object|null} calibration Calibration, or null to clear. + * @returns {void} + */ + function setCalibration(pageId, calibration) { + getPageData(pageId, true).calibration = calibration ? { ...calibration } : null; + } + + // --------------------------------------------------------------------------- + // Hex records + // --------------------------------------------------------------------------- + + /** + * Builds the in-memory path ID index on first use. + * + * @returns {Map} Map of path ID to [pageId, key]. + */ + function getIndex() { + if (!pathIndex) { + pathIndex = new Map(); + for (const [pageId, page] of Object.entries(getState().pages)) { + for (const [key, hex] of Object.entries(page.hexes)) { + pathIndex.set(hex.id, [pageId, key]); + } + } + } + return pathIndex; + } + + /** + * Returns a hex record. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} Hex record. + */ + function getHex(pageId, key) { + return getPageData(pageId)?.hexes[key] || null; + } + + /** + * Returns every hex record on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Hex records. + */ + function getPageHexes(pageId) { + const page = getPageData(pageId); + return page ? Object.values(page.hexes) : []; + } + + /** + * Returns the hex record drawn by a path, with its page. + * + * @param {string} pathId Path object ID. + * @returns {{pageId: string, key: string, hex: object}|null} Lookup result. + */ + function getHexByPathId(pathId) { + const entry = getIndex().get(pathId); + if (!entry) { + return null; + } + const [pageId, key] = entry; + const hex = getHex(pageId, key); + return hex ? { pageId, key, hex } : null; + } + + /** + * Stores a hex record, replacing any record at the same cell. + * + * @param {string} pageId Page ID. + * @param {object} hex Hex record with row and col. + * @returns {object} The stored record. + */ + function putHex(pageId, hex) { + const key = `${hex.row},${hex.col}`; + const page = getPageData(pageId, true); + const old = page.hexes[key]; + if (old && old.id !== hex.id) { + getIndex().delete(old.id); + } + page.hexes[key] = hex; + getIndex().set(hex.id, [pageId, key]); + return hex; + } + + /** + * Removes a hex record (not its Roll20 objects). + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} The removed record. + */ + function deleteHexRecord(pageId, key) { + const page = getPageData(pageId); + const hex = page?.hexes[key]; + if (!hex) { + return null; + } + delete page.hexes[key]; + getIndex().delete(hex.id); + return hex; + } + + // --------------------------------------------------------------------------- + // Pending locations and undo + // --------------------------------------------------------------------------- + + /** + * Returns pending location token IDs on a page (tokens marked as locations + * before the area under them was filled). + * + * @param {string} pageId Page ID. + * @returns {string[]} Token IDs. + */ + function getPendingLocations(pageId) { + return Object.entries(getState().pendingLocations) + .filter(([, page]) => page === pageId) + .map(([tokenId]) => tokenId); + } + + /** + * Adds or removes a pending location. + * + * @param {string} tokenId Token ID. + * @param {string|null} pageId Page ID, or null to remove. + * @returns {void} + */ + function setPendingLocation(tokenId, pageId) { + const pending = getState().pendingLocations; + if (pageId) { + pending[tokenId] = pageId; + } else { + delete pending[tokenId]; + } + } + + /** + * Returns the record of the last fill, used by undo. + * + * @returns {object|null} Last fill record. + */ + function getLastFill() { + return getState().lastFill; + } + + /** + * Stores or clears the record of the last fill. + * + * @param {object|null} record Fill record. + * @returns {void} + */ + function setLastFill(record) { + getState().lastFill = record; + } + + /** + * Returns the saved player-visible properties of tokens hidden under hexes. + * + * @returns {object} Map of token ID to { pageId, saved }. + */ + function getCoveredTokens() { + return getState().coveredTokens; + } + + /** + * Builds the hex grid for a page, including any calibration. + * + * @param {object} page Roll20 page. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function buildPageGrid(page) { + const pageId = page.get('_id'); + return createGrid({ + gridType: page.get('grid_type'), + // snapping_increment is 0 when snapping is off; the grid is still drawn at 1 unit. + scale: Number(page.get('snapping_increment')) || 1, + jumpgate: isJumpgate(), + // Set by Jumpgate's map alignment tool. + offsetX: Number(page.get('grid_offset_x')) || 0, + offsetY: Number(page.get('grid_offset_y')) || 0, + calibration: getPageData(pageId)?.calibration || null, + }); + } + + /** + * Returns everything needed to work on a page's hexes. + * + * @param {string} pageId Page ID. + * @returns {{ok: true, pageId: string, page: object, grid: object}|{ok: false, reason: string}} + * Context, or the reason it is unavailable ('noPage' or 'notHex'). + */ + function getPageContext(pageId) { + const page = pageId ? getObj('page', pageId) : null; + if (!page) { + return { ok: false, reason: 'noPage' }; + } + const grid = buildPageGrid(page); + if (!grid) { + return { ok: false, reason: 'notHex' }; + } + return { ok: true, pageId, page, grid }; + } + + // Hiding tokens' player-visible details while they are under a hex. + // + // Hexes hide the token image, but Roll20 draws nameplates, bars and auras + // above the foreground layer, so a monster under a hex would still give its + // position away. While a token's centre is under a covered (not glimpsed) hex, + // its player-visible flags are switched off; the saved values are restored + // when it is uncovered, moved out, or the setting is turned off. + + /** + * Returns true when a token's centre is under a covered hex. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @returns {boolean} True when covered. + */ + function isCovered(ctx, token) { + if (token.get('layer') !== LAYER_TOKEN || token.get('_subtype') !== 'token') { + return false; + } + const [row, col] = pixelToHex(ctx.grid, Number(token.get('left')), Number(token.get('top'))); + const hex = getHex(ctx.pageId, hexKey(row, col)); + return !!hex && !hex.glimpsed; + } + + /** + * Switches a token's player-visible details off, saving their values. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function hideDetails(token) { + const covered = getCoveredTokens(); + const id = token.get('_id'); + if (covered[id]) { + return; + } + const saved = {}; + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + saved[prop] = token.get(prop) === true; + updates[prop] = false; + } + covered[id] = { pageId: token.get('_pageid'), saved }; + token.set(updates); + } + + /** + * Restores a token's saved player-visible details. + * + * @param {string} tokenId Token ID. + * @returns {void} + */ + function restoreDetails(tokenId) { + const covered = getCoveredTokens(); + const entry = covered[tokenId]; + if (!entry) { + return; + } + delete covered[tokenId]; + const token = getObj('graphic', tokenId); + if (token) { + token.set({ ...entry.saved }); + } + } + + /** + * Keeps a covered token's details hidden when the GM switches one on while it + * is covered: the new value is saved for when the token is uncovered. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleCoveredChange(token, prev) { + const entry = getCoveredTokens()[token.get('_id')]; + if (!entry || !prev) { + return; + } + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + if (token.get(prop) === true && prev[prop] !== true) { + entry.saved[prop] = true; + updates[prop] = false; + } + } + if (Object.keys(updates).length > 0) { + token.set(updates); + } + } + + /** + * Hides or restores one token's details to match whether it is covered. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function refreshToken(token) { + const ctx = getPageContext(token.get('_pageid')); + if (getConfig().hideCoveredTokens && ctx.ok && isCovered(ctx, token)) { + hideDetails(token); + } else { + restoreDetails(token.get('_id')); + } + } + + /** + * Hides or restores the details of every token on a page. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function refreshPage(pageId) { + const ctx = getPageContext(pageId); + const enabled = getConfig().hideCoveredTokens && ctx.ok; + const covered = getCoveredTokens(); + for (const token of findObjs({ _type: 'graphic', _pageid: pageId, _subtype: 'token' })) { + if (enabled && isCovered(ctx, token)) { + hideDetails(token); + } else if (covered[token.get('_id')]) { + restoreDetails(token.get('_id')); + } + } + // Forget tokens that were deleted while hidden. + for (const [tokenId, entry] of Object.entries(covered)) { + if (entry.pageId === pageId && !getObj('graphic', tokenId)) { + delete covered[tokenId]; + } + } + } + + /** + * Restores every hidden token in the game (used when the setting is turned off). + * + * @returns {void} + */ + function restoreAll() { + for (const tokenId of Object.keys(getCoveredTokens())) { + restoreDetails(tokenId); + } + } + + // Named hexes and hidden location tokens. + // + // A hex can carry a name (shown to the GM as a label on the GM layer) and an + // icon (a token hidden on the GM layer). Both are announced when the hex is + // revealed, and the icon is moved back to the token layer. + + /** + * Returns the token attached to a hex as its icon, if it still exists. + * + * @param {object} hex Hex record. + * @returns {object|null} Roll20 graphic. + */ + function getHexIcon(hex) { + return hex.iconId ? getObj('graphic', hex.iconId) || null : null; + } + + /** + * Returns the name announced when a hex is discovered: the icon's name, or + * the hex's own name. + * + * @param {object} hex Hex record. + * @returns {string} Discovery name (empty when the hex is unnamed). + */ + function getDiscoveryName(hex) { + const icon = getHexIcon(hex); + return toText(icon?.get('name')) || toText(hex.name); + } + + /** + * Removes a hex's GM-layer name label. + * + * @param {object} hex Hex record. + * @returns {void} + */ + function removeLabel(hex) { + if (hex.nameId) { + getObj('text', hex.nameId)?.remove(); + delete hex.nameId; + } + } + + /** + * Sets or clears a hex's name and redraws its GM-layer label. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record. + * @param {string} name New name (empty to clear). + * @returns {void} + */ + function setHexName(ctx, hex, name) { + removeLabel(hex); + const clean = toText(name).slice(0, MAX_NAME_LENGTH); + if (!clean) { + delete hex.name; + return; + } + hex.name = clean; + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + const label = createObj('text', { + _pageid: ctx.pageId, + layer: LAYER_GM, + left: x, + top: y, + text: clean, + color: getConfig().labelColor, + }); + if (label) { + hex.nameId = label.get('_id'); + } + } + + /** + * Attaches a token to a hex as its hidden icon. + * + * @param {object} hex Hex record. + * @param {object} token Roll20 graphic. + * @returns {string} The token's layer before it was hidden (for undo). + */ + function attachIcon(hex, token) { + const previousLayer = token.get('layer'); + hex.iconId = token.get('_id'); + token.set('layer', LAYER_GM); + setPendingLocation(hex.iconId, null); + return previousLayer; + } + + /** + * Detaches a hex's icon and returns it to the token layer. + * + * @param {object} hex Hex record. + * @param {boolean} [show=true] Move the icon back to the token layer. + * @returns {void} + */ + function detachIcon(hex, show = true) { + const icon = getHexIcon(hex); + if (icon && show) { + icon.set('layer', LAYER_TOKEN); + } + delete hex.iconId; + } + + /** + * Returns the hex records on a page keyed by the ID of their icon. + * + * @param {string} pageId Page ID. + * @returns {Map} Map of icon ID to hex record. + */ + function hexesByIcon(pageId) { + const map = new Map(); + for (const hex of getPageHexes(pageId)) { + if (hex.iconId) { + map.set(hex.iconId, hex); + } + } + return map; + } + + /** + * Returns location tokens waiting for a hex on a page, keyed by hex cell: + * tokens marked with `mark`, plus (as in v1) tokens with the white-tower + * status marker. Tokens already attached to a hex are ignored. + * + * @param {object} ctx Page context. + * @returns {Map} Map of "row,col" to Roll20 graphic. + */ + function findLocationTokens(ctx) { + const attached = hexesByIcon(ctx.pageId); + const tokens = new Map(); + const consider = (token) => { + if (!token || attached.has(token.get('_id'))) { + return; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + tokens.set(hexKey(row, col), token); + }; + + for (const tokenId of getPendingLocations(ctx.pageId)) { + const token = getObj('graphic', tokenId); + if (token) { + consider(token); + } else { + setPendingLocation(tokenId, null); + } + } + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId })) { + if (tokenHasMarker(token, LOCATION_MARKER)) { + consider(token); + } + } + return tokens; + } + + /** + * Marks tokens as hidden locations. A token already under a hex is attached + * immediately; otherwise it waits for the next fill that covers it. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {{attached: number, pending: number}} Counts. + */ + function markLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + let attachedCount = 0; + let pendingCount = 0; + for (const token of tokens) { + if (attached.has(token.get('_id'))) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + attachIcon(hex, token); + attachedCount++; + } else { + setPendingLocation(token.get('_id'), ctx.pageId); + pendingCount++; + } + } + return { attached: attachedCount, pending: pendingCount }; + } + + /** + * Stops tokens being hidden locations. Attached tokens return to the token layer. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number} Number of tokens unmarked. + */ + function unmarkLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + const pending = new Set(getPendingLocations(ctx.pageId)); + let count = 0; + for (const token of tokens) { + const id = token.get('_id'); + const hex = attached.get(id); + if (hex) { + detachIcon(hex); + count++; + } else if (pending.has(id)) { + setPendingLocation(id, null); + count++; + } + } + return count; + } + + // Polygon maths for Roll20 drawn shapes. Pure functions only: callers pass + // plain property objects, so the module can be unit tested in Node. + // + // Both kinds of Roll20 path store points relative to their own bounding box + // and are placed by their centre: + // - Legacy `path`: `_path` is a JSON list of SVG-like commands (M, L, Q, C), + // placed by left/top, sized by width/height, scaled by scaleX/scaleY. + // - Jumpgate `pathv2`: `points` is a JSON list of [x, y] pairs interpreted by + // `shape` (pol, free, rec, eli) and placed by x/y. It has no scale. + // Both can be rotated by `rotation` degrees about their centre. + + const UNIT_PX = 70; + const ELLIPSE_SEGMENTS = 32; + const CURVE_SEGMENTS = 8; + + /** + * Returns the bounding box of a list of points. + * + * @param {number[][]} points Array of [x, y]. + * @returns {{left: number, top: number, right: number, bottom: number}} Bounding box. + */ + function boundingBox(points) { + let left = Infinity; + let top = Infinity; + let right = -Infinity; + let bottom = -Infinity; + for (const [x, y] of points) { + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x); + bottom = Math.max(bottom, y); + } + return { left, top, right, bottom }; + } + + /** + * Tests whether a point lies inside a polygon ring (even-odd rule). The ring + * is treated as closed whether or not its last point repeats the first. + * + * @param {number[]} point [x, y]. + * @param {number[][]} ring Array of [x, y]. + * @returns {boolean} True when inside. + */ + function pointInRing(point, ring) { + const [x, y] = point; + let inside = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const [xi, yi] = ring[i]; + const [xj, yj] = ring[j]; + const crosses = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi; + if (crosses) { + inside = !inside; + } + } + return inside; + } + + /** + * Tests whether a point lies inside any of a shape's rings (even-odd across + * rings, so a ring drawn inside another makes a hole). + * + * @param {number[]} point [x, y]. + * @param {number[][][]} rings Array of rings. + * @returns {boolean} True when inside. + */ + function pointInShape(point, rings) { + let inside = false; + for (const ring of rings) { + if (ring.length >= 3 && pointInRing(point, ring)) { + inside = !inside; + } + } + return inside; + } + + /** + * Builds a transform from path-local coordinates to page pixels. + * + * @param {object} t Transform values. + * @returns {(x: number, y: number) => number[]} Point transform. + */ + function makeTransform({ width, height, cx, cy, scaleX = 1, scaleY = 1, rotation = 0 }) { + const angle = ((Number(rotation) || 0) * Math.PI) / 180; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + return (x, y) => { + const lx = (x - width / 2) * scaleX; + const ly = (y - height / 2) * scaleY; + return [cx + lx * cos - ly * sin, cy + lx * sin + ly * cos]; + }; + } + + /** + * Samples a quadratic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 Control point. + * @param {number[]} p2 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleQuadratic(p0, p1, p2) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + points.push([ + u * u * p0[0] + 2 * u * t * p1[0] + t * t * p2[0], + u * u * p0[1] + 2 * u * t * p1[1] + t * t * p2[1], + ]); + } + return points; + } + + /** + * Samples a cubic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 First control point. + * @param {number[]} p2 Second control point. + * @param {number[]} p3 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleCubic(p0, p1, p2, p3) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + const a = u * u * u; + const b = 3 * u * u * t; + const c = 3 * u * t * t; + const d = t * t * t; + points.push([ + a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], + a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1], + ]); + } + return points; + } + + /** + * Converts a Legacy path's command list into rings in path-local coordinates. + * + * @param {Array[]} commands Parsed `_path` commands. + * @returns {number[][][]} Rings. + */ + function legacyCommandsToRings(commands) { + const rings = []; + let ring = []; + let prevType = null; + for (const cmd of commands) { + if (!Array.isArray(cmd)) { + continue; + } + const [type, ...args] = cmd; + const nums = args.map(Number); + const prev = ring.at(-1); + if (type === 'M' && prevType !== 'M') { + if (ring.length > 0) { + rings.push(ring); + } + ring = [[nums[0], nums[1]]]; + } else if (type === 'L' || type === 'M') { + // Two consecutive Ms are drawn by Roll20 as a line, so treat the second as L. + ring.push([nums[0], nums[1]]); + } else if (type === 'Q' && prev) { + ring.push(...sampleQuadratic(prev, [nums[0], nums[1]], [nums[2], nums[3]])); + } else if (type === 'C' && prev) { + ring.push(...sampleCubic(prev, [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]])); + } + prevType = type; + } + if (ring.length > 0) { + rings.push(ring); + } + return rings; + } + + /** + * Returns points approximating an ellipse inside a box. + * + * @param {number} width Box width. + * @param {number} height Box height. + * @returns {number[][]} Points in box-local coordinates. + */ + function ellipsePoints(width, height) { + const points = []; + for (let i = 0; i < ELLIPSE_SEGMENTS; i++) { + const angle = (i / ELLIPSE_SEGMENTS) * Math.PI * 2; + points.push([ + width / 2 + (Math.cos(angle) * width) / 2, + height / 2 + (Math.sin(angle) * height) / 2, + ]); + } + return points; + } + + /** + * Parses a JSON string, returning null on failure. + * + * @param {string} text JSON text. + * @returns {*} Parsed value, or null. + */ + function safeJson(text) { + try { + return JSON.parse(text); + } catch { + return null; + } + } + + /** + * Converts a Legacy path's properties into page-space rings. + * + * @param {object} props Path properties (_path, left, top, width, height, scaleX, scaleY, rotation). + * @param {object} [page] Page size in units ({ width, height }) for mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function legacyPathToRings(props, page = {}) { + const raw = String(props._path || props.path || '') + .replaceAll('mapWidth', String((Number(page.width) || 0) * UNIT_PX)) + .replaceAll('mapHeight', String((Number(page.height) || 0) * UNIT_PX)); + const commands = safeJson(raw); + if (!Array.isArray(commands)) { + return []; + } + const transform = makeTransform({ + width: Number(props.width) || 0, + height: Number(props.height) || 0, + cx: Number(props.left) || 0, + cy: Number(props.top) || 0, + scaleX: Number(props.scaleX) || 1, + scaleY: Number(props.scaleY) || 1, + rotation: props.rotation, + }); + return legacyCommandsToRings(commands).map((ring) => ring.map(([x, y]) => transform(x, y))); + } + + /** + * Converts a Jumpgate pathv2's properties into page-space rings. + * + * @param {object} props Path properties (points, shape, x, y, rotation). + * @returns {number[][][]} Rings in page pixels. + */ + function pathV2ToRings(props) { + const parsed = safeJson(props.points); + if (!Array.isArray(parsed) || parsed.length === 0) { + return []; + } + const raw = parsed + .filter((p) => Array.isArray(p) && p.length >= 2) + .map(([x, y]) => [Number(x), Number(y)]) + .filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)); + if (raw.length === 0) { + return []; + } + + // Points are normalised so the bounding box starts at 0,0. + const box = boundingBox(raw); + const local = raw.map(([x, y]) => [x - box.left, y - box.top]); + const width = box.right - box.left; + const height = box.bottom - box.top; + + let ring; + if (props.shape === 'rec') { + ring = [ + [0, 0], + [width, 0], + [width, height], + [0, height], + ]; + } else if (props.shape === 'eli') { + ring = ellipsePoints(width, height); + } else { + ring = local; + } + + const transform = makeTransform({ + width, + height, + cx: Number(props.x) || 0, + cy: Number(props.y) || 0, + rotation: props.rotation, + }); + return [ring.map(([x, y]) => transform(x, y))]; + } + + /** + * Converts either kind of path into page-space rings. + * + * @param {object} props Path properties including `type` ('path' or 'pathv2'). + * @param {object} [page] Page size in units, for Legacy mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function pathToRings(props, page) { + if (props.type === 'pathv2') { + return pathV2ToRings(props); + } + return legacyPathToRings(props, page); + } + + /** + * Builds the properties for a closed polygon as either kind of path. + * Points are made relative to their bounding box, and the path is placed by + * its centre, matching how Roll20 stores both path types. + * + * @param {number[][]} points Polygon corners in page pixels. + * @param {boolean} jumpgate True to build a pathv2, false for a Legacy path. + * @returns {object} Geometry properties for createObj. + */ + function polygonPathProps(points, jumpgate) { + const box = boundingBox(points); + const width = box.right - box.left; + const height = box.bottom - box.top; + const cx = box.left + width / 2; + const cy = box.top + height / 2; + const round = (n) => Math.round(n * 1000) / 1000; + const local = points.map(([x, y]) => [round(x - box.left), round(y - box.top)]); + const closed = [...local, local[0]]; + + if (jumpgate) { + return { + shape: 'pol', + points: JSON.stringify(closed), + x: cx, + y: cy, + }; + } + + const commands = closed.map(([x, y], i) => [i === 0 ? 'M' : 'L', x, y]); + return { + _path: JSON.stringify(commands), + left: cx, + top: cy, + width, + height, + }; + } + + /** + * Returns the centroid of a ring's distinct vertices. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[]} [x, y]. + */ + function ringCentre(ring) { + const pts = distinctVertices(ring); + const sum = pts.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [0, 0]); + return [sum[0] / pts.length, sum[1] / pts.length]; + } + + /** + * Returns a ring's vertices with a repeated closing point removed. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[][]} Distinct vertices. + */ + function distinctVertices(ring) { + if (ring.length > 1) { + const first = ring[0]; + const last = ring.at(-1); + if (Math.abs(first[0] - last[0]) < 0.01 && Math.abs(first[1] - last[1]) < 0.01) { + return ring.slice(0, -1); + } + } + return ring; + } + + // Roll20 object access for drawn shapes. Jumpgate games draw `pathv2` + // objects; Legacy games draw `path` objects. Everything that reads or writes a + // path goes through this module so the rest of the mod never cares which. + + // Set when the foreground layer turns out to be unavailable, so later hexes + // go straight to the token layer instead of failing one by one. + let foregroundUnavailable = false; + + /** + * Returns a path object of either type by ID. + * + * @param {string} id Object ID. + * @param {string|null} [type] Known type, checked first. + * @returns {object|null} Roll20 path or pathv2 object. + */ + function getPathObject(id, type = null) { + if (!id) { + return null; + } + const types = activePathTypes(); + const order = type && types.includes(type) ? [type, ...types.filter((t) => t !== type)] : types; + for (const t of order) { + const obj = getObj(t, id); + if (obj) { + return obj; + } + } + return null; + } + + /** + * Returns true when a Roll20 object is a path of either type. + * + * @param {object} obj Roll20 object. + * @returns {boolean} True for path and pathv2. + */ + function isPathObject(obj) { + return !!obj && PATH_TYPES.includes(obj.get('_type')); + } + + /** + * Copies the properties the polygon module needs from a path. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {object} Plain properties including `type`. + */ + function readPathProps(obj) { + const type = obj.get('_type'); + const base = { + type, + pageId: obj.get('_pageid'), + layer: obj.get('layer'), + rotation: obj.get('rotation'), + fill: obj.get('fill'), + stroke: obj.get('stroke'), + stroke_width: obj.get('stroke_width'), + }; + if (type === PATH_TYPE_V2) { + return { + ...base, + shape: obj.get('shape'), + points: obj.get('points'), + x: obj.get('x'), + y: obj.get('y'), + }; + } + return { + ...base, + _path: obj.get('_path'), + left: obj.get('left'), + top: obj.get('top'), + width: obj.get('width'), + height: obj.get('height'), + scaleX: obj.get('scaleX'), + scaleY: obj.get('scaleY'), + }; + } + + /** + * Returns a path's outline as page-space rings. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {number[][][]} Rings. + */ + function getPathRings(obj) { + const props = readPathProps(obj); + const page = getObj('page', props.pageId); + return pathToRings(props, page ? { width: page.get('width'), height: page.get('height') } : {}); + } + + /** + * Recreates a path from properties saved by readPathProps (used by undo). + * + * @param {object} props Saved properties. + * @returns {object|null} New Roll20 object. + */ + function recreatePath(props) { + const { type, pageId, ...rest } = props; + const attrs = { _pageid: pageId }; + for (const [key, value] of Object.entries(rest)) { + if (value !== undefined && value !== null) { + attrs[key] = value; + } + } + // A Legacy game cannot create pathv2 objects, and vice versa. + const createType = type === PATH_TYPE_V2 && !isJumpgate() ? PATH_TYPE_LEGACY : type; + return createObj(createType, attrs) || null; + } + + /** + * Returns the layer new hexes should be drawn on. + * + * @returns {string} Roll20 layer. + */ + function getHexLayer() { + const setting = getConfig().hexLayer; + if (setting === 'objects' || foregroundUnavailable) { + return LAYER_TOKEN; + } + return LAYER_FOREGROUND; + } + + /** + * Draws a hex outline as a path. + * + * The foreground layer is tried first (unless the GM chose the token layer); + * if the game rejects it, the hex is drawn on the token layer instead and the + * fallback is remembered for the rest of the session. + * + * @param {string} pageId Page ID. + * @param {number[][]} corners Hex corners in page pixels. + * @param {object} style Style with fill, stroke and strokeWidth. + * @returns {{obj: object, fellBack: boolean}|null} New path, or null when it could not be created. + */ + function createHexPath(pageId, corners, style) { + const jumpgate = isJumpgate(); + const type = jumpgate ? PATH_TYPE_V2 : PATH_TYPE_LEGACY; + const geometry = polygonPathProps(corners, jumpgate); + const attrs = { + ...geometry, + _pageid: pageId, + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + controlledby: '', + }; + + const layer = getHexLayer(); + let obj = createObj(type, { ...attrs, layer }); + if (obj && obj.get('layer') === layer) { + return { obj, fellBack: false }; + } + + if (layer === LAYER_FOREGROUND) { + if (obj) { + obj.remove(); + } + foregroundUnavailable = true; + obj = createObj(type, { ...attrs, layer: LAYER_TOKEN }); + return obj ? { obj, fellBack: true } : null; + } + return obj ? { obj, fellBack: false } : null; + } + + /** + * Removes a Roll20 object if it still exists. + * + * @param {object|null} obj Roll20 object. + * @returns {void} + */ + function safeRemove(obj) { + if (obj) { + try { + obj.remove(); + } catch (err) { + log(`Hexploration: could not remove object: ${err?.message || err}`); + } + } + } + + /** + * Returns every path of either type on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Roll20 path objects. + */ + function getPagePaths(pageId) { + return activePathTypes().flatMap((type) => findObjs({ _type: type, _pageid: pageId })); + } + + /** + * Returns the path types that can exist in this game. Jumpgate games can + * hold both (old API-made paths survive); Legacy games only have `path`. + * + * @returns {string[]} Path types. + */ + function activePathTypes() { + return isJumpgate() ? PATH_TYPES : [PATH_TYPE_LEGACY]; + } + + // Creating, removing and maintaining hexes on a page: fill, inverse fill, + // conceal, reset, rescan, calibrate and undo. + + /** + * Returns the hex style from the current config. + * + * @returns {{fill: string, stroke: string, strokeWidth: number, maxDistance: number|null}} Style. + */ + function currentStyle() { + const config = getConfig(); + return { + fill: config.fillColor, + stroke: config.strokeColor, + strokeWidth: config.strokeWidth, + maxDistance: config.maxDistance, + }; + } + + /** + * Draws one hex and stores its record. + * + * @param {object} ctx Page context. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {object} style Hex style. + * @param {object} [extra] Extra record fields (name, iconId…). + * @returns {{hex: object, fellBack: boolean}|null} New record, or null on failure. + */ + function drawHex(ctx, row, col, style, extra = {}) { + const created = createHexPath(ctx.pageId, hexCorners(ctx.grid, row, col), style); + if (!created) { + return null; + } + const hex = { id: created.obj.get('_id'), type: created.obj.get('_type'), row, col, ...extra }; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } + putHex(ctx.pageId, hex); + return { hex, fellBack: created.fellBack }; + } + + /** + * Removes a hex: its record, its path and its name label. Its icon is moved + * back to the token layer when `showIcon` is true, otherwise left hidden. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @param {boolean} [showIcon=false] Return the icon to the token layer. + * @returns {object|null} The removed record. + */ + function removeHex(pageId, key, showIcon = false) { + const hex = deleteHexRecord(pageId, key); + if (!hex) { + return null; + } + removeLabel(hex); + if (showIcon) { + detachIcon(hex); + } + safeRemove(getPathObject(hex.id, hex.type)); + return hex; + } + + /** + * Returns the cells whose centres lie inside any of the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects on the page. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function cellsInPaths(ctx, paths) { + const seen = new Set(); + const cells = []; + for (const path of paths) { + const rings = getPathRings(path); + if (rings.length === 0) { + continue; + } + const box = boundingBox(rings.flat()); + for (const [row, col] of hexesInBox(ctx.grid, box)) { + const key = hexKey(row, col); + if (!seen.has(key) && pointInShape(hexToPixel(ctx.grid, row, col), rings)) { + seen.add(key); + cells.push([row, col]); + } + } + } + return cells; + } + + /** + * Returns every cell on the page except those inside the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects to leave uncovered. + * @returns {number[][]} Array of [row, col]. + */ + function cellsOutsidePaths(ctx, paths) { + const omit = new Set(cellsInPaths(ctx, paths).map(([r, c]) => hexKey(r, c))); + const width = Number(ctx.page.get('width')) * 70; + const height = Number(ctx.page.get('height')) * 70; + return hexesCoveringPage(ctx.grid, width, height).filter(([r, c]) => !omit.has(hexKey(r, c))); + } + + /** + * Covers cells with hexes. Existing hexes are restyled rather than replaced, + * so their names and icons are kept. Location tokens in a covered cell are + * attached as icons. Work is batched; `onDone` receives a summary. + * + * @param {object} ctx Page context. + * @param {number[][]} cells Cells to cover. + * @param {object} options Fill options. + * @param {object[]} [options.sources] Saved properties of the polygons used (for undo). + * @param {string} options.kind Fill kind for undo ('fill', 'fillInverse', 'conceal'). + * @param {(summary: object) => void} options.onDone Completion callback. + * @returns {{started: boolean, reason?: string}} Whether the fill started. + */ + function fillCells(ctx, cells, { sources = [], kind, onDone }) { + if (cells.length > MAX_FILL_HEXES) { + return { started: false, reason: 'tooMany' }; + } + + const style = currentStyle(); + const locations = findLocationTokens(ctx); + const record = { + pageId: ctx.pageId, + kind, + time: Date.now(), + created: [], + restyled: [], + icons: [], + sources, + }; + const summary = { created: 0, restyled: 0, icons: 0, failed: 0, fellBack: false }; + + runInBatches( + cells, + BATCH_SIZE, + ([row, col]) => { + const key = hexKey(row, col); + let hex = getHex(ctx.pageId, key); + const existingPath = hex ? getPathObject(hex.id, hex.type) : null; + + if (hex && existingPath) { + record.restyled.push({ + key, + fill: existingPath.get('fill'), + stroke: existingPath.get('stroke'), + strokeWidth: existingPath.get('stroke_width'), + maxDistance: hex.maxDistance ?? null, + glimpsed: hex.glimpsed === true, + }); + existingPath.set({ + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + }); + delete hex.glimpsed; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } else { + delete hex.maxDistance; + } + summary.restyled++; + } else { + if (hex) { + // The record outlived its path (deleted while the API was off). + deleteHexRecord(ctx.pageId, key); + } + const drawn = drawHex(ctx, row, col, style); + if (!drawn) { + summary.failed++; + return; + } + hex = drawn.hex; + summary.fellBack = summary.fellBack || drawn.fellBack; + record.created.push({ key, id: hex.id }); + summary.created++; + } + + const token = locations.get(key); + if (token && !hex.iconId) { + record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + attachIcon(hex, token); + summary.icons++; + } + }, + (errors) => { + summary.failed += errors; + setLastFill(record); + onDone(summary); + } + ); + + return { started: true }; + } + + /** + * Removes every hex on a page, returning icons to the token layer. Page + * settings and calibration are kept. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function clearPage(ctx, onDone) { + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + for (const tokenId of getPendingLocations(ctx.pageId)) { + setPendingLocation(tokenId, null); + } + const last = getLastFill(); + if (last?.pageId === ctx.pageId) { + setLastFill(null); + } + runInBatches( + keys, + BATCH_SIZE, + (key) => removeHex(ctx.pageId, key, true), + () => onDone(keys.length) + ); + } + + /** + * Reverses the last fill: removes the hexes it created, restores the style + * of hexes it restyled, returns icons it hid, and redraws the polygons it used. + * + * @returns {{ok: boolean, reason?: string, removed?: number, restored?: number, pageId?: string}} Result. + */ + function undoLastFill() { + const record = getLastFill(); + if (!record) { + return { ok: false, reason: 'nothingToUndo' }; + } + setLastFill(null); + const page = getObj('page', record.pageId); + if (!page) { + return { ok: false, reason: 'noPage' }; + } + + let removed = 0; + for (const { key, id } of record.created || []) { + const hex = getHex(record.pageId, key); + if (hex && hex.id === id) { + removeHex(record.pageId, key, false); + removed++; + } + } + + let restored = 0; + for (const prev of record.restyled || []) { + const hex = getHex(record.pageId, prev.key); + const path = hex ? getPathObject(hex.id, hex.type) : null; + if (path) { + path.set({ fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); + if (Number.isInteger(prev.maxDistance)) { + hex.maxDistance = prev.maxDistance; + } else { + delete hex.maxDistance; + } + if (prev.glimpsed) { + hex.glimpsed = true; + } + restored++; + } + } + + for (const { id, layer } of record.icons || []) { + const token = getObj('graphic', id); + if (token) { + for (const hex of getPageHexes(record.pageId)) { + if (hex.iconId === id) { + delete hex.iconId; + } + } + token.set('layer', layer || LAYER_TOKEN); + } + } + + for (const props of record.sources || []) { + recreatePath(props); + } + + return { ok: true, removed, restored, pageId: record.pageId }; + } + + /** + * Captures the polygons used for a fill so undo can redraw them, then deletes them. + * + * @param {object[]} paths Roll20 path objects. + * @returns {object[]} Saved properties. + */ + function consumeSourcePaths(paths) { + // A selected path may itself be a hex; only plain drawings are consumed. + const drawings = paths.filter((path) => !getHexByPathId(path.get('_id'))); + const sources = drawings.map(readPathProps); + for (const path of drawings) { + safeRemove(path); + } + return sources; + } + + /** + * Returns the hex a path draws, judged by its shape: a six-cornered polygon + * centred on a hex cell and roughly the size of a hex. + * + * @param {object} ctx Page context. + * @param {object} path Roll20 path object. + * @returns {number[]|null} [row, col], or null when the path is not a hex. + */ + function matchHexShape(ctx, path) { + const rings = getPathRings(path); + if (rings.length !== 1) { + return null; + } + const vertices = distinctVertices(rings[0]); + if (vertices.length !== 6) { + return null; + } + const [x, y] = ringCentre(vertices); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + if (Math.hypot(x - cx, y - cy) > ctx.grid.colStep * RESCAN_CENTRE_TOLERANCE) { + return null; + } + const actual = boundingBox(vertices); + const expected = boundingBox(hexCorners(ctx.grid, row, col)); + const ratioW = (actual.right - actual.left) / (expected.right - expected.left); + const ratioH = (actual.bottom - actual.top) / (expected.bottom - expected.top); + if (ratioW < 0.75 || ratioW > 1.25 || ratioH < 0.75 || ratioH > 1.25) { + return null; + } + return [row, col]; + } + + /** + * Rebuilds a page's hex list from what is actually on the page: + * - drops records whose path is gone, and label/icon links that are broken; + * - re-files hexes whose cell changed (after calibration); + * - adopts hex-shaped paths the mod does not know about (duplicated pages, + * Legacy games copied to Jumpgate); + * - re-links GM-layer labels and white-tower icons sitting on hexes. + * + * @param {object} ctx Page context. + * @returns {{kept: number, dropped: number, moved: number, adopted: number, labels: number, icons: number}} Counts. + */ + function rescanPage(ctx) { + const counts = { kept: 0, dropped: 0, moved: 0, adopted: 0, labels: 0, icons: 0 }; + const pageData = getPageData(ctx.pageId, true); + + // 1. Check existing records. + for (const hex of Object.values(pageData.hexes)) { + const key = hexKey(hex.row, hex.col); + const path = getPathObject(hex.id, hex.type); + if (!path) { + removeLabel(hex); + deleteHexRecord(ctx.pageId, key); + counts.dropped++; + continue; + } + hex.type = path.get('_type'); + if (hex.nameId && !getObj('text', hex.nameId)) { + delete hex.nameId; + } + if (hex.iconId && !getHexIcon(hex)) { + delete hex.iconId; + } + const cell = matchHexShape(ctx, path); + if ( + cell && + hexKey(cell[0], cell[1]) !== key && + !getHex(ctx.pageId, hexKey(cell[0], cell[1])) + ) { + deleteHexRecord(ctx.pageId, key); + putHex(ctx.pageId, { ...hex, row: cell[0], col: cell[1] }); + counts.moved++; + } else { + counts.kept++; + } + } + + // 2. Adopt unknown hex-shaped paths. + for (const path of getPagePaths(ctx.pageId)) { + const id = path.get('_id'); + if (getHexByPathId(id)) { + continue; + } + const cell = matchHexShape(ctx, path); + if (!cell || getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + continue; + } + putHex(ctx.pageId, { id, type: path.get('_type'), row: cell[0], col: cell[1] }); + counts.adopted++; + } + + // 3. Re-link GM-layer labels sitting on hex centres. + const linkedLabels = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.nameId) + .filter(Boolean) + ); + for (const text of findObjs({ _type: 'text', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedLabels.has(text.get('_id'))) { + continue; + } + const x = Number(text.get('left')); + const y = Number(text.get('top')); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + hex.nameId = text.get('_id'); + hex.name = String(text.get('text') || '').trim() || hex.name; + counts.labels++; + } + } + + // 4. Re-link hidden white-tower icons. + const linkedIcons = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.iconId) + .filter(Boolean) + ); + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedIcons.has(token.get('_id')) || !tokenHasMarker(token, LOCATION_MARKER)) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + hex.iconId = token.get('_id'); + counts.icons++; + } + } + + return counts; + } + + /** + * Calibrates a page's grid from tokens snapped to hex centres, then rescans + * so existing hexes are filed under their corrected cells. + * + * @param {object} ctx Page context. + * @param {object[]} tokens One or two Roll20 graphics. + * @returns {{ok: boolean, calibration?: object, counts?: object}} Result. + */ + function calibratePage(ctx, tokens) { + const points = tokens.slice(0, 2).map((t) => [Number(t.get('left')), Number(t.get('top'))]); + // Calibrate against the uncalibrated profile so repeated calibration does not drift. + setCalibration(ctx.pageId, null); + const base = buildPageGrid(ctx.page); + const calibration = calibrateGrid(base, points); + if (!calibration) { + return { ok: false }; + } + setCalibration(ctx.pageId, calibration); + const fresh = { ...ctx, grid: buildPageGrid(ctx.page) }; + return { ok: true, calibration, counts: rescanPage(fresh) }; + } + + /** + * Clears a page's calibration and rescans. + * + * @param {object} ctx Page context. + * @returns {object} Rescan counts. + */ + function resetCalibration(ctx) { + setCalibration(ctx.pageId, null); + return rescanPage({ ...ctx, grid: buildPageGrid(ctx.page) }); + } + + /** + * Removes stored hexes whose paths no longer exist, on every page. Run on + * startup, since paths deleted while the API was off fire no events. + * + * @returns {{dropped: number, pages: number}} Counts. + */ + function pruneMissingHexes() { + let dropped = 0; + let pages = 0; + for (const pageId of getPageIds()) { + if (!getObj('page', pageId)) { + dropped += getPageHexes(pageId).length; + deletePageData(pageId); + pages++; + continue; + } + for (const hex of getPageHexes(pageId)) { + if (!getPathObject(hex.id, hex.type)) { + deleteHexRecord(pageId, hexKey(hex.row, hex.col)); + dropped++; + } + } + } + return { dropped, pages }; + } + + // Journal handouts: the Help handout and the Command Deck. + + const STYLE = { + outer: `background:${COLOR_CARD_BG_BOTTOM};color:${COLOR_TEXT};padding:14px 18px;border:1px solid ${COLOR_BORDER};border-radius:6px;font-family:Arial,sans-serif;line-height:1.5;`, + header: `background:${COLOR_HEADER_BG};padding:12px;border-radius:4px;text-align:center;border-bottom:3px solid ${COLOR_ACCENT};margin-bottom:12px;`, + h1: `color:${COLOR_HEADER_TEXT};margin:0;font-size:1.8em;letter-spacing:0.05em;`, + subtitle: `color:${COLOR_MUTED};margin:4px 0 0 0;font-size:0.9em;`, + h2: `color:${COLOR_ACCENT};border-bottom:1px solid ${COLOR_BORDER};padding-bottom:3px;margin:18px 0 8px 0;font-size:1.25em;`, + p: `color:${COLOR_TEXT};margin:6px 0;`, + li: `color:${COLOR_TEXT};margin:3px 0;`, + table: 'width:100%;border-collapse:collapse;margin:6px 0;font-size:0.92em;', + th: `background:${COLOR_HEADER_BG};color:${COLOR_HEADER_TEXT};padding:5px 8px;text-align:left;border:1px solid ${COLOR_BORDER};`, + td: `padding:5px 8px;border:1px solid ${COLOR_BORDER};vertical-align:top;color:${COLOR_TEXT};`, + code: 'font-family:monospace;color:#f3d48b;white-space:nowrap;', + link: `color:${COLOR_ACCENT};`, + footer: `color:${COLOR_MUTED};font-size:0.85em;text-align:center;margin-top:16px;border-top:1px solid ${COLOR_BORDER};padding-top:8px;`, + btn: `background:${COLOR_BUTTON_BG};color:${COLOR_BUTTON_TEXT};padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;font-weight:bold;`, + btnDark: `background:#2c4034;color:${COLOR_TEXT};border:1px solid #4d6b56;padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;`, + section: `background:${COLOR_HEADER_BG};color:${COLOR_ACCENT};padding:4px 8px;font-variant:small-caps;font-weight:bold;letter-spacing:0.05em;border-left:3px solid ${COLOR_ACCENT};margin:12px 0 4px 0;`, + desc: `color:${COLOR_MUTED};font-size:0.85em;margin:0 0 4px 8px;`, + }; + + /** + * Builds a table. + * + * @param {string[]} headings Column headings (escaped). + * @param {string[][]} rows Row cells (trusted HTML). + * @returns {string} HTML string. + */ + function table(headings, rows) { + const head = headings.map((h) => `${escapeHtml(h)}`).join(''); + const body = rows + .map((cells) => `${cells.map((c) => `${c}`).join('')}`) + .join(''); + return `${head}${body}
    `; + } + + /** + * Builds a paragraph list from a translated array. + * + * @param {*} items Translated value (array of strings expected). + * @param {boolean} [ordered=false] Use a numbered list. + * @returns {string} HTML string. + */ + function list(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const lis = (Array.isArray(items) ? items : []) + .map((item) => `
  • ${escapeHtml(item)}
    • `) + .join(''); + return `<${tag}>${lis}`; + } + + /** + * Builds a link. + * + * @param {string} url URL. + * @param {string} label Link text. + * @returns {string} HTML anchor. + */ + function link(url, label) { + return `${escapeHtml(label)}`; + } + + /** + * Builds the Help handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildHelpHtml(locale) { + const lang = getLocale(locale); + const h = (key, vars) => escapeHtml(t(`handout.${key}`, lang, vars)); + const raw = (key) => tRaw(`handout.${key}`, lang); + const code = (text) => `${escapeHtml(text)}`; + const section = (key, body) => `

    ${h(`${key}.heading`)}

    ${body}`; + + const commands = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ].map(([cmd, key]) => [code(`${COMMAND} ${cmd}`.trim()), escapeHtml(t(`help.${key}`, lang))]); + + const settings = Object.keys(DEFAULT_CONFIG).map((key) => [ + code(key), + escapeHtml(t(`settings.${key}.label`, lang)), + escapeHtml(t(`settings.${key}.desc`, lang)) + + (PAGE_SETTING_KEYS.includes(key) ? ` ${h('settings.perPage')}` : ''), + ]); + + const legacyCommands = [ + ['!hexploration_showMenuMain', `${COMMAND}`], + ['!hexploration_fillPoly', `${COMMAND} fill`], + ['!hexploration_fillInversePoly', `${COMMAND} fill inverse`], + ['!hexploration_hexModifyProperty name&&…', `${COMMAND} name …`], + ['!hexploration_configModifyProperty …', `${COMMAND} set …`], + ].map(([v1, v2]) => [code(v1), code(v2)]); + + const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const { original, maintainer } = AUTHOR_LINKS; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${h('versionLabel')} ${SCRIPT_VERSION} • ${h('subtitle')}

    +
    + ${section('overview', `

    ${h('overview.body')}

    ${link(DEMO_GIF_URL, t('handout.overview.demo', lang))}

    `)} + ${section('quickStart', list(raw('quickStart.steps'), true))} + ${section('commands', `

    ${h('commands.intro')}

    ${table([t('handout.commands.colCommand', lang), t('handout.commands.colDesc', lang)], commands)}`)} + ${section('revealing', list(raw('revealing.points')))} + ${section('locations', list(raw('locations.points')))} + ${section('settings', `

    ${h('settings.intro')}

    ${table([t('handout.settings.colKey', lang), t('handout.settings.colName', lang), t('handout.settings.colDesc', lang)], settings)}`)} + ${section('jumpgate', list(raw('jumpgate.points')))} + ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} + ${section('troubleshooting', list(raw('troubleshooting.points')))} + ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section( + 'credits', + `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    +

    ${h('credits.maintainer')} ${link(maintainer.profile, maintainer.name)} • ${link(maintainer.github, 'GitHub')}

    +

    ${h('credits.support')}

    ` + )} +
    ${SCRIPT_NAME} ${SCRIPT_VERSION} • ${h('footer', { deck: HANDOUT_DECK_NAME })}
    +
    `; + } + + /** + * Builds the Command Deck handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildDeckHtml(locale) { + const lang = getLocale(locale); + const tr = (key, vars) => t(key, lang, vars); + const btn = (key, cmd, dark = false) => + `${escapeHtml(tr(`buttons.${key}`))}`; + const group = (titleKey, descKey, buttons) => + `
    ${escapeHtml(tr(titleKey))}
    ${escapeHtml(tr(descKey))}
    ${buttons.join('')}
    `; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +
    + ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} + ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} + ${group('menu.locations', 'deck.locationsDesc', [btn('mark', 'mark'), btn('unmark', 'unmark', true), btn('name', `name ?{${tr('prompts.name')}}`)])} + ${group('menu.tools', 'deck.toolsDesc', [btn('settings', 'set', true), btn('pageSettings', 'page', true), btn('status', 'status', true), btn('rescan', 'rescan', true), btn('calibrate', 'calibrate', true), btn('calibrateReset', 'calibrate reset', true), btn('help', 'help', true), btn('menu', '', true)])} +
    ${escapeHtml(tr('deck.footer', { help: HANDOUT_HELP_NAME }))}
    +
    `; + } + + /** + * Creates or updates a handout, removing duplicates with the same name. + * + * @param {string} name Handout name. + * @param {string} html Handout notes HTML. + * @returns {void} + */ + function upsertHandout(name, html) { + const existing = findObjs({ _type: 'handout', name }); + const [primary, ...duplicates] = existing; + const handout = primary || createObj('handout', { name }); + if (!handout) { + return; + } + handout.set({ inplayerjournals: '', controlledby: '' }); + handout.set('notes', html); + for (const dup of duplicates) { + dup.remove(); + } + } + + /** + * Creates or refreshes the Help and Command Deck handouts in the current language. + * + * @returns {void} + */ + function installHandouts() { + const lang = getConfig().language; + upsertHandout(HANDOUT_HELP_NAME, buildHelpHtml(lang)); + upsertHandout(HANDOUT_DECK_NAME, buildDeckHtml(lang)); + } + + // Revealing hexes: when tokens move, from GM commands, and through the public API. + + /** + * Returns true when a token should reveal hexes under the page's settings. + * + * @param {object} token Roll20 graphic. + * @param {object} settings Effective page settings. + * @returns {boolean} True when the token reveals. + */ + function tokenReveals(token, settings) { + if (!token || token.get('_subtype') !== 'token' || token.get('layer') !== LAYER_TOKEN) { + return false; + } + switch (settings.revealBy) { + case 'all': + return true; + case 'characters': + return !!token.get('represents'); + default: + return getTokenControllers(token).some((id) => id === 'all' || !playerIsGM(id)); + } + } + + /** + * Announces a discovered location. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record (before removal). + * @param {string} name Location name. + * @param {string} imgsrc Icon image URL (may be empty). + * @param {object} settings Effective page settings. + * @returns {void} + */ + function announceDiscovery(ctx, hex, name, imgsrc, settings) { + if (name && settings.announce !== 'off') { + const lang = getConfig().language; + const img = imgsrc + ? `
    ` + : ''; + const html = buildCard( + t('discovery.title', lang), + `${img}
    ${escapeHtml(name)}
    ` + ); + const prefix = settings.announce === 'gm' ? '/w gm ' : ''; + sendChat(SCRIPT_NAME, `${prefix}${html}`); + } + if (name && settings.pingDiscoveries) { + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + sendPing(x, y, ctx.pageId, null, true); + } + } + + /** + * Reveals one hex: removes it and its label, shows its icon, and announces + * it when named. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {object} settings Effective page settings. + * @param {object} [options] Options. + * @param {number} [options.distance=0] Distance from the revealing token (for maxDistance). + * @param {boolean} [options.announce=true] Announce named discoveries. + * @returns {boolean} True when a hex was revealed. + */ + function revealHex(ctx, key, settings, { distance = 0, announce = true } = {}) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + if (distance > 0 && Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + + const name = getDiscoveryName(hex); + const icon = getHexIcon(hex); + const imgsrc = icon ? toText(icon.get('imgsrc')) : ''; + removeHex(ctx.pageId, key, false); + if (icon) { + icon.set({ layer: LAYER_TOKEN, showname: true }); + } + if (announce) { + announceDiscovery(ctx, hex, name, imgsrc, settings); + } + return true; + } + + /** + * Turns a hex see-through (glimpse mode) without revealing it. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {number} distance Distance from the revealing token. + * @returns {boolean} True when the hex changed. + */ + function glimpseHex(ctx, key, distance) { + const hex = getHex(ctx.pageId, key); + if (!hex || hex.glimpsed) { + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + const path = getPathObject(hex.id, hex.type); + if (!path) { + return false; + } + path.set('fill', getConfig().glimpseColor); + hex.glimpsed = true; + return true; + } + + /** + * Returns true when line of sight from one hex to another is blocked by a + * covered hex. Glimpsed hexes have been seen through, so they do not block. + * + * @param {object} ctx Page context. + * @param {number[]} from [row, col]. + * @param {number[]} to [row, col]. + * @returns {boolean} True when blocked. + */ + function isBlocked(ctx, from, to) { + return hexesBetween(ctx.grid, from, to).some(([r, c]) => { + const hex = getHex(ctx.pageId, hexKey(r, c)); + return hex && !hex.glimpsed; + }); + } + + /** + * Parses a token's lastmove into points. + * + * @param {string} lastmove Roll20 lastmove ("x1,y1,x2,y2,…"). + * @returns {number[][]} Array of [x, y]. + */ + function parseLastMove(lastmove) { + const nums = toText(lastmove) + .split(',') + .map(Number) + .filter((n) => Number.isFinite(n)); + const points = []; + for (let i = 0; i + 1 < nums.length; i += 2) { + points.push([nums[i], nums[i + 1]]); + } + return points; + } + + /** + * Returns the cells a token passed through on its last move, in order, plus + * every cell it now covers. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @param {object|null} prev Previous token properties, when known. + * @param {boolean} followPath Include the route travelled. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function travelledCells(ctx, token, prev, followPath) { + const current = [Number(token.get('left')), Number(token.get('top'))]; + const cells = []; + + if ( + followPath && + prev && + Number.isFinite(Number(prev.left)) && + Number.isFinite(Number(prev.top)) + ) { + const start = [Number(prev.left), Number(prev.top)]; + // lastmove holds the start point and any waypoints of the latest drag. It + // is only trusted when it starts where the token was; moves made by other + // mods leave a stale lastmove behind. + const waypoints = parseLastMove(token.get('lastmove')); + const startsHere = + waypoints.length > 0 && + Math.abs(waypoints[0][0] - start[0]) < 1 && + Math.abs(waypoints[0][1] - start[1]) < 1; + const route = startsHere ? [...waypoints, current] : [start, current]; + for (let i = 1; i < route.length; i++) { + cells.push(...hexesAlongSegment(ctx.grid, route[i - 1], route[i])); + } + } + + cells.push( + ...hexesUnderToken( + ctx.grid, + current[0], + current[1], + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + + const seen = new Set(); + return cells.filter(([r, c]) => { + const key = hexKey(r, c); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); + } + + /** + * Reveals around a list of origin cells using the page's settings. + * + * @param {object} ctx Page context. + * @param {number[][]} origins Cells the token occupied, in order. + * @param {object} settings Effective page settings. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealFromCells(ctx, origins, settings) { + let changed = 0; + for (const origin of origins) { + if (revealHex(ctx, hexKey(origin[0], origin[1]), settings)) { + changed++; + } + for (const cell of hexesWithin(ctx.grid, origin[0], origin[1], settings.revealDistance)) { + const key = hexKey(cell[0], cell[1]); + if (!getHex(ctx.pageId, key)) { + continue; + } + if (settings.lineOfSight && isBlocked(ctx, origin, cell)) { + continue; + } + const distance = hexDistance(ctx.grid, origin, cell); + const done = + settings.revealMode === 'glimpse' + ? glimpseHex(ctx, key, distance) + : revealHex(ctx, key, settings, { distance }); + if (done) { + changed++; + } + } + } + return changed; + } + + /** + * Reveals the hexes a token has moved through and can now see. + * + * @param {object} token Roll20 graphic. + * @param {object|null} [prev] Previous token properties from a change event. + * @param {boolean} [force=false] Skip the "which tokens reveal" check. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealAroundToken(token, prev = null, force = false) { + const pageId = token?.get('_pageid'); + if (!pageId || getPageHexes(pageId).length === 0) { + return 0; + } + const ctx = getPageContext(pageId); + if (!ctx.ok) { + return 0; + } + const settings = getPageSettings(pageId); + if (!force && !tokenReveals(token, settings)) { + return 0; + } + return revealFromCells(ctx, travelledCells(ctx, token, prev, settings.revealPath), settings); + } + + /** + * Handles a graphic change event: reveals when a token moves or arrives on + * the token layer. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleTokenChange(token, prev) { + const moved = prev && (prev.left !== token.get('left') || prev.top !== token.get('top')); + const surfaced = + prev && prev.layer !== token.get('layer') && token.get('layer') === LAYER_TOKEN; + const resized = + prev && (prev.width !== token.get('width') || prev.height !== token.get('height')); + handleCoveredChange(token, prev); + const layerChanged = prev && prev.layer !== token.get('layer'); + if (moved || surfaced || resized) { + if (revealAroundToken(token, moved ? prev : null) > 0) { + // Reveals may uncover other tokens as well as this one. + refreshPage(token.get('_pageid')); + return; + } + } + if (moved || layerChanged) { + refreshToken(token); + } + } + + /** + * Reveals every hex on a page without announcements. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function revealPage(ctx, onDone) { + const settings = getPageSettings(ctx.pageId); + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + let count = 0; + runInBatches( + keys, + BATCH_SIZE, + (key) => { + if (revealHex(ctx, key, settings, { announce: false })) { + count++; + } + }, + () => { + refreshPage(ctx.pageId); + onDone(count); + } + ); + } + + // Settings shown in the menu, in order, with how to prompt for them. + const SETTING_ROWS = [ + { key: 'hexLayer', options: HEX_LAYER_OPTIONS }, + { key: 'fillColor', color: true }, + { key: 'strokeColor', color: true }, + { key: 'labelColor', color: true }, + { key: 'glimpseColor', color: true }, + { key: 'strokeWidth' }, + { key: 'maxDistance' }, + { key: 'revealDistance' }, + { key: 'lineOfSight', options: ['on', 'off'] }, + { key: 'revealPath', options: ['on', 'off'] }, + { key: 'revealBy', options: REVEAL_BY_OPTIONS }, + { key: 'revealMode', options: REVEAL_MODE_OPTIONS }, + { key: 'announce', options: ANNOUNCE_OPTIONS }, + { key: 'pingDiscoveries', options: ['on', 'off'] }, + { key: 'hideCoveredTokens', options: ['on', 'off'] }, + { key: 'language' }, + ]; + + /** + * Returns the active locale. + * + * @returns {string} Locale code. + */ + function lang() { + return getConfig().language; + } + + /** + * Translates a key in the active locale. + * + * @param {string} key Translation key. + * @param {object} [vars] Interpolation variables. + * @returns {string} Translated text. + */ + function tr(key, vars) { + return t(key, lang(), vars); + } + + /** + * Whispers a translated error with its hint. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `errors.` (the hint lives under `hints.`). + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function fail(playerId, key, vars) { + const hint = t(`hints.${key}`, lang(), vars); + whisperError(playerId, tr(`errors.${key}`, vars), hint === `hints.${key}` ? '' : hint); + } + + /** + * Whispers a short translated confirmation. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `messages.`. + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function done(playerId, key, vars) { + whisper(playerId, SCRIPT_NAME, `
    ${escapeHtml(tr(`messages.${key}`, vars))}
    `); + } + + /** + * Formats a setting value for display. + * + * @param {string} key Setting key. + * @param {*} value Setting value. + * @returns {string} Display text. + */ + function formatValue(key, value) { + if (typeof value === 'boolean') { + return tr(value ? 'values.on' : 'values.off'); + } + if (value === null || value === undefined) { + return tr('values.none'); + } + if (key === 'language') { + return LOCALE_LABELS[value] || value; + } + if (['hexLayer', 'revealBy', 'revealMode', 'announce'].includes(key)) { + return tr(`values.${key}.${value}`); + } + return String(value); + } + + /** + * Builds a Roll20 query prompting for a setting's new value. + * + * @param {object} row Setting row definition. + * @param {*} current Current value. + * @returns {string} Query text. + */ + function settingQuery(row, current) { + const label = tr(`settings.${row.key}.label`).replaceAll(/[|}]/g, ''); + if (row.options) { + return `?{${label}|${row.options.join('|')}}`; + } + if (row.key === 'language') { + return `?{${label}|${SUPPORTED_LOCALES.join('|')}}`; + } + const shown = current === null || current === undefined ? '' : String(current); + return `?{${label}|${shown.replaceAll(/[|}]/g, '')}}`; + } + + // --------------------------------------------------------------------------- + // Selection and page helpers + // --------------------------------------------------------------------------- + + /** + * Sorts the selection into drawn shapes, hexes and tokens. + * + * @param {object} msg Chat message. + * @returns {{paths: object[], hexes: object[], tokens: object[], pageId: string|null}} Selection. + */ + function readSelection(msg) { + const selection = { paths: [], hexes: [], tokens: [], pageId: null }; + for (const sel of msg.selected || []) { + const obj = getObj(sel._type, sel._id); + if (!obj) { + continue; + } + selection.pageId = selection.pageId || obj.get('_pageid'); + if (isPathObject(obj)) { + const found = getHexByPathId(sel._id); + if (found) { + selection.hexes.push(found); + } else { + selection.paths.push(obj); + } + } else if (sel._type === 'graphic' && obj.get('_subtype') === 'token') { + selection.tokens.push(obj); + } + } + return selection; + } + + /** + * Returns the context for the selection's page, or the GM's current page. + * Whispers an error when the page cannot be used. + * + * @param {object} msg Chat message. + * @param {object} selection Selection from readSelection. + * @returns {object|null} Page context. + */ + function pageContextFor(msg, selection) { + const ctx = getPageContext(selection.pageId || getPlayerPageId(msg.playerid)); + if (!ctx.ok) { + fail(msg.playerid, ctx.reason); + return null; + } + return ctx; + } + + /** + * Returns the cells under the selected tokens. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number[][]} Array of [row, col]. + */ + function cellsUnderTokens(ctx, tokens) { + return tokens.flatMap((token) => + hexesUnderToken( + ctx.grid, + Number(token.get('left')), + Number(token.get('top')), + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + } + + /** + * Reports the end of a fill. + * + * @param {string} playerId Player ID. + * @param {object} summary Fill summary. + * @returns {void} + */ + function reportFill(playerId, summary) { + done(playerId, 'filled', summary); + if (summary.fellBack) { + whisperWarning(playerId, tr('warnings.foregroundUnavailable')); + } + if (summary.failed > 0) { + whisperWarning(playerId, tr('warnings.someFailed', { count: summary.failed })); + } + } + + /** + * Starts a fill and reports its outcome. + * + * @param {object} msg Chat message. + * @param {object} ctx Page context. + * @param {number[][]} allCells Cells to cover (duplicates are ignored). + * @param {object[]} sources Saved source polygons. + * @param {string} kind Fill kind. + * @returns {void} + */ + function startFill(msg, ctx, allCells, sources, kind) { + const seen = new Set(); + const cells = allCells.filter(([r, c]) => { + const key = hexKey(r, c); + return seen.has(key) ? false : seen.add(key); + }); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const result = fillCells(ctx, cells, { + sources, + kind, + onDone: (summary) => { + refreshPage(ctx.pageId); + reportFill(msg.playerid, summary); + }, + }); + if (!result.started) { + fail(msg.playerid, result.reason, { count: cells.length }); + } + } + + // --------------------------------------------------------------------------- + // Command handlers + // --------------------------------------------------------------------------- + + /** + * `fill` and `fill inverse`: cover the selected polygons (or everything + * outside them) with hexes. + * + * @param {object} msg Chat message. + * @param {boolean} inverse Fill outside the polygons. + * @returns {void} + */ + function commandFill(msg, inverse) { + const selection = readSelection(msg); + if (selection.paths.length === 0) { + fail(msg.playerid, 'noPolygons'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = inverse + ? cellsOutsidePaths(ctx, selection.paths) + : cellsInPaths(ctx, selection.paths); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, inverse ? 'fillInverse' : 'fill'); + } + + /** + * `conceal`: cover the cells under the selected polygons and tokens again. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandConceal(msg) { + const selection = readSelection(msg); + if (selection.paths.length === 0 && selection.tokens.length === 0) { + fail(msg.playerid, 'nothingToConceal'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]; + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, 'conceal'); + } + + /** + * `reveal`: reveal the selected hexes and the hexes under selected polygons + * and tokens. `reveal page` reveals everything on the page silently. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReveal(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + + if (args[0] === 'page') { + revealPage(ctx, (count) => done(msg.playerid, 'revealedPage', { count })); + return; + } + + const keys = new Set(selection.hexes.filter((h) => h.pageId === ctx.pageId).map((h) => h.key)); + for (const [r, c] of [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]) { + keys.add(hexKey(r, c)); + } + if (keys.size === 0) { + fail(msg.playerid, 'nothingToReveal'); + return; + } + consumeSourcePaths(selection.paths); + const settings = getPageSettings(ctx.pageId); + let count = 0; + for (const key of keys) { + if (revealHex(ctx, key, settings)) { + count++; + } + } + refreshPage(ctx.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `explore`: reveal around the selected tokens as if they had just moved + * there. Useful after moving tokens with other mods. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandExplore(msg) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const count = selection.tokens.reduce( + (sum, token) => sum + revealAroundToken(token, null, true), + 0 + ); + refreshPage(selection.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `reset page [confirm]`: remove every hex on the page. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReset(msg, args) { + if (args[0] !== 'page') { + fail(msg.playerid, 'unknownCommand', { command: `reset ${args.join(' ')}` }); + return; + } + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const count = getPageHexes(ctx.pageId).length; + if (args[1] !== 'confirm') { + whisper(msg.playerid, tr('titles.confirm'), [ + `
    ${escapeHtml(tr('messages.confirmReset', { count, page: ctx.page.get('name') }))}
    `, + `
    ${buildButton(tr('buttons.confirmReset'), `${COMMAND} reset page confirm`)}
    `, + ]); + return; + } + clearPage(ctx, (removed) => { + refreshPage(ctx.pageId); + done(msg.playerid, 'resetPage', { count: removed }); + }); + } + + /** + * `undo`: reverse the last fill. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandUndo(msg) { + const result = undoLastFill(); + if (!result.ok) { + fail(msg.playerid, result.reason); + return; + } + refreshPage(result.pageId); + done(msg.playerid, 'undone', result); + } + + /** + * `name `: name the selected hexes (or the hexes under selected tokens). + * An empty name clears it. + * + * @param {object} msg Chat message. + * @param {string} rawName Name text. + * @returns {void} + */ + function commandName(msg, rawName) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const keys = new Set(selection.hexes.map((h) => h.key)); + for (const token of selection.tokens) { + const [r, c] = cellsUnderTokens(ctx, [token])[0]; + keys.add(hexKey(r, c)); + } + const hexes = [...keys].map((key) => getHex(ctx.pageId, key)).filter(Boolean); + if (hexes.length === 0) { + fail(msg.playerid, 'noHexes'); + return; + } + for (const hex of hexes) { + setHexName(ctx, hex, rawName); + } + done(msg.playerid, toText(rawName) ? 'named' : 'unnamed', { + count: hexes.length, + name: toText(rawName), + }); + } + + /** + * `mark` / `unmark`: turn the selected tokens into hidden locations, or back. + * + * @param {object} msg Chat message. + * @param {boolean} mark True to mark, false to unmark. + * @returns {void} + */ + function commandMark(msg, mark) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (mark) { + done(msg.playerid, 'marked', markLocations(ctx, selection.tokens)); + } else { + done(msg.playerid, 'unmarked', { count: unmarkLocations(ctx, selection.tokens) }); + } + } + + /** + * `set [key] [value]`: change a global setting, or show the settings card. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandSet(msg, args) { + const [key, ...rest] = args; + if (!key) { + showSettings(msg.playerid); + return; + } + if (!(key in DEFAULT_CONFIG)) { + fail(msg.playerid, 'unknownSetting', { key }); + return; + } + const raw = rest.join(' '); + if (key === 'language' && !raw) { + showLanguages(msg.playerid); + return; + } + const result = setConfigValue(key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + if (key === 'language') { + installHandouts(); + } + if (key === 'hideCoveredTokens') { + if (result.value) { + getPageIds().forEach(refreshPage); + } else { + restoreAll(); + } + } + done(msg.playerid, 'settingChanged', { + setting: tr(`settings.${key}.label`), + value: formatValue(key, result.value), + }); + showSettings(msg.playerid); + } + + /** + * `page [set | clear]`: per-page overrides. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandPage(msg, args) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const [action, key, ...rest] = args; + if (action === 'set') { + if (!PAGE_SETTING_KEYS.includes(key)) { + fail(msg.playerid, 'unknownPageSetting', { + key: key || '', + keys: PAGE_SETTING_KEYS.join(', '), + }); + return; + } + const raw = rest.join(' '); + const result = setPageSetting(ctx.pageId, key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + } else if (action === 'clear') { + clearPageSettings(ctx.pageId); + } else if (action) { + fail(msg.playerid, 'unknownCommand', { command: `page ${args.join(' ')}` }); + return; + } + showPageSettings(msg.playerid, ctx); + } + + /** + * `rescan`: rebuild the page's hex list from the objects on it. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandRescan(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (ctx) { + const counts = rescanPage(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'rescanned', counts); + } + } + + /** + * `calibrate [reset]`: line the grid up with tokens snapped to hex centres. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandCalibrate(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (args[0] === 'reset') { + const counts = resetCalibration(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrationReset', counts); + return; + } + if (selection.tokens.length === 0) { + fail(msg.playerid, 'calibrateNeedsTokens'); + return; + } + const result = calibratePage(ctx, selection.tokens); + if (!result.ok) { + fail(msg.playerid, 'calibrateFailed'); + return; + } + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrated', { + ...result.counts, + colStep: result.calibration.colStep.toFixed(2), + rowStep: result.calibration.rowStep.toFixed(2), + }); + } + + /** + * `journal rebuild`: recreate the help and Command Deck handouts. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandJournal(msg) { + installHandouts(); + done(msg.playerid, 'journalRebuilt', { help: HANDOUT_HELP_NAME, deck: HANDOUT_DECK_NAME }); + } + + // --------------------------------------------------------------------------- + // Cards + // --------------------------------------------------------------------------- + + /** + * Whispers the main menu. + * + * @param {string|null} playerId Player ID (null for every GM). + * @returns {void} + */ + function showMainMenu(playerId) { + const b = (key, cmd) => buildButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + const s = (key, cmd) => buildSecondaryButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + whisper(playerId, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, [ + buildSectionLabel(tr('menu.draw')), + `
    ${b('fill', 'fill')}${b('fillInverse', 'fill inverse')}${s('undo', 'undo')}
    `, + buildSectionLabel(tr('menu.reveal')), + `
    ${b('reveal', 'reveal')}${b('conceal', 'conceal')}${b('explore', 'explore')}
    `, + `
    ${s('revealPage', 'reveal page')}${s('resetPage', 'reset page')}
    `, + buildSectionLabel(tr('menu.locations')), + `
    ${b('mark', 'mark')}${s('unmark', 'unmark')}${b('name', `name ?{${tr('prompts.name')}}`)}
    `, + buildSectionLabel(tr('menu.tools')), + `
    ${s('settings', 'set')}${s('pageSettings', 'page')}${s('status', 'status')}
    `, + `
    ${s('rescan', 'rescan')}${s('calibrate', 'calibrate')}${s('help', 'help')}
    `, + ]); + } + + /** + * Whispers the global settings card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showSettings(playerId) { + const config = getConfig(); + const rows = SETTING_ROWS.map((row) => { + const value = config[row.key]; + const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} set ${row.key} ${settingQuery(row, value)}` + ); + return buildRow(tr(`settings.${row.key}.label`), `${shown} ${button}`); + }); + whisper(playerId, tr('titles.settings'), [ + ...rows, + buildDivider(), + `
    ${escapeHtml(tr('menu.layerInUse', { layer: tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) }))}
    `, + `
    ${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the list of languages. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showLanguages(playerId) { + const buttons = SUPPORTED_LOCALES.map((code) => + buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + ); + whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); + } + + /** + * Whispers a page's settings and overrides. + * + * @param {string} playerId Player ID. + * @param {object} ctx Page context. + * @returns {void} + */ + function showPageSettings(playerId, ctx) { + const overrides = getPageData(ctx.pageId)?.settings || {}; + const effective = getPageSettings(ctx.pageId); + const rows = PAGE_SETTING_KEYS.map((key) => { + const row = SETTING_ROWS.find((r) => r.key === key); + const marker = key in overrides ? ' ★' : ''; + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} page set ${key} ${settingQuery(row, effective[key])}` + ); + return buildRow( + `${tr(`settings.${key}.label`)}${marker}`, + `${escapeHtml(formatValue(key, effective[key]))} ${button}` + ); + }); + whisper(playerId, tr('titles.pageSettings', { page: ctx.page.get('name') }), [ + `
    ${escapeHtml(tr('menu.pageSettingsHelp'))}
    `, + ...rows, + `
    ${buildSecondaryButton(tr('buttons.clearOverrides'), `${COMMAND} page clear`)}${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the status of the current page. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function showStatus(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const hexes = getPageHexes(ctx.pageId); + const data = getPageData(ctx.pageId); + const last = getLastFill(); + const row = (key, value) => buildRow(tr(`status.${key}`), escapeHtml(String(value))); + whisper(msg.playerid, tr('titles.status', { page: ctx.page.get('name') }), [ + row('engine', isJumpgate() ? 'Jumpgate' : 'Legacy'), + row('grid', tr(`values.orientation.${ctx.grid.orientation}`)), + row( + 'layer', + tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) + ), + row('hexes', hexes.length), + row('named', hexes.filter((h) => h.name).length), + row('icons', hexes.filter((h) => h.iconId).length), + row('glimpsed', hexes.filter((h) => h.glimpsed).length), + row('pending', getPendingLocations(ctx.pageId).length), + row('calibrated', tr(data?.calibration ? 'values.on' : 'values.off')), + row('overrides', Object.keys(data?.settings || {}).length), + row('undo', last ? tr(`values.fillKind.${last.kind}`) : tr('values.none')), + ]); + } + + /** + * Whispers the help card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showHelp(playerId) { + const lines = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ]; + const html = lines + .map( + ([cmd, key]) => + `
    ${escapeHtml(`${COMMAND} ${cmd}`.trim())}
    ${escapeHtml(tr(`help.${key}`))}
    ` + ) + .join(''); + whisper(playerId, tr('titles.help'), [ + html, + buildDivider(), + `
    ${escapeHtml(tr('help.handout', { name: HANDOUT_HELP_NAME }))}
    `, + ]); + } + + // --------------------------------------------------------------------------- + // Routing + // --------------------------------------------------------------------------- + + /** + * Routes a parsed command. + * + * @param {object} msg Chat message. + * @param {string} sub Subcommand. + * @param {string[]} args Arguments. + * @param {string} rest Raw text after the subcommand. + * @returns {void} + */ + function routeCommand(msg, sub, args, rest) { + switch (sub) { + case '': + case 'menu': + showMainMenu(msg.playerid); + return; + case 'help': + showHelp(msg.playerid); + return; + case 'fill': + commandFill(msg, args[0] === 'inverse'); + return; + case 'conceal': + case 'hide': + commandConceal(msg); + return; + case 'reveal': + commandReveal(msg, args); + return; + case 'explore': + commandExplore(msg); + return; + case 'reset': + commandReset(msg, args); + return; + case 'undo': + commandUndo(msg); + return; + case 'name': + commandName(msg, rest); + return; + case 'mark': + commandMark(msg, true); + return; + case 'unmark': + commandMark(msg, false); + return; + case 'set': + case 'config': + commandSet(msg, args); + return; + case 'page': + commandPage(msg, args); + return; + case 'rescan': + commandRescan(msg); + return; + case 'calibrate': + commandCalibrate(msg, args); + return; + case 'status': + showStatus(msg); + return; + case 'journal': + commandJournal(msg); + return; + default: + fail(msg.playerid, 'unknownCommand', { command: sub }); + } + } + + /** + * Maps a v1 command to the v2 handlers. + * + * @param {object} msg Chat message. + * @param {string} action Legacy action from LEGACY_COMMANDS. + * @param {string} rest Raw text after the command. + * @returns {void} + */ + function routeLegacy(msg, action, rest) { + const params = rest.split(LEGACY_ARG_SEPARATOR).map((p) => p.trim()); + switch (action) { + case 'fill': + commandFill(msg, false); + return; + case 'fillInverse': + commandFill(msg, true); + return; + case 'menu': + showMainMenu(msg.playerid); + return; + case 'legacyHex': + if (params[0] === 'name') { + commandName(msg, params.slice(1).join(LEGACY_ARG_SEPARATOR)); + } + return; + case 'legacyConfig': { + const [prop, ...values] = params; + // v1 defaults when a colour prompt is left empty. + const updates = { + color: () => ({ + fillColor: values[0] || 'black', + strokeColor: values[1] || 'transparent', + labelColor: values[2] || 'white', + }), + strokeWidth: () => ({ strokeWidth: values[0] || '0' }), + maxDistance: () => ({ maxDistance: values[0] || '' }), + revealDistance: () => ({ revealDistance: values[0] || '0' }), + }[prop]; + if (!updates) { + fail(msg.playerid, 'unknownSetting', { key: prop || '' }); + return; + } + for (const [key, value] of Object.entries(updates())) { + if (!setConfigValue(key, value).valid) { + fail(msg.playerid, 'invalidValue', { key, value }); + } + } + showSettings(msg.playerid); + return; + } + } + } + + /** + * Handles chat input: `!hexploration …` and the v1 commands. GM only. + * + * @param {object} msg Roll20 chat message. + * @returns {void} + */ + function handleInput(msg) { + if (msg.type !== 'api') { + return; + } + const content = toText(msg.content); + const [first] = content.split(/\s+/, 1); + const isMain = first === COMMAND; + const legacy = LEGACY_COMMANDS[first]; + if (!isMain && !legacy) { + return; + } + if (!playerIsGM(msg.playerid)) { + return; + } + + try { + const rest = content.slice(first.length).trim(); + if (legacy) { + routeLegacy(msg, legacy, rest); + return; + } + const [sub = '', ...args] = rest.split(/\s+/).filter(Boolean); + const afterSub = rest.slice(sub.length).trim(); + routeCommand(msg, sub.toLowerCase(), args, afterSub); + } catch (err) { + log(`${SCRIPT_NAME} ERROR: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + fail(msg.playerid, 'unexpected', { message: err?.message || String(err) }); + } + } + + let ready = false; + + /** + * Runs a handler, logging instead of crashing the sandbox on errors. + * + * @param {string} label Handler name for the log. + * @param {Function} fn Handler. + * @returns {Function} Wrapped handler. + */ + function guarded(label, fn) { + return (...args) => { + if (!ready) { + return; + } + try { + fn(...args); + } catch (err) { + log(`${SCRIPT_NAME} ERROR in ${label}: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }; + } + + /** + * Forgets a hex whose path was deleted by hand. + * + * @param {object} path Deleted Roll20 path. + * @returns {void} + */ + function handlePathDestroyed(path) { + const found = getHexByPathId(path.get('_id')); + if (found) { + removeLabel(found.hex); + deleteHexRecord(found.pageId, found.key); + refreshPage(found.pageId); + } + } + + /** + * Forgets a deleted token as a pending location or hidden token. + * + * @param {object} token Deleted Roll20 graphic. + * @returns {void} + */ + function handleGraphicDestroyed(token) { + setPendingLocation(token.get('_id'), null); + delete getCoveredTokens()[token.get('_id')]; + } + + /** + * Forgets a deleted page's hexes. + * + * @param {object} page Deleted Roll20 page. + * @returns {void} + */ + function handlePageDestroyed(page) { + const pageId = page.get('_id'); + if (getPageIds().includes(pageId)) { + deletePageData(pageId); + } + } + + /** + * Registers with TokenMod (if installed) so tokens it moves reveal hexes; + * the API does not raise change events for moves made by other mods. + * + * @returns {void} + */ + function observeOtherMods() { + if (typeof TokenMod !== 'undefined' && typeof TokenMod?.ObserveTokenChange === 'function') { + TokenMod.ObserveTokenChange(guarded('TokenMod observer', handleTokenChange)); + } + } + + /** + * Publishes the API other mods can call. + * + * @returns {void} + */ + function publishApi() { + globalThis.Hexploration = Object.freeze({ + version: SCRIPT_VERSION, + /** + * Reveals around a token as if it had just moved, for mods that move tokens. + * + * @param {object|string} tokenOrId Roll20 graphic or its ID. + * @param {object} [prev] Previous left/top, to reveal along the route. + * @returns {number} Number of hexes revealed or glimpsed. + */ + revealAround(tokenOrId, prev = null) { + const token = typeof tokenOrId === 'string' ? getObj('graphic', tokenOrId) : tokenOrId; + if (!ready || !token) { + return 0; + } + try { + const changed = revealAroundToken(token, prev); + refreshPage(token.get('_pageid')); + return changed; + } catch (err) { + log(`${SCRIPT_NAME} ERROR in revealAround: ${err?.message || err}`); + return 0; + } + }, + }); + } + + /** + * Startup: migrate state, clean up, install handouts and greet the GM. + * + * @returns {void} + */ + function checkInstall() { + const migratedFrom = initialiseState(); + applyGlobalConfig(); + const pruned = pruneMissingHexes(); + for (const pageId of new Set([ + ...getPageIds(), + ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), + ])) { + refreshPage(pageId); + } + installHandouts(); + registerEngineHandlers(); + observeOtherMods(); + publishApi(); + ready = true; + + log( + `-=> ${SCRIPT_NAME} v${SCRIPT_VERSION} [Updated: ${SCRIPT_LAST_UPDATED}] (${isJumpgate() ? 'Jumpgate' : 'Legacy'}) <=-` + ); + + const lang = getConfig().language; + const lines = [`
    ${escapeHtml(t('titles.ready', lang))}
    `]; + if (migratedFrom === 1) { + lines.push(`
    ${escapeHtml(t('messages.migrated', lang))}
    `); + } + if (pruned.dropped > 0) { + lines.push( + `
    ${escapeHtml(t('messages.pruned', lang, pruned))}
    ` + ); + } + lines.push( + `
    ${escapeHtml(t('messages.readyHint', lang))}
    ` + ); + whisper(null, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, lines); + if (migratedFrom === 1 || pruned.dropped > 0) { + showMainMenu(null); + } + } + + /** + * Registers all Roll20 event handlers. + * + * @returns {void} + */ + function registerEventHandlers() { + on('ready', () => { + try { + checkInstall(); + } catch (err) { + log(`${SCRIPT_NAME} ERROR during startup: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }); + on('chat:message', (msg) => { + if (ready) { + handleInput(msg); + } + }); + on('change:graphic', guarded('change:graphic', handleTokenChange)); + on('add:graphic', guarded('add:graphic', refreshToken)); + on('destroy:graphic', guarded('destroy:graphic', handleGraphicDestroyed)); + on('destroy:page', guarded('destroy:page', handlePageDestroyed)); + on(`destroy:${PATH_TYPE_LEGACY}`, guarded('destroy:path', handlePathDestroyed)); + } + + /** + * Registers handlers that depend on the game engine. pathv2 objects only + * exist in Jumpgate, and the engine is only known once the game has loaded. + * + * @returns {void} + */ + function registerEngineHandlers() { + if (isJumpgate()) { + on(`destroy:${PATH_TYPE_V2}`, guarded('destroy:pathv2', handlePathDestroyed)); + } + } + + registerEventHandlers(); +})(); diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js new file mode 100644 index 0000000000..87a8b34aff --- /dev/null +++ b/Hexploration/Hexploration.js @@ -0,0 +1,7387 @@ +/** + * NOTE: GENERATED FILE - DO NOT EDIT DIRECTLY. + * NOTE: Source files live under src/ and are bundled with `npm run build`. + * ------------------------------------------------ + * Name: Hexploration + * Script: Hexploration.js + * Version: 2.0.0 + * Built: 2026-10-29T02:20:55.900Z + */ +const HexplorationMod = (() => { + 'use strict'; + + // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. + const SCRIPT_NAME = 'Hexploration'; + const SCRIPT_VERSION = '2.0.0'; + const SCRIPT_LAST_UPDATED = '2026-10-29T02:20:55.900Z'; + + const DEFAULT_LOCALE$1 = 'en-US'; + + const STATE_KEY = 'Hexploration'; + const SCHEMA_VERSION = 2; + const COMMAND = '!hexploration'; + + // v1 commands, kept so existing macros and the Hexploration_menu macro still work. + const LEGACY_COMMANDS = { + '!hexploration_fillPoly': 'fill', + '!hexploration_fillInversePoly': 'fillInverse', + '!hexploration_showMenuMain': 'menu', + '!hexploration_configModifyProperty': 'legacyConfig', + '!hexploration_hexModifyProperty': 'legacyHex', + }; + + // Separator v1 used between the arguments of its config and hex commands. + const LEGACY_ARG_SEPARATOR = '&&'; + + const HANDOUT_HELP_NAME = 'Hexploration - Help'; + const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; + + const AUTHOR_LINKS = { + original: { + name: 'Ada Lindberg', + profile: 'https://app.roll20.net/users/46544/ada-l', + marketplace: 'https://marketplace.roll20.net/browse/publisher/165/ada-lindberg', + }, + maintainer: { + name: 'MidNiteShadow7', + profile: 'https://app.roll20.net/users/16506286/midniteshadow7', + github: 'https://github.com/steverobertsuk', + }, + }; + + const DEMO_GIF_URL = + 'https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif'; + + // Roll20 layer identifiers. + const LAYER_TOKEN = 'objects'; + const LAYER_GM = 'gmlayer'; + const LAYER_FOREGROUND = 'foreground'; + + // Roll20 object types for drawn shapes. Jumpgate draws pathv2; Legacy draws path. + const PATH_TYPE_LEGACY = 'path'; + const PATH_TYPE_V2 = 'pathv2'; + const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + + // Status marker v1 used to flag location tokens. Still honoured as a fallback. + const LOCATION_MARKER = 'white-tower'; + + // Option lists for settings. + const HEX_LAYER_OPTIONS = ['auto', 'foreground', 'objects']; + const REVEAL_BY_OPTIONS = ['players', 'characters', 'all']; + const REVEAL_MODE_OPTIONS = ['clear', 'glimpse']; + const ANNOUNCE_OPTIONS = ['all', 'gm', 'off']; + + // Default configuration for new installs. Migrated v1 games keep their own values. + const DEFAULT_CONFIG = { + language: DEFAULT_LOCALE$1, + hexLayer: 'auto', + fillColor: '#222222', + strokeColor: '#444444', + labelColor: '#FFFFFF', + glimpseColor: 'rgba(34,34,34,0.5)', + strokeWidth: 1, + revealDistance: 1, + maxDistance: null, + lineOfSight: true, + revealPath: true, + revealBy: 'players', + revealMode: 'clear', + announce: 'all', + pingDiscoveries: false, + hideCoveredTokens: true, + }; + + // Player-visible token properties switched off while a token is under a + // covered hex, because Roll20 draws nameplates, bars and auras above the + // foreground layer. Saved values are restored when the token is uncovered. + const COVERED_TOKEN_PROPS = [ + 'showplayers_name', + 'showplayers_bar1', + 'showplayers_bar2', + 'showplayers_bar3', + 'showplayers_aura1', + 'showplayers_aura2', + ]; + + // Settings that can be overridden for a single page. + const PAGE_SETTING_KEYS = [ + 'revealDistance', + 'lineOfSight', + 'revealPath', + 'revealBy', + 'revealMode', + 'announce', + 'pingDiscoveries', + ]; + + // Limits that keep a single command from creating an unreasonable number of objects. + const MAX_REVEAL_DISTANCE = 20; + const MAX_STROKE_WIDTH = 20; + const MAX_FILL_HEXES = 20000; + const MAX_NAME_LENGTH = 100; + + // Hexes are created and removed in batches so large fills do not trip the + // API's long-running script watchdog. + const BATCH_SIZE = 100; + + // How close (as a fraction of the column step) a path's centre must be to a + // hex centre for Rescan to adopt it as a hex. + const RESCAN_CENTRE_TOLERANCE = 0.2; + + // How close (in pixels) a text label must be to a hex centre to be adopted as its name. + const RESCAN_LABEL_TOLERANCE = 6; + + // Colour palette for chat cards and handouts. + const COLOR_HEADER_BG = '#1b2a1f'; + const COLOR_HEADER_TEXT = '#e8dcb5'; + const COLOR_CARD_BG_TOP = '#22352a'; + const COLOR_CARD_BG_BOTTOM = '#14211a'; + const COLOR_BORDER = '#3c5a45'; + const COLOR_TEXT = '#e4e0d0'; + const COLOR_MUTED = '#9aa89c'; + const COLOR_ACCENT = '#d9a441'; + const COLOR_BUTTON_BG = '#b5832a'; + const COLOR_BUTTON_TEXT = '#ffffff'; + const COLOR_WARNING_BG = '#fef3c7'; + const COLOR_WARNING_BORDER = '#92400e'; + const COLOR_WARNING_TEXT = '#92400e'; + const COLOR_ERROR_BG = '#fee2e2'; + const COLOR_ERROR_BORDER = '#991b1b'; + const COLOR_ERROR_TEXT = '#991b1b'; + + /** + * Returns true when a value is a plain non-null, non-array object. + * + * @param {*} value Value to test. + * @returns {boolean} True when the value is a record. + */ + function isRecord(value) { + return value !== null && typeof value === 'object' && !Array.isArray(value); + } + + /** + * Converts a value to trimmed text, treating null and undefined as empty. + * + * @param {*} value Value to convert. + * @returns {string} Trimmed string. + */ + function toText(value) { + return value === null || value === undefined ? '' : String(value).trim(); + } + + /** + * Escapes HTML special characters. + * + * @param {*} text Text to escape. + * @returns {string} Escaped text. + */ + function escapeHtml(text) { + return String(text) + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); + } + + /** + * Parses a whole number, rejecting anything that is not entirely digits + * (with an optional leading minus sign). + * + * @param {*} raw Raw input. + * @returns {number|null} Parsed integer, or null when invalid. + */ + function parseStrictInt(raw) { + const text = toText(raw); + return /^-?\d+$/.test(text) ? Number(text) : null; + } + + /** + * Parses a yes/no style value. + * + * @param {*} raw Raw input. + * @returns {boolean|null} Parsed boolean, or null when not recognised. + */ + function parseBoolean(raw) { + if (typeof raw === 'boolean') { + return raw; + } + const text = toText(raw).toLowerCase(); + if (['on', 'true', 'yes', '1'].includes(text)) { + return true; + } + if (['off', 'false', 'no', '0'].includes(text)) { + return false; + } + return null; + } + + /** + * Returns true when a value is a colour Roll20 accepts for path fill and stroke: + * #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(), rgba(), transparent, or a CSS colour name. + * + * @param {*} raw Colour text. + * @returns {boolean} True when valid. + */ + function isValidColor(raw) { + const text = toText(raw); + return ( + /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text) || + /^rgba?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+%?\s*)?\)$/i.test(text) || + /^[a-z]{3,20}$/i.test(text) + ); + } + + /** + * Clamps a number into a range. + * + * @param {number} value Value. + * @param {number} min Minimum. + * @param {number} max Maximum. + * @returns {number} Clamped value. + */ + function clamp(value, min, max) { + return Math.min(max, Math.max(min, value)); + } + + let jumpgateCache = null; + + /** + * Returns true when the game runs on Jumpgate. Roll20 has exposed this as + * both `_release` and `release`, so both are checked. + * + * @returns {boolean} True for Jumpgate games. + */ + function isJumpgate() { + if (jumpgateCache === null) { + const campaign = Campaign(); + const release = toText(campaign.get('_release') || campaign.get('release')).toLowerCase(); + jumpgateCache = release === 'jumpgate'; + } + return jumpgateCache; + } + + /** + * Returns the page a player is viewing: their own page when split from the + * party, otherwise the player ribbon page. + * + * @param {string} playerId Roll20 player ID. + * @returns {string} Page ID. + */ + function getPlayerPageId(playerId) { + const campaign = Campaign(); + if (playerIsGM(playerId)) { + const player = getObj('player', playerId); + const lastPage = player?.get('_lastpage'); + if (lastPage) { + return lastPage; + } + } + const specific = campaign.get('playerspecificpages'); + if (isRecord(specific) && specific[playerId]) { + return specific[playerId]; + } + return campaign.get('playerpageid'); + } + + /** + * Returns the player IDs who control a token, directly or through the + * character it represents. + * + * @param {Graphic} token Roll20 token. + * @returns {string[]} Controller IDs (may include 'all'). + */ + function getTokenControllers(token) { + const ids = new Set(); + const add = (list) => { + for (const id of toText(list).split(',')) { + if (id.trim()) { + ids.add(id.trim()); + } + } + }; + add(token.get('controlledby')); + const characterId = token.get('represents'); + if (characterId) { + add(getObj('character', characterId)?.get('controlledby')); + } + return [...ids]; + } + + /** + * Returns true when a token carries a status marker, matching both plain + * markers ("white-tower") and numbered ones ("white-tower@2"). + * + * @param {Graphic} token Roll20 token. + * @param {string} marker Marker tag. + * @returns {boolean} True when the marker is present. + */ + function tokenHasMarker(token, marker) { + return toText(token.get('statusmarkers')) + .split(',') + .some((tag) => tag.split('@')[0] === marker); + } + + /** + * Splits work into batches run on successive event-loop turns, so large jobs + * do not trip the API sandbox's long-running script watchdog. + * + * @param {Array} items Items to process. + * @param {number} size Batch size. + * @param {(item: *, index: number) => void} work Called for each item. + * @param {(errors: number) => void} [done] Called once every item has been + * processed, with the number of items whose work threw. + * @returns {void} + */ + function runInBatches(items, size, work, done) { + let index = 0; + let errors = 0; + // Errors are caught per item: an exception thrown from a timer callback + // would otherwise stop the whole API sandbox. + const step = () => { + const end = Math.min(items.length, index + size); + for (; index < end; index++) { + try { + work(items[index], index); + } catch (err) { + errors++; + log(`Hexploration: batch item failed: ${err?.message || err}`); + } + } + if (index < items.length) { + setTimeout(step, 0); + } else if (done) { + try { + done(errors); + } catch (err) { + log(`Hexploration: batch completion failed: ${err?.message || err}`); + } + } + }; + step(); + } + + const CHAT_CARD_STYLE = [ + 'width:100%', + 'border-radius:4px', + 'box-shadow:1px 1px 3px rgba(0,0,0,0.4)', + 'text-align:left', + 'margin:2px auto', + `border:1px solid ${COLOR_BORDER}`, + `color:${COLOR_TEXT}`, + `background-image:-webkit-linear-gradient(135deg,${COLOR_CARD_BG_TOP} 0%,${COLOR_CARD_BG_BOTTOM} 100%)`, + `background-color:${COLOR_CARD_BG_BOTTOM}`, + 'overflow:hidden', + ].join(';'); + + const CHAT_HEADER_STYLE = [ + `background:${COLOR_HEADER_BG}`, + `color:${COLOR_HEADER_TEXT}`, + 'padding:4px 8px', + `border-bottom:2px solid ${COLOR_ACCENT}`, + 'font-variant:small-caps', + 'font-weight:bold', + 'font-size:1.05em', + 'text-align:center', + 'letter-spacing:0.05em', + ].join(';'); + + const CHAT_CONTENT_STYLE = 'padding:5px 8px;line-height:1.5'; + + const BUTTON_STYLE = [ + `background:${COLOR_BUTTON_BG}`, + `color:${COLOR_BUTTON_TEXT}`, + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const BUTTON_SECONDARY_STYLE = [ + 'background:#2c4034', + `color:${COLOR_TEXT}`, + 'border:1px solid #4d6b56', + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const SECTION_LABEL_STYLE = [ + `color:${COLOR_MUTED}`, + 'font-size:0.8em', + 'text-transform:uppercase', + 'letter-spacing:0.08em', + 'margin-top:4px', + 'margin-bottom:2px', + ].join(';'); + + const DIVIDER_STYLE = `border:none;border-top:1px solid ${COLOR_BORDER};margin:4px 0`; + + /** + * Returns the whisper target for a player, falling back to all GMs. + * + * Double quotes are stripped so the name is safe inside /w "name". + * + * @param {string} [playerId] Roll20 player ID. + * @returns {string} Whisper target text. + */ + function whisperTarget(playerId) { + const player = playerId ? getObj('player', playerId) : null; + if (!player) { + return 'gm'; + } + return `"${String(player.get('displayname') || playerId).replaceAll('"', '')}"`; + } + + /** + * Sends a styled card whispered to a player, or to every GM when no player is given. + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} title Card header text. + * @param {string|string[]} content HTML body content. + * @returns {void} + */ + function whisper(playerId, title, content) { + const body = Array.isArray(content) ? content.join('') : content; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${buildCard(title, body)}`, null, { + noarchive: true, + }); + } + + /** + * Sends a warning whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message Warning text. + * @returns {void} + */ + function whisperWarning(playerId, message) { + const style = [ + `background:${COLOR_WARNING_BG}`, + `color:${COLOR_WARNING_TEXT}`, + `border:1px solid ${COLOR_WARNING_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const html = `
    ${escapeHtml(message)}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Sends an error whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message What went wrong. + * @param {string} [hint] How to fix it. + * @returns {void} + */ + function whisperError(playerId, message, hint) { + const style = [ + `background:${COLOR_ERROR_BG}`, + `color:${COLOR_ERROR_TEXT}`, + `border:1px solid ${COLOR_ERROR_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const hintHtml = hint + ? `
    ${escapeHtml(hint)}
    ` + : ''; + const html = `
    ${escapeHtml(message)}${hintHtml}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Builds a styled chat card. + * + * @param {string} title Header text (escaped). + * @param {string} body Body HTML (trusted). + * @returns {string} HTML string. + */ + function buildCard(title, body) { + return [ + `
    `, + `
    ${escapeHtml(title)}
    `, + `
    ${body}
    `, + '
    ', + ].join(''); + } + + /** + * Builds a primary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a secondary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildSecondaryButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a section label. + * + * @param {string} text Label text. + * @returns {string} HTML string. + */ + function buildSectionLabel(text) { + return `
    ${escapeHtml(text)}
    `; + } + + /** + * Builds a horizontal divider. + * + * @returns {string} HTML string. + */ + function buildDivider() { + return `
    `; + } + + /** + * Builds a label/value row. The value may be trusted HTML (e.g. a button). + * + * @param {string} label Label text (escaped). + * @param {string} valueHtml Value HTML. + * @returns {string} HTML string. + */ + function buildRow(label, valueHtml) { + return [ + '', + ``, + ``, + '
    ${escapeHtml(label)}${valueHtml}
    ', + ].join(''); + } + + /** + * Builds a small colour swatch with its value. + * + * @param {string} color CSS colour. + * @returns {string} HTML string. + */ + function buildSwatch(color) { + const safe = escapeHtml(color); + return ` ${safe}`; + } + + // Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, + // so the whole module can be unit tested in Node. + // + // Hexes are addressed by offset coordinates [row, col], matching the keys v1 + // stored in state. "vertical" is Roll20's Hex (V) grid (pointy-top hexes, odd + // rows shifted right by half a hex). "horizontal" is Hex (H) (flat-top hexes, + // odd columns shifted down by half a hex). Internally the maths converts to + // cube coordinates, which make distance, rounding and line drawing exact. + + const SQRT3 = Math.sqrt(3); + + const ORIENTATION_VERTICAL = 'vertical'; + const ORIENTATION_HORIZONTAL = 'horizontal'; + + // Pixel spacing of a 1-unit hex grid. + // + // Legacy values were measured from the Legacy editor's grid by the v1 author + // and are kept exactly so existing v1 hexes stay aligned. Legacy hexes are + // slightly stretched rather than regular. + // + // Jumpgate draws mathematically regular hexes from the 70 px grid unit: the + // distance across the flats is one unit, so the corner radius is 70/√3. The + // first hex's bounding box sits at the page's top-left corner. (Taken from the + // Jumpgate client's hex grid, which builds cells with radius gridCellSize/√3.) + // Pages that still do not line up can be corrected with `!hexploration calibrate`. + const LEGACY_V = { + colStep: 75.19856198446, + rowStep: 66.965827824268, + originX: 37.5, + originY: 44, + }; + const LEGACY_H = { + colStep: 69.585127490377, + rowStep: 79.688789983504, + originX: 47, + originY: 40.5, + }; + const JUMPGATE_UNIT = 70; + + const GRID_PROFILES = { + legacy: { + [ORIENTATION_VERTICAL]: LEGACY_V, + [ORIENTATION_HORIZONTAL]: LEGACY_H, + }, + jumpgate: { + [ORIENTATION_VERTICAL]: { + colStep: JUMPGATE_UNIT, + rowStep: (JUMPGATE_UNIT * SQRT3) / 2, + originX: JUMPGATE_UNIT / 2, + originY: JUMPGATE_UNIT / SQRT3, + }, + [ORIENTATION_HORIZONTAL]: { + colStep: (JUMPGATE_UNIT * SQRT3) / 2, + rowStep: JUMPGATE_UNIT, + originX: JUMPGATE_UNIT / SQRT3, + originY: JUMPGATE_UNIT / 2, + }, + }, + }; + + /** + * Maps a Roll20 page grid_type to a hex orientation. + * + * @param {string} gridType Page grid_type ('hex' or 'hexr'). + * @returns {string|null} Orientation, or null when the grid is not hexagonal. + */ + function orientationForGridType(gridType) { + if (gridType === 'hex') { + return ORIENTATION_VERTICAL; + } + if (gridType === 'hexr') { + return ORIENTATION_HORIZONTAL; + } + return null; + } + + /** + * Builds a grid description for a page. + * + * @param {object} options Grid options. + * @param {string} options.gridType Page grid_type. + * @param {number} [options.scale=1] Page snapping_increment (cell size in units). + * @param {boolean} [options.jumpgate=false] True for Jumpgate geometry. + * @param {number} [options.offsetX=0] Jumpgate page grid_offset_x, in pixels. + * @param {number} [options.offsetY=0] Jumpgate page grid_offset_y, in pixels. Jumpgate + * measures it upwards, so a positive value moves the grid up the page. + * @param {object|null} [options.calibration] Per-page pixel overrides from calibrate. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function createGrid({ + gridType, + scale = 1, + jumpgate = false, + offsetX = 0, + offsetY = 0, + calibration = null, + }) { + const orientation = orientationForGridType(gridType); + if (!orientation) { + return null; + } + + const unit = Number(scale) > 0 ? Number(scale) : 1; + const profile = GRID_PROFILES[jumpgate ? 'jumpgate' : 'legacy'][orientation]; + const grid = { + orientation, + colStep: profile.colStep * unit, + rowStep: profile.rowStep * unit, + originX: profile.originX * unit + (jumpgate ? Number(offsetX) || 0 : 0), + originY: profile.originY * unit - (jumpgate ? Number(offsetY) || 0 : 0), + }; + + if (calibration) { + for (const key of ['colStep', 'rowStep', 'originX', 'originY']) { + if ( + Number.isFinite(calibration[key]) && + (key.startsWith('origin') || calibration[key] > 0) + ) { + grid[key] = calibration[key]; + } + } + } + + return grid; + } + + /** + * Returns true when an integer is odd, including negative values. + * + * @param {number} n Integer. + * @returns {boolean} True when odd. + */ + function isOdd(n) { + return (n & 1) === 1; + } + + /** + * Builds the state key for a hex. + * + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {string} Key in "row,col" form. + */ + function hexKey(row, col) { + return `${row},${col}`; + } + + /** + * Parses a "row,col" hex key. + * + * @param {string} key Hex key. + * @returns {number[]|null} [row, col], or null when malformed. + */ + function parseHexKey(key) { + const parts = String(key).split(','); + if (parts.length !== 2) { + return null; + } + const row = Number(parts[0]); + const col = Number(parts[1]); + return Number.isInteger(row) && Number.isInteger(col) ? [row, col] : null; + } + + /** + * Converts offset coordinates to cube coordinates. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [q, r, s]. + */ + function offsetToCube(grid, row, col) { + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = col - (row - (row & 1)) / 2; + r = row; + } else { + q = col; + r = row - (col - (col & 1)) / 2; + } + return [q, r, -q - r]; + } + + /** + * Converts cube coordinates to offset coordinates. + * + * @param {object} grid Grid object. + * @param {number[]} cube [q, r, s]. + * @returns {number[]} [row, col]. + */ + function cubeToOffset(grid, cube) { + const [q, r] = cube; + if (grid.orientation === ORIENTATION_VERTICAL) { + return [r, q + (r - (r & 1)) / 2]; + } + return [r + (q - (q & 1)) / 2, q]; + } + + /** + * Rounds fractional cube coordinates to the nearest hex. + * + * @param {number[]} cube Fractional [q, r, s]. + * @returns {number[]} Integer [q, r, s]. + */ + function cubeRound(cube) { + let q = Math.round(cube[0]); + let r = Math.round(cube[1]); + let s = Math.round(cube[2]); + const dq = Math.abs(q - cube[0]); + const dr = Math.abs(r - cube[1]); + const ds = Math.abs(s - cube[2]); + + if (dq > dr && dq > ds) { + q = -r - s; + } else if (dr > ds) { + r = -q - s; + } else { + s = -q - r; + } + // Normalise -0 so keys never contain "-0". + return [q + 0, r + 0, s + 0]; + } + + /** + * Returns the pixel centre of a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [x, y]. + */ + function hexToPixel(grid, row, col) { + if (grid.orientation === ORIENTATION_VERTICAL) { + return [ + grid.originX + (col + (isOdd(row) ? 0.5 : 0)) * grid.colStep, + grid.originY + row * grid.rowStep, + ]; + } + return [ + grid.originX + col * grid.colStep, + grid.originY + (row + (isOdd(col) ? 0.5 : 0)) * grid.rowStep, + ]; + } + + /** + * Returns the hex containing a pixel position. + * + * The grid is treated as a regular hex lattice scaled by colStep and rowStep, + * so this is exact for both regular (Jumpgate) and stretched (Legacy) hexes. + * + * @param {object} grid Grid object. + * @param {number} x Pixel x. + * @param {number} y Pixel y. + * @returns {number[]} [row, col]. + */ + function pixelToHex(grid, x, y) { + const colF = (x - grid.originX) / grid.colStep; + const rowF = (y - grid.originY) / grid.rowStep; + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = colF - rowF / 2; + r = rowF; + } else { + q = colF; + r = rowF - colF / 2; + } + return cubeToOffset(grid, cubeRound([q, r, -q - r])); + } + + /** + * Returns the number of hex steps between two hexes. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number} Distance in hexes. + */ + function hexDistance(grid, a, b) { + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + return Math.max(Math.abs(ca[0] - cb[0]), Math.abs(ca[1] - cb[1]), Math.abs(ca[2] - cb[2])); + } + + /** + * Returns every hex within a distance of a hex (excluding the hex itself), + * nearest first. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {number} radius Distance in hexes. + * @returns {number[][]} Array of [row, col]. + */ + function hexesWithin(grid, row, col, radius) { + const result = []; + const [q, r] = offsetToCube(grid, row, col); + for (let dist = 1; dist <= radius; dist++) { + for (let dq = -dist; dq <= dist; dq++) { + for (let dr = Math.max(-dist, -dq - dist); dr <= Math.min(dist, -dq + dist); dr++) { + const ds = -dq - dr; + if (Math.max(Math.abs(dq), Math.abs(dr), Math.abs(ds)) === dist) { + result.push(cubeToOffset(grid, [q + dq, r + dr, -(q + dq) - (r + dr)])); + } + } + } + } + return result; + } + + /** + * Returns the hexes on a straight line between two hexes, both ends included. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexLine(grid, a, b) { + const n = hexDistance(grid, a, b); + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + if (n === 0) { + return [[a[0], a[1]]]; + } + + // A tiny nudge stops the line landing exactly on hex edges, where rounding + // would otherwise pick a side inconsistently. + const nudge = [1e-6, 2e-6, -3e-6]; + const result = []; + for (let i = 0; i <= n; i++) { + const t = i / n; + const cube = [0, 1, 2].map((k) => ca[k] + nudge[k] + (cb[k] - ca[k]) * t); + result.push(cubeToOffset(grid, cubeRound(cube))); + } + return result; + } + + /** + * Returns the hexes strictly between two hexes on a straight line. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesBetween(grid, a, b) { + return hexLine(grid, a, b).slice(1, -1); + } + + /** + * Returns the hexes crossed by a pixel-space line segment, in travel order. + * + * @param {object} grid Grid object. + * @param {number[]} from [x, y]. + * @param {number[]} to [x, y]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesAlongSegment(grid, from, to) { + return hexLine(grid, pixelToHex(grid, from[0], from[1]), pixelToHex(grid, to[0], to[1])); + } + + /** + * Returns the six corner points of a hex in pixels. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of six [x, y] points, clockwise. + */ + function hexCorners(grid, row, col) { + const [cx, cy] = hexToPixel(grid, row, col); + const corners = []; + for (let i = 0; i < 6; i++) { + if (grid.orientation === ORIENTATION_VERTICAL) { + const angle = ((30 + 60 * i) * Math.PI) / 180; + corners.push([ + cx + (Math.cos(angle) / SQRT3) * grid.colStep, + cy + ((Math.sin(angle) * 2) / 3) * grid.rowStep, + ]); + } else { + const angle = (60 * i * Math.PI) / 180; + corners.push([ + cx + ((Math.cos(angle) * 2) / 3) * grid.colStep, + cy + (Math.sin(angle) / SQRT3) * grid.rowStep, + ]); + } + } + return corners; + } + + /** + * Returns every hex whose centre lies inside a bounding box. + * + * @param {object} grid Grid object. + * @param {object} box Box with left, top, right and bottom in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesInBox(grid, box) { + const [r0, c0] = pixelToHex(grid, box.left, box.top); + const [r1, c1] = pixelToHex(grid, box.right, box.bottom); + const result = []; + for (let row = Math.min(r0, r1) - 1; row <= Math.max(r0, r1) + 1; row++) { + for (let col = Math.min(c0, c1) - 1; col <= Math.max(c0, c1) + 1; col++) { + const [x, y] = hexToPixel(grid, row, col); + if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) { + result.push([row, col]); + } + } + } + return result; + } + + /** + * Returns every hex needed to cover a page completely, including the partial + * hexes along its edges. + * + * @param {object} grid Grid object. + * @param {number} widthPx Page width in pixels. + * @param {number} heightPx Page height in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesCoveringPage(grid, widthPx, heightPx) { + // A hex overlaps the page when its centre is within its own half-size of + // the page edge. Slivers thinner than a quarter pixel are ignored. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const padX = (vertical ? grid.colStep / 2 : (grid.colStep * 2) / 3) - 0.25; + const padY = (vertical ? (grid.rowStep * 2) / 3 : grid.rowStep / 2) - 0.25; + return hexesInBox(grid, { + left: -padX, + top: -padY, + right: widthPx + padX, + bottom: heightPx + padY, + }); + } + + /** + * Returns the hexes a token covers: every hex whose centre lies under the + * token, plus the hex under its centre. + * + * @param {object} grid Grid object. + * @param {number} x Token centre x. + * @param {number} y Token centre y. + * @param {number} width Token width in pixels. + * @param {number} height Token height in pixels. + * @returns {number[][]} Array of [row, col], centre hex first. + */ + function hexesUnderToken(grid, x, y, width, height) { + const centre = pixelToHex(grid, x, y); + // Shrink slightly so a token that only touches a neighbour's centre does not claim it. + const halfW = Math.max(0, width / 2 - 2); + const halfH = Math.max(0, height / 2 - 2); + const covered = hexesInBox(grid, { + left: x - halfW, + top: y - halfH, + right: x + halfW, + bottom: y + halfH, + }); + const centreKey = hexKey(centre[0], centre[1]); + return [centre, ...covered.filter(([r, c]) => hexKey(r, c) !== centreKey)]; + } + + /** + * Derives a calibration from tokens the GM has snapped to hex centres. + * + * One token corrects the grid origin. Two tokens in neighbouring cells of the + * same row (Hex V) or column (Hex H) also correct the hex spacing, keeping the + * current ratio between column and row spacing. + * + * @param {object} grid Current grid object. + * @param {number[][]} points Token centres [[x, y], ...]. + * @returns {object|null} Calibration, or null when the points cannot be used. + */ + function calibrateGrid(grid, points) { + if (!Array.isArray(points) || points.length === 0) { + return null; + } + + let { colStep, rowStep } = grid; + if (points.length >= 2) { + const [a, b] = points; + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const along = vertical ? Math.abs(b[0] - a[0]) : Math.abs(b[1] - a[1]); + const across = vertical ? Math.abs(b[1] - a[1]) : Math.abs(b[0] - a[0]); + const currentStep = vertical ? colStep : rowStep; + const steps = Math.round(along / currentStep); + if (steps < 1 || across > currentStep / 4) { + return null; + } + const ratio = rowStep / colStep; + if (vertical) { + colStep = along / steps; + rowStep = colStep * ratio; + } else { + rowStep = along / steps; + colStep = rowStep / ratio; + } + } + + const scaled = { ...grid, colStep, rowStep }; + const [px, py] = points[0]; + const [row, col] = pixelToHex(scaled, px, py); + const [cx, cy] = hexToPixel(scaled, row, col); + const calibration = { + colStep, + rowStep, + originX: grid.originX + (px - cx), + originY: grid.originY + (py - cy), + }; + + // Keep the origin inside the first cell so offsets stay small and stable. + // Shifting by two rows/columns preserves the odd/even offset pattern. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const wrapX = vertical ? colStep : colStep * 2; + const wrapY = vertical ? rowStep * 2 : rowStep; + calibration.originX = ((calibration.originX % wrapX) + wrapX) % wrapX; + calibration.originY = ((calibration.originY % wrapY) + wrapY) % wrapY; + return calibration; + } + + const TRANSLATION$4 = { + titles: { + ready: 'Heeksplorasie is gereed.', + settings: 'Heksplorasie-instellings', + languages: "Kies 'n taal", + pageSettings: 'Bladsyinstellings: {page}', + status: 'Heksplorasiestatus: {page}', + help: 'Heksplorasie-opdragte', + confirm: 'Bevestig asseblief', + }, + discovery: { + title: 'Ligging ontdek', + }, + menu: { + draw: 'Teken', + reveal: 'Openbaar en versteek', + locations: 'Liggings', + tools: 'Gereedskap', + layerInUse: 'Nuwe hekse word op die {layer} geteken.', + pageSettingsHelp: + 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', + }, + buttons: { + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + undo: 'Ontdoen vul', + reveal: 'Onthul', + conceal: 'Versteek', + explore: 'Verken', + revealPage: 'Onthul bladsy', + resetPage: 'Stel bladsy terug', + mark: 'Merk ligging', + unmark: 'Ontmerk', + name: 'Noem Hex', + settings: 'Instellings', + pageSettings: 'Bladsy-instellings', + status: 'Status', + rescan: 'Skandeer weer', + calibrate: 'Kalibreer', + calibrateReset: 'Stel Kalibrasie terug', + help: 'Help', + change: 'Verander', + menu: 'Spyskaart', + clearOverrides: 'Vee oorskrywings uit', + confirmReset: 'Ja, verwyder alle hekse', + }, + prompts: { + name: 'Liggingnaam (laat leeg om skoon te maak)', + }, + values: { + on: 'Aan', + off: 'Af', + none: 'Geen', + hexLayer: { + auto: 'Outo (voorgrond indien beskikbaar)', + foreground: 'voorgrond laag', + objects: 'tekenlaag', + }, + revealBy: { + players: 'Speler tokens', + characters: 'Karaktertekens', + all: 'Alle tekens', + }, + revealMode: { + clear: 'Duidelik', + glimpse: 'Glimpie', + }, + announce: { + all: 'Almal', + gm: 'Slegs GM', + off: 'Af', + }, + orientation: { + vertical: 'Heks (V)', + horizontal: 'Heks (H)', + }, + fillKind: { + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + conceal: 'Versteek', + }, + }, + settings: { + language: { + label: 'Taal', + desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', + }, + hexLayer: { + label: 'Hex laag', + desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', + }, + fillColor: { + label: 'Vul kleur', + desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Rand Kleur', + desc: 'Kleur van die buitelyn van nuwe hekse.', + }, + labelColor: { + label: 'Etiket Kleur', + desc: 'Kleur van die GM-net naametikette op benoemde hekse.', + }, + glimpseColor: { + label: 'Glimp kleur', + desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + }, + strokeWidth: { + label: 'Grens breedte', + desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + }, + revealDistance: { + label: 'Sigafstand', + desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + }, + lineOfSight: { + label: 'Siglyn', + desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + }, + revealPath: { + label: 'Openbaar Langs Pad', + desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + }, + revealBy: { + label: 'Tekens wat openbaar', + desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + }, + revealMode: { + label: 'Onthullingsmodus', + desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + }, + announce: { + label: 'Kondig ontdekkings aan', + desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + }, + pingDiscoveries: { + label: 'Ping Ontdekkings', + desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + }, + }, + status: { + engine: 'Spel enjin', + grid: 'Rooster', + layer: 'Hex laag', + hexes: 'Hekse', + named: 'Benoemde hekse', + icons: 'Liggingtekens', + glimpsed: 'Geskimpte hekkies', + pending: "Liggings wat wag vir 'n vulling", + calibrated: 'Gekalibreer', + overrides: 'Bladsy ignoreer', + undo: 'Ontdoen beskikbaar', + }, + messages: { + filled: + 'Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.', + revealed: '{count} hekkies geopenbaar.', + revealedPage: 'Alle {count} hekse op die bladsy is geopenbaar.', + confirmReset: + 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: '{count} hekse van die bladsy verwyder.', + undone: + 'Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.', + named: '{count} heksies genaamd "{name}".', + unnamed: 'Naam verwyder van {count} hekse.', + marked: + '{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.', + unmarked: '{count} tekens is nie meer liggings nie.', + settingChanged: '{setting} gestel na {value}.', + rescanned: + "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + calibrated: + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + calibrationReset: + 'Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', + migrated: + "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + pruned: + '{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + readyHint: + 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + }, + warnings: { + foregroundUnavailable: + 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', + someFailed: + '{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.', + }, + errors: { + noPage: 'Kon nie die bladsy vind om aan te werk nie.', + notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + noPolygons: 'Kies een of meer getekende vorms om te vul.', + emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', + tooMany: 'Dit sal {count} hexes skep, wat te veel in een slag is.', + nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', + nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', + noTokens: 'Kies eers een of meer tekens.', + noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', + unknownCommand: 'Onbekende opdrag: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', + invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', + calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + unexpected: 'Iets het verkeerd geloop: {message}', + }, + hints: { + noPage: 'Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.', + notHex: 'Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.', + noPolygons: + "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", + emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", + tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', + noHexes: + 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + unknownCommand: 'Tik !hexploration help om die opdragte te lys.', + unknownSetting: 'Tik !hexploration set om elke instelling te sien.', + calibrateNeedsTokens: + "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + calibrateFailed: + 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + unexpected: 'Besonderhede is in die API-konsole-logboek.', + }, + help: { + menu: 'Wys die spyskaart.', + fill: 'Bedek die geselekteerde getekende vorms met hekse.', + fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', + undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', + reveal: + 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', + revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', + conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', + explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', + resetPage: 'Verwyder elke heks op die bladsy (vra eers).', + name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', + mark: 'Verander die geselekteerde tekens in versteekte liggings.', + unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', + set: "Verander 'n instelling, of wys alle instellings.", + pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se ignorering.', + rescan: + "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + calibrate: + 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', + status: 'Wys wat Hexploration van die huidige bladsy weet.', + journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + help: 'Wys hierdie lys.', + handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', + }, + deck: { + subtitle: 'Beveldek', + drawDesc: + "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + revealDesc: + 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', + locationsDesc: + "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + toolsDesc: + 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', + footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', + }, + handout: { + versionLabel: 'Weergawe', + subtitle: 'Heks-vir-heks verkenning vir Roll20', + footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', + overview: { + heading: 'Oorsig', + body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", + }, + quickStart: { + heading: 'Vinnige Begin', + steps: [ + "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", + 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', + 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', + 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + ], + }, + commands: { + heading: 'Opdragte', + intro: + "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", + colCommand: 'Bevel', + colDesc: 'Wat dit doen', + }, + revealing: { + heading: 'Hoe onthulling werk', + points: [ + 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", + "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", + "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", + "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + ], + }, + locations: { + heading: 'Genoemde hekse en liggings', + points: [ + "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", + 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', + "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + ], + }, + settings: { + heading: 'Instellings', + intro: + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beskrywing', + perPage: '(Kan per bladsy gestel word.)', + }, + jumpgate: { + heading: 'Jumpgate en Legacy', + points: [ + 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', + 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', + "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + ], + }, + upgrading: { + heading: 'Opgradering vanaf weergawe 1', + points: [ + "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", + 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', + "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + ], + colV1: 'Weergawe 1 opdrag', + colV2: 'Weergawe 2 opdrag', + }, + troubleshooting: { + heading: 'Probleemoplossing', + points: [ + "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", + "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", + "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", + 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', + ], + }, + languages: { + heading: 'Tale', + body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + }, + credits: { + heading: 'Krediete', + original: 'Oorspronklike mod deur', + maintainer: 'Weergawe 2 onderhou deur', + marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', + support: + "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: "L'exploració està a punt.", + settings: "Configuració d'exploració", + languages: 'Trieu un idioma', + pageSettings: 'Configuració de la pàgina: {page}', + status: "Estat de l'exploració: {page}", + help: "Comandes d'exploració", + confirm: 'Si us plau, confirmeu', + }, + discovery: { + title: 'Localització descoberta', + }, + menu: { + draw: 'Dibuixa', + reveal: 'Revela i amaga', + locations: 'Ubicacions', + tools: 'Eines', + layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + pageSettingsHelp: + "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", + }, + buttons: { + fill: 'Omplir', + fillInverse: 'Farciment invers', + undo: 'Desfer el farciment', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explora', + revealPage: 'Revela la pàgina', + resetPage: 'Restableix la pàgina', + mark: 'Marca la ubicació', + unmark: 'Desmarca', + name: 'Nom Hex', + settings: 'Configuració', + pageSettings: 'Configuració de la pàgina', + status: 'Estat', + rescan: 'Torna a escanejar', + calibrate: 'Calibrar', + calibrateReset: 'Restableix la calibració', + help: 'Ajuda', + change: 'Canviar', + menu: 'Menú', + clearOverrides: 'Esborra les substitucions', + confirmReset: 'Sí, traieu tots els hexagones', + }, + prompts: { + name: 'Nom de la ubicació (deixeu en blanc per esborrar)', + }, + values: { + on: 'Encès', + off: 'Apagat', + none: 'Cap', + hexLayer: { + auto: 'Automàtic (en primer pla si està disponible)', + foreground: 'capa de primer pla', + objects: 'capa de testimoni', + }, + revealBy: { + players: 'Fitxes de jugador', + characters: 'Fitxes de personatges', + all: 'Totes les fitxes', + }, + revealMode: { + clear: 'Clar', + glimpse: "Un cop d'ull", + }, + announce: { + all: 'Tothom', + gm: 'Només GM', + off: 'Apagat', + }, + orientation: { + vertical: 'Hexadecimal (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Omplir', + fillInverse: 'Farciment invers', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Llengua', + desc: 'Idioma per a menús, missatges i fullets.', + }, + hexLayer: { + label: 'Capa hexagonal', + desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + }, + fillColor: { + label: 'Color de farciment', + desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color de la vora', + desc: 'Color del contorn dels nous hexagonals.', + }, + labelColor: { + label: "Color de l'etiqueta", + desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', + }, + glimpseColor: { + label: "Color d'ull", + desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', + }, + strokeWidth: { + label: 'Amplada de la vora', + desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', + }, + maxDistance: { + label: 'Distància de revelació hexagonal', + desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", + }, + revealDistance: { + label: 'Distància de visió', + desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + }, + lineOfSight: { + label: 'Línia de visió', + desc: 'Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.', + }, + revealPath: { + label: 'Revela al llarg del camí', + desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + }, + revealBy: { + label: 'Fitxes que revelen', + desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + }, + revealMode: { + label: 'Mode de revelació', + desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + }, + announce: { + label: 'Anunciar descobriments', + desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', + }, + pingDiscoveries: { + label: 'Ping Descobriments', + desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', + }, + }, + status: { + engine: 'Motor de joc', + grid: 'Quadrícula', + layer: 'Capa hexagonal', + hexes: 'Hexes', + named: 'Hexagones anomenats', + icons: "Fitxes d'ubicació", + glimpsed: 'Hexagones albirats', + pending: "Ubicacions a l'espera d'omplir-se", + calibrated: 'Calibrat', + overrides: 'Anul·lació de la pàgina', + undo: 'Desfer disponible', + }, + messages: { + filled: + 'Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.', + revealed: '{count} hexadecimals revelats.', + revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + confirmReset: + 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: '{count} hexadecimals eliminats de la pàgina.', + undone: + 'Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.', + named: '{count} hexadecimals anomenats "{name}".', + unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + marked: + "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", + unmarked: 'Les fitxes {count} ja no són ubicacions.', + settingChanged: "{setting} s'ha establert en {value}.", + rescanned: + "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + calibrated: + 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.', + calibrationReset: + "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', + migrated: + "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + pruned: + "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + readyHint: + 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + }, + warnings: { + foregroundUnavailable: + 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + someFailed: + "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + }, + errors: { + noPage: "No s'ha pogut trobar la pàgina per treballar.", + notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', + emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", + tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", + nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', + nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer un o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToUndo: 'No hi ha cap emplenament per desfer.', + unknownCommand: 'Ordre desconeguda: {command}', + unknownSetting: 'Configuració desconeguda: {key}', + unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', + invalidValue: '"{value}" no és un valor vàlid per a {key}.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', + unexpected: "S'ha produït un error: {message}", + }, + hints: { + noPage: 'Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.', + notHex: + 'Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.', + noPolygons: + "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", + emptyArea: + 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', + tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", + noHexes: + 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', + unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', + calibrateNeedsTokens: + "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + calibrateFailed: + "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + unexpected: "Els detalls es troben al registre de la consola de l'API.", + }, + help: { + menu: 'Mostra el menú.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', + undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + reveal: + 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + mark: 'Converteix les fitxes seleccionades en llocs ocults.', + unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + set: 'Canvia un paràmetre o mostra tots els paràmetres.', + pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', + pageClear: 'Elimina les substitucions de la pàgina actual.', + rescan: + 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', + calibrate: + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + calibrateReset: 'Elimineu el calibratge de la pàgina actual.', + status: 'Mostra què sap Hexploration sobre la pàgina actual.', + journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + help: 'Mostra aquesta llista.', + handout: 'Les instruccions completes es troben al fullet "{name}".', + }, + deck: { + subtitle: 'Comandament de la plataforma', + drawDesc: + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + revealDesc: + "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + locationsDesc: + 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', + toolsDesc: + 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', + footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', + }, + handout: { + versionLabel: 'Versió', + subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', + footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', + overview: { + heading: 'Visió general', + body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + demo: 'Mira una petita demostració (de la versió 1)', + }, + quickStart: { + heading: 'Inici ràpid', + steps: [ + 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', + "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", + "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", + 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', + ], + }, + commands: { + heading: 'Ordres', + intro: + 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', + colCommand: 'Comandament', + colDesc: 'Què fa', + }, + revealing: { + heading: 'Com funciona la revelació', + points: [ + 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", + "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", + "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + ], + }, + locations: { + heading: 'Hexes i ubicacions anomenades', + points: [ + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", + "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", + "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + ], + }, + settings: { + heading: 'Configuració', + intro: + "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + colKey: 'clau', + colName: 'Configuració', + colDesc: 'Descripció', + perPage: '(Es pot configurar per pàgina.)', + }, + jumpgate: { + heading: 'Jumpgate i Legacy', + points: [ + 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', + "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", + "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + ], + }, + upgrading: { + heading: 'Actualització de la versió 1', + points: [ + 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', + "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', + ], + colV1: 'Comandament de la versió 1', + colV2: 'Comandament de la versió 2', + }, + troubleshooting: { + heading: 'Resolució de problemes', + points: [ + 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', + 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', + 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', + "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", + ], + }, + languages: { + heading: 'Idiomes', + body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + }, + credits: { + heading: 'Crèdits', + original: 'Mod original de', + maintainer: 'Versió 2 mantinguda per', + marketplace: "Els paquets d'art de l'Ada al mercat Roll20", + support: + "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'H探索已準備就緒。', + settings: 'H探索設置', + languages: '選擇語言', + pageSettings: '頁面設定：{page}', + status: 'H探索狀態：{page}', + help: '探索命令', + confirm: '請確認', + }, + discovery: { + title: '發現地點', + }, + menu: { + draw: '畫', + reveal: '顯示和隱藏', + locations: '地點', + tools: '工具', + layerInUse: '正在 {layer} 上繪製新的六角形。', + pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', + }, + buttons: { + fill: '充滿', + fillInverse: '反向填充', + undo: '撤銷填充', + reveal: '揭示', + conceal: '隱藏', + explore: '探索', + revealPage: '顯示頁面', + resetPage: '重置頁面', + mark: '標記位置', + unmark: '取消標記', + name: '名稱十六進位', + settings: '設定', + pageSettings: '頁面設定', + status: '地位', + rescan: '重新掃描', + calibrate: '校準', + calibrateReset: '重置校準', + help: '幫助', + change: '改變', + menu: '選單', + clearOverrides: '清除覆蓋', + confirmReset: '是的，刪除所有六角形', + }, + prompts: { + name: '地點名稱（留空以清除）', + }, + values: { + on: '在', + off: '離開', + none: '沒有任何', + hexLayer: { + auto: '自動（前景，如果可用）', + foreground: '前景層', + objects: '令牌層', + }, + revealBy: { + players: '玩家代幣', + characters: 'Character tokens', + all: '所有代幣', + }, + revealMode: { + clear: '清除', + glimpse: '一瞥', + }, + announce: { + all: '每個人', + gm: '限通用汽車', + off: '離開', + }, + orientation: { + vertical: '六角 (V)', + horizontal: '六角 (H)', + }, + fillKind: { + fill: '充滿', + fillInverse: '反向填充', + conceal: '隱藏', + }, + }, + settings: { + language: { + label: '語言', + desc: '選單、訊息和講義的語言。', + }, + hexLayer: { + label: '六角層', + desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + }, + fillColor: { + label: '填充顏色', + desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', + }, + strokeColor: { + label: '邊框顏色', + desc: '新六邊形輪廓的顏色。', + }, + labelColor: { + label: '標籤顏色', + desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + }, + glimpseColor: { + label: '瞥見顏色', + desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', + }, + strokeWidth: { + label: '邊框寬度', + desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + }, + maxDistance: { + label: '十六進位顯示距離', + desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', + }, + revealDistance: { + label: '視距', + desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + }, + lineOfSight: { + label: '視線', + desc: '啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。', + }, + revealPath: { + label: '沿路徑顯示', + desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + }, + revealBy: { + label: '揭示的代幣', + desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', + }, + revealMode: { + label: '揭示模式', + desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', + }, + announce: { + label: '宣布發現', + desc: '當發現指定位置時誰會看到聊天訊息。', + }, + pingDiscoveries: { + label: '平發現', + desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + }, + }, + status: { + engine: '遊戲引擎', + grid: '網格', + layer: '六角層', + hexes: '六角形', + named: '命名六角形', + icons: '位置標記', + glimpsed: '瞥見的六角形', + pending: '等待填補的地點', + calibrated: '已校準', + overrides: '頁面覆蓋', + undo: '可以撤銷', + }, + messages: { + filled: '填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。', + revealed: '{count} 十六進位顯示。', + revealedPage: '顯示頁面上的所有 {count} 十六進位。', + confirmReset: + '從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。', + resetPage: '從頁面中刪除了 {count} 十六進位。', + undone: '上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。', + named: '{count} 名為「{name}」的十六進位。', + unnamed: '從 {count} 十六進位清除名稱。', + marked: '{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。', + unmarked: '{count} 標記不再是位置。', + settingChanged: '{setting} 設定為 {value}。', + rescanned: + '重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_', + calibrated: + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', + calibrationReset: '校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', + pruned: + '{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', + readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', + }, + warnings: { + foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', + someFailed: '無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。', + }, + errors: { + noPage: '找不到要處理的頁面。', + notHex: '此頁面不使用六角網格。', + noPolygons: '選擇一個或多個要填滿的繪製形狀。', + emptyArea: '所選區域不包含任何六角形中心。', + tooMany: '這會建立 {count} 六角形，一次性就太多了。', + nothingToConceal: '選擇要隱藏的繪製形狀或標記。', + nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + noTokens: '首先選擇一個或多個令牌。', + noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + nothingToUndo: '沒有可撤消的填充。', + unknownCommand: '未知指令：{command}', + unknownSetting: '未知設定：{key}', + unknownPageSetting: '每頁可設定的設定：{keys}', + invalidValue: '“{value}”對於 {key} 不是有效值。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateFailed: '這些令牌不能用於校準。', + unexpected: '出了點問題：{message}', + }, + hints: { + noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', + notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', + emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', + tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', + noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + unknownCommand: '鍵入 !hexploration help 以列出指令。', + unknownSetting: '輸入 !hexploration set 查看每個設定。', + calibrateNeedsTokens: + '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + unexpected: '詳細資訊位於 API 控制台日誌中。', + }, + help: { + menu: '顯示選單。', + fill: '用六角形覆蓋選定的繪製形狀。', + fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + revealPage: '顯示頁面上的每個十六進制，無需公告。', + conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', + explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', + mark: '將選取的標記變成隱藏位置。', + unmark: '停止將選定的標記隱藏在位置。', + set: '更改設定或顯示所有設定。', + pageSet: '僅覆蓋目前頁面上的顯示設定。', + pageClear: '刪除目前頁面的覆蓋。', + rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrateReset: '刪除目前頁面的校準。', + status: '顯示 Hexploration 對目前頁面的了解。', + journal: '重建幫助和命令平台講義。', + help: '顯示此清單。', + handout: '完整說明位於「{name}」講義。', + }, + deck: { + subtitle: '指揮台', + drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', + revealDesc: + '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', + footer: '有關完整說明，請參閱“{help}”講義。', + }, + handout: { + versionLabel: '版本', + subtitle: 'Roll20 的逐十六進位探索', + footer: '使用“{deck}”講義進行一鍵式控制項。', + overview: { + heading: '概述', + body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + demo: '觀看簡短的演示（來自版本 1）', + }, + quickStart: { + heading: '快速入門', + steps: [ + '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', + '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', + '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + ], + }, + commands: { + heading: '命令', + intro: + '只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。', + colCommand: '命令', + colDesc: '它的作用', + }, + revealing: { + heading: '揭示如何運作', + points: [ + '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', + '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', + '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + ], + }, + locations: { + heading: '命名六角形和位置', + points: [ + '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', + 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', + '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', + ], + }, + settings: { + heading: '設定', + intro: + '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + colKey: '鑰匙', + colName: '環境', + colDesc: '描述', + perPage: '（可按頁設定。）', + }, + jumpgate: { + heading: '跳躍門和遺產', + points: [ + 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', + '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', + 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + ], + }, + upgrading: { + heading: '從版本 1 升級', + points: [ + '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', + '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', + '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', + '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', + ], + colV1: '版本 1 指令', + colV2: '版本 2 指令', + }, + troubleshooting: { + heading: '故障排除', + points: [ + '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: '語言', + body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + }, + credits: { + heading: '製作人員', + original: '原始模組由', + maintainer: '版本 2 維護者', + marketplace: 'Roll20 Marketplace 上的 Ada 藝術包', + support: + '如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Heexploration je připraven.', + settings: 'Nastavení Heexploration', + languages: 'Vyberte jazyk', + pageSettings: 'Nastavení stránky: {page}', + status: 'Stav průzkumu: {page}', + help: 'Příkazy pro průzkum', + confirm: 'Prosím potvrďte', + }, + discovery: { + title: 'Místo objeveno', + }, + menu: { + draw: 'Remíza', + reveal: 'Odhalit a skrýt', + locations: 'Místa', + tools: 'Nástroje', + layerInUse: 'Na {layer} se kreslí nové hexy.', + pageSettingsHelp: + 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', + }, + buttons: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + undo: 'Vrátit zpět výplň', + reveal: 'Odhalit', + conceal: 'Skrývat', + explore: 'Prozkoumat', + revealPage: 'Odhalit stránku', + resetPage: 'Obnovit stránku', + mark: 'Označte umístění', + unmark: 'Zrušit označení', + name: 'Jméno Hex', + settings: 'Nastavení', + pageSettings: 'Nastavení stránky', + status: 'Postavení', + rescan: 'Znovu naskenujte', + calibrate: 'Kalibrovat', + calibrateReset: 'Resetovat kalibraci', + help: 'Pomoc', + change: 'Přeměna', + menu: 'Menu', + clearOverrides: 'Vymazat přepisy', + confirmReset: 'Ano, Odebrat všechny hexy', + }, + prompts: { + name: 'Název místa (pro vymazání ponechte prázdné)', + }, + values: { + on: 'Na', + off: 'Vypnuto', + none: 'Žádný', + hexLayer: { + auto: 'Auto (popředí, pokud je k dispozici)', + foreground: 'vrstva popředí', + objects: 'vrstva tokenů', + }, + revealBy: { + players: 'Hráčské žetony', + characters: 'Žetony postav', + all: 'Všechny tokeny', + }, + revealMode: { + clear: 'Jasný', + glimpse: 'Záblesk', + }, + announce: { + all: 'Každý', + gm: 'Pouze GM', + off: 'Vypnuto', + }, + orientation: { + vertical: 'Hexadecimální (V)', + horizontal: 'Hexadecimální (H)', + }, + fillKind: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + conceal: 'Skrývat', + }, + }, + settings: { + language: { + label: 'Jazyk', + desc: 'Jazyk pro nabídky, zprávy a letáky.', + }, + hexLayer: { + label: 'Hexadecimální vrstva', + desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', + }, + fillColor: { + label: 'Barva výplně', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Barva ohraničení', + desc: 'Barva obrysu nových hexů.', + }, + labelColor: { + label: 'Barva štítku', + desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', + }, + glimpseColor: { + label: 'Barva záblesku', + desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', + }, + strokeWidth: { + label: 'Šířka okraje', + desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', + }, + maxDistance: { + label: 'Hexadecimální vzdálenost odhalení', + desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', + }, + revealDistance: { + label: 'Pohledová vzdálenost', + desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', + }, + lineOfSight: { + label: 'Zornost', + desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', + }, + revealPath: { + label: 'Odhalení Po cestě', + desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', + }, + revealBy: { + label: 'Tokeny, které odhalují', + desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', + }, + revealMode: { + label: 'Režim odhalení', + desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', + }, + announce: { + label: 'Oznamte objevy', + desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', + }, + pingDiscoveries: { + label: 'Ping Discovery', + desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', + }, + }, + status: { + engine: 'Herní engine', + grid: 'Mřížka', + layer: 'Hexadecimální vrstva', + hexes: 'Hexy', + named: 'Pojmenované hexy', + icons: 'Tokeny polohy', + glimpsed: 'Zahlédnuté hexy', + pending: 'Místa čekající na zaplnění', + calibrated: 'Zkalibrováno', + overrides: 'Přepíše stránku', + undo: 'Zpět k dispozici', + }, + messages: { + filled: + 'Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.', + revealed: '{count} odhalených hexů.', + revealedPage: 'Všechny {count} hexy na stránce odhaleny.', + confirmReset: + 'Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: '{count} hexy odstraněny ze stránky.', + undone: + 'Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.', + named: '{count} hexy s názvem „{name}“.', + unnamed: 'Název byl vymazán z {count} hexů.', + marked: + '{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.', + unmarked: '{count} tokeny již nejsou umístění.', + settingChanged: '{setting} nastaveno na {value}.', + rescanned: + 'Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.', + calibrated: + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + calibrationReset: + 'Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', + migrated: + 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', + pruned: + '{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + readyHint: + 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', + }, + warnings: { + foregroundUnavailable: + 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', + someFailed: '{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.', + }, + errors: { + noPage: 'Nelze najít stránku, na které by se dalo pracovat.', + notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + tooMany: 'To by vytvořilo {count} hexů, což je příliš mnoho najednou.', + nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', + nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', + noTokens: 'Nejprve vyberte jeden nebo více žetonů.', + noHexes: 'Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).', + nothingToUndo: 'Neexistuje žádná výplň, kterou lze vrátit zpět.', + unknownCommand: 'Neznámý příkaz: {command}', + unknownSetting: 'Neznámé nastavení: {key}', + unknownPageSetting: 'Nastavení, která lze nastavit na stránce: {keys}', + invalidValue: '„{value}“ není platná hodnota pro {key}.', + calibrateNeedsTokens: 'Vyberte jeden nebo dva žetony přichycené na středy hexů.', + calibrateFailed: 'Tyto tokeny nelze použít ke kalibraci.', + unexpected: 'Něco se pokazilo: {message}', + }, + hints: { + noPage: 'Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.', + notHex: 'Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.', + noPolygons: + 'Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.', + emptyArea: 'Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.', + tooMany: 'Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.', + noHexes: 'Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.', + unknownCommand: 'Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.', + unknownSetting: 'Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.', + calibrateNeedsTokens: + 'Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.', + calibrateFailed: + 'Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.', + unexpected: 'Podrobnosti jsou v protokolu konzoly API.', + }, + help: { + menu: 'Ukaž menu.', + fill: 'Zakryjte vybrané nakreslené tvary hexy.', + fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', + undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', + reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', + revealPage: 'Odhalte každé hex na stránce bez oznámení.', + conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', + explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', + resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', + name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', + mark: 'Proměňte vybrané žetony na skrytá místa.', + unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + set: 'Změňte nastavení nebo zobrazte všechna nastavení.', + pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', + pageClear: 'Odstraňte přepsání aktuální stránky.', + rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + calibrate: + 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', + calibrateReset: 'Odstraňte kalibraci aktuální stránky.', + status: 'Ukažte, co Heexploration ví o aktuální stránce.', + journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + help: 'Zobrazit tento seznam.', + handout: 'Úplné pokyny jsou v letáku „{name}“.', + }, + deck: { + subtitle: 'Velitelský balíček', + drawDesc: + 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', + revealDesc: + 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', + locationsDesc: + 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', + toolsDesc: + 'Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.', + footer: 'Úplné pokyny naleznete v letáku „{help}“.', + }, + handout: { + versionLabel: 'Verze', + subtitle: 'Průzkum hex po hexu pro Roll20', + footer: 'Pro ovládání jedním kliknutím použijte leták „{deck}“.', + overview: { + heading: 'Přehled', + body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', + demo: 'Podívejte se na krátkou ukázku (od verze 1)', + }, + quickStart: { + heading: 'Rychlý start', + steps: [ + 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', + 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', + 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', + ], + }, + commands: { + heading: 'Příkazy', + intro: + 'Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.', + colCommand: 'Příkaz', + colDesc: 'Co to dělá', + }, + revealing: { + heading: 'Jak funguje odhalování', + points: [ + 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', + 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', + 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', + 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + ], + }, + locations: { + heading: 'Pojmenované hexy a umístění', + points: [ + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', + 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', + 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', + 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', + ], + }, + settings: { + heading: 'Nastavení', + intro: + 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + colKey: 'Klíč', + colName: 'Nastavení', + colDesc: 'Popis', + perPage: '(Lze nastavit na stránku.)', + }, + jumpgate: { + heading: 'Jumpgate a Legacy', + points: [ + 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', + 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', + ], + }, + upgrading: { + heading: 'Upgrade z verze 1', + points: [ + 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', + 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', + 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', + 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', + ], + colV1: 'Příkaz verze 1', + colV2: 'Příkaz verze 2', + }, + troubleshooting: { + heading: 'Odstraňování problémů', + points: [ + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', + 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', + ], + }, + languages: { + heading: 'Jazyky', + body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + }, + credits: { + heading: 'Kredity', + original: 'Původní mod od', + maintainer: 'Verze 2 spravovaná společností', + marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', + support: + 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration er klar.', + settings: 'Indstillinger for Hexploration', + languages: 'Vælg et sprog', + pageSettings: 'Sideindstillinger: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandoer', + confirm: 'Bekræft venligst', + }, + discovery: { + title: 'Sted opdaget', + }, + menu: { + draw: 'Tegne', + reveal: 'Afsløre og skjul', + locations: 'Steder', + tools: 'Værktøjer', + layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', + pageSettingsHelp: + 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', + }, + buttons: { + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + undo: 'Fortryd Fyld', + reveal: 'Afsløre', + conceal: 'Skjule', + explore: 'Udforske', + revealPage: 'Afsløre side', + resetPage: 'Nulstil side', + mark: 'Marker placering', + unmark: 'Fjern markering', + name: 'Navn Hex', + settings: 'Indstillinger', + pageSettings: 'Sideindstillinger', + status: 'Status', + rescan: 'Scan igen', + calibrate: 'Kalibrer', + calibrateReset: 'Nulstil kalibrering', + help: 'Hjælp', + change: 'Forandring', + menu: 'Menu', + clearOverrides: 'Ryd tilsidesættelser', + confirmReset: 'Ja, Fjern alle Hexes', + }, + prompts: { + name: 'Placeringsnavn (lad tom for at rydde)', + }, + values: { + on: 'På', + off: 'Slukket', + none: 'Ingen', + hexLayer: { + auto: 'Auto (forgrund, hvis tilgængelig)', + foreground: 'forgrundslaget', + objects: 'symbollag', + }, + revealBy: { + players: 'Spillerpoletter', + characters: 'Karakter tokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Klar', + glimpse: 'Glimt', + }, + announce: { + all: 'Alle sammen', + gm: 'Kun GM', + off: 'Slukket', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + conceal: 'Skjule', + }, + }, + settings: { + language: { + label: 'Sprog', + desc: 'Sprog til menuer, beskeder og uddelingskopier.', + }, + hexLayer: { + label: 'Hex lag', + desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + }, + fillColor: { + label: 'Fyld farve', + desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfarve', + desc: 'Farve på omridset af nye sekskanter.', + }, + labelColor: { + label: 'Etiket farve', + desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + }, + glimpseColor: { + label: 'Glimt farve', + desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', + }, + strokeWidth: { + label: 'Border Bredde', + desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', + }, + revealDistance: { + label: 'Synsafstand', + desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + }, + lineOfSight: { + label: 'Synslinie', + desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', + }, + revealPath: { + label: 'Afsløre langs stien', + desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + }, + revealBy: { + label: 'Tokens, der afslører', + desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', + }, + announce: { + label: 'Annoncer opdagelser', + desc: 'Hvem ser chatbeskeden, når en navngivet placering opdages.', + }, + pingDiscoveries: { + label: 'Ping opdagelser', + desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', + }, + }, + status: { + engine: 'Spil motor', + grid: 'Gitter', + layer: 'Hex lag', + hexes: 'Hekser', + named: 'Navngivne hexes', + icons: 'Placeringstokens', + glimpsed: 'Glimpede sekskanter', + pending: 'Steder, der venter på udfyldning', + calibrated: 'Kalibreret', + overrides: 'Side tilsidesætter', + undo: 'Fortryd tilgængelig', + }, + messages: { + filled: + 'Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.', + revealed: '{count} hexes afsløret.', + revealedPage: 'Alle {count} hexes på siden afsløret.', + confirmReset: + 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: '{count} sekskanter fjernet fra siden.', + undone: + 'Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.', + named: '{count} hexes med navnet "{name}".', + unnamed: 'Navnet er ryddet fra {count} hexes.', + marked: + '{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.', + unmarked: '{count} tokens er ikke længere placeringer.', + settingChanged: '{setting} indstillet til {value}.', + rescanned: + 'Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.', + calibrated: + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.', + calibrationReset: + 'Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.', + journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + migrated: + 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', + pruned: + '{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + readyHint: + 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + }, + warnings: { + foregroundUnavailable: + 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', + someFailed: '{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.', + }, + errors: { + noPage: 'Kunne ikke finde siden at arbejde på.', + notHex: 'Denne side bruger ikke et hex-gitter.', + noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', + emptyArea: 'Det valgte område indeholder ingen hex-centre.', + tooMany: 'Det ville skabe {count} hexes, hvilket er for mange på én gang.', + nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', + nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + noTokens: 'Vælg først et eller flere tokens.', + noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + nothingToUndo: 'Der er ingen udfyldning at fortryde.', + unknownCommand: 'Ukendt kommando: {command}', + unknownSetting: 'Ukendt indstilling: {key}', + unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', + invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', + unexpected: 'Noget gik galt: {message}', + }, + hints: { + noPage: 'Åbn den side, du vil arbejde på, eller vælg noget på den.', + notHex: 'Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.', + noPolygons: + 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', + emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', + tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', + noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', + unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', + calibrateNeedsTokens: + 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + calibrateFailed: + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + unexpected: 'Detaljer er i API-konsolloggen.', + }, + help: { + menu: 'Vis menuen.', + fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', + undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', + reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', + revealPage: 'Afslør hver hex på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', + resetPage: 'Fjern hver hex på siden (spørg først).', + name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + mark: 'Gør de valgte tokens til skjulte placeringer.', + unmark: 'Stop de valgte tokens med at være skjulte placeringer.', + set: 'Skift en indstilling, eller vis alle indstillinger.', + pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', + pageClear: 'Fjern den aktuelle sides tilsidesættelser.', + rescan: + 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + calibrate: + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + calibrateReset: 'Fjern den aktuelle sides kalibrering.', + status: 'Vis, hvad Hexploration ved om den aktuelle side.', + journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + help: 'Vis denne liste.', + handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', + }, + deck: { + subtitle: 'Kommandodæk', + drawDesc: + 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', + revealDesc: + 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', + locationsDesc: + 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + toolsDesc: + 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', + footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-udforskning for Roll20', + footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + overview: { + heading: 'Oversigt', + body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + demo: 'Se en kort demo (fra version 1)', + }, + quickStart: { + heading: 'Hurtig start', + steps: [ + 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', + 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', + 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', + 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', + 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', + ], + }, + commands: { + heading: 'Kommandoer', + intro: + "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", + colCommand: 'Kommando', + colDesc: 'Hvad den gør', + }, + revealing: { + heading: 'Sådan fungerer afsløring', + points: [ + 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', + 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', + 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', + 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + ], + }, + locations: { + heading: 'Navngivne Hekser og Steder', + points: [ + 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', + 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', + ], + }, + settings: { + heading: 'Indstillinger', + intro: + "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + colKey: 'Nøgle', + colName: 'Indstilling', + colDesc: 'Beskrivelse', + perPage: '(Kan indstilles pr. side.)', + }, + jumpgate: { + heading: 'Jumpgate og Legacy', + points: [ + 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', + 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + ], + }, + upgrading: { + heading: 'Opgradering fra version 1', + points: [ + 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', + 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', + 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', + ], + colV1: 'Version 1 kommando', + colV2: 'Version 2 kommando', + }, + troubleshooting: { + heading: 'Fejlfinding', + points: [ + 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', + 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', + 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', + 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', + ], + }, + languages: { + heading: 'Sprog', + body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + }, + credits: { + heading: 'Credits', + original: 'Original mod af', + maintainer: 'Version 2 vedligeholdes af', + marketplace: 'Adas kunstpakker på Roll20 Marketplace', + support: + 'Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.', + }, + }, + }; + + var localeNl = {}; + + var localeEnUS = { + titles: { + ready: 'Hexploration is ready.', + settings: 'Hexploration Settings', + languages: 'Choose a Language', + pageSettings: 'Page Settings: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration Commands', + confirm: 'Please Confirm', + }, + discovery: { + title: 'Location Discovered', + }, + menu: { + draw: 'Draw', + reveal: 'Reveal and Hide', + locations: 'Locations', + tools: 'Tools', + layerInUse: 'New hexes are being drawn on the {layer}.', + pageSettingsHelp: + 'These settings apply to this page only. Settings marked ★ override the global settings.', + }, + buttons: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + undo: 'Undo Fill', + reveal: 'Reveal', + conceal: 'Conceal', + explore: 'Explore', + revealPage: 'Reveal Page', + resetPage: 'Reset Page', + mark: 'Mark Location', + unmark: 'Unmark', + name: 'Name Hex', + settings: 'Settings', + pageSettings: 'Page Settings', + status: 'Status', + rescan: 'Rescan', + calibrate: 'Calibrate', + calibrateReset: 'Reset Calibration', + help: 'Help', + change: 'Change', + menu: 'Menu', + clearOverrides: 'Clear Overrides', + confirmReset: 'Yes, Remove All Hexes', + }, + prompts: { + name: 'Location name (leave empty to clear)', + }, + values: { + on: 'On', + off: 'Off', + none: 'None', + hexLayer: { + auto: 'Auto (foreground if available)', + foreground: 'foreground layer', + objects: 'token layer', + }, + revealBy: { + players: 'Player tokens', + characters: 'Character tokens', + all: 'All tokens', + }, + revealMode: { + clear: 'Clear', + glimpse: 'Glimpse', + }, + announce: { + all: 'Everyone', + gm: 'GM only', + off: 'Off', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + conceal: 'Conceal', + }, + }, + settings: { + language: { + label: 'Language', + desc: 'Language for menus, messages and handouts.', + }, + hexLayer: { + label: 'Hex Layer', + desc: 'Where new hexes are drawn. Auto tries the foreground layer (above tokens) and falls back to the token layer if the game does not support it.', + }, + fillColor: { + label: 'Fill Colour', + desc: 'Colour of new hexes. Use rgba() for see-through hexes, for example rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Border Colour', + desc: 'Colour of the outline of new hexes.', + }, + labelColor: { + label: 'Label Colour', + desc: 'Colour of the GM-only name labels on named hexes.', + }, + glimpseColor: { + label: 'Glimpse Colour', + desc: 'Colour hexes change to when glimpsed (Glimpse reveal mode). Use a see-through rgba() colour.', + }, + strokeWidth: { + label: 'Border Width', + desc: 'Width of the outline of new hexes, in pixels (0 to 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Applied to hexes as they are drawn: a token must be within this many hexes to reveal them, however far it can see. Leave empty for no limit.', + }, + revealDistance: { + label: 'Sight Distance', + desc: 'How many hexes around a moving token are revealed (0 to 20). 0 reveals only the hexes the token passes through.', + }, + lineOfSight: { + label: 'Line of Sight', + desc: 'When on, a hex is only revealed if no covered hex lies between it and the token.', + }, + revealPath: { + label: 'Reveal Along Path', + desc: 'When on, every hex a token passes through while being dragged (including waypoints) is revealed, not just where it stops.', + }, + revealBy: { + label: 'Tokens That Reveal', + desc: 'Which tokens on the token layer reveal hexes: tokens controlled by a player, tokens that represent any character, or every token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear removes hexes within sight. Glimpse makes them see-through instead; they are removed when a token enters them.', + }, + announce: { + label: 'Announce Discoveries', + desc: 'Who sees the chat message when a named location is discovered.', + }, + pingDiscoveries: { + label: 'Ping Discoveries', + desc: 'When on, players are pinged to a named location when it is discovered.', + }, + hideCoveredTokens: { + label: 'Hide Covered Tokens', + desc: 'Roll20 draws names, bars and auras above hexes. When on, tokens under a covered hex have their player-visible name, bars and auras switched off, and switched back on when they are uncovered.', + }, + }, + status: { + engine: 'Game engine', + grid: 'Grid', + layer: 'Hex layer', + hexes: 'Hexes', + named: 'Named hexes', + icons: 'Location tokens', + glimpsed: 'Glimpsed hexes', + pending: 'Locations waiting for a fill', + calibrated: 'Calibrated', + overrides: 'Page overrides', + undo: 'Undo available', + }, + messages: { + filled: + 'Fill complete. Hexes drawn: {created}. Restyled: {restyled}. Locations hidden: {icons}.', + revealed: 'Hexes revealed: {count}.', + revealedPage: 'Every hex on the page revealed ({count}).', + confirmReset: + 'Remove every hex from "{page}" ({count})? Location tokens return to the token layer. Undo cannot reverse this.', + resetPage: 'Hexes removed from the page: {count}.', + undone: 'Last fill undone. Hexes removed: {removed}. Restyled hexes restored: {restored}.', + named: 'Hexes named "{name}": {count}.', + unnamed: 'Names cleared: {count}.', + marked: + 'Locations hidden in existing hexes: {attached}. Waiting for the next fill that covers them: {pending}.', + unmarked: 'Tokens that are no longer locations: {count}.', + settingChanged: '{setting} set to {value}.', + rescanned: + 'Rescan complete. Kept: {kept}. Adopted: {adopted}. Re-filed: {moved}. Missing and forgotten: {dropped}. Labels re-linked: {labels}. Location tokens re-linked: {icons}.', + calibrated: + 'Grid calibrated (column step {colStep}px, row step {rowStep}px). Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + calibrationReset: + 'Calibration removed. Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + 'Your Hexploration 1.x hex maps have been upgraded. If this game was copied from a Legacy game, run Rescan on each hex map page.', + pruned: + 'Saved hexes that no longer exist and were forgotten: {dropped}. If this game or page was copied, run Rescan on the page to pick its hexes up again.', + readyHint: + 'Type !hexploration for the menu, or open the "Hexploration - Command Deck" handout.', + }, + warnings: { + foregroundUnavailable: + 'This game does not support drawing on the foreground layer, so hexes were drawn on the token layer.', + someFailed: 'Hexes that could not be drawn: {count}. Check the API console for details.', + }, + errors: { + noPage: 'Could not find the page to work on.', + notHex: 'This page does not use a hex grid.', + noPolygons: 'Select one or more drawn shapes to fill.', + emptyArea: 'The selected area does not contain any hex centres.', + tooMany: 'That would create too many hexes in one go ({count}).', + nothingToConceal: 'Select drawn shapes or tokens to conceal.', + nothingToReveal: 'Select hexes, drawn shapes or tokens to reveal.', + noTokens: 'Select one or more tokens first.', + noHexes: 'Select one or more hexes (or tokens standing on hexes) first.', + nothingToUndo: 'There is no fill to undo.', + unknownCommand: 'Unknown command: {command}', + unknownSetting: 'Unknown setting: {key}', + unknownPageSetting: 'Settings that can be set per page: {keys}', + invalidValue: '"{value}" is not a valid value for {key}.', + calibrateNeedsTokens: 'Select one or two tokens snapped to hex centres.', + calibrateFailed: 'Those tokens cannot be used to calibrate.', + unexpected: 'Something went wrong: {message}', + }, + hints: { + noPage: 'Open the page you want to work on, or select something on it.', + notHex: 'Set the page grid to Hex (V) or Hex (H) in Page Settings.', + noPolygons: + 'Draw a polygon, rectangle, ellipse or freehand shape around the area, select it, then try again.', + emptyArea: 'Draw a larger shape, or check the page grid settings.', + tooMany: 'Fill a smaller area, or split the area into several shapes.', + noHexes: 'Hexes are on the foreground or token layer; switch to that layer to select them.', + unknownCommand: 'Type !hexploration help to list the commands.', + unknownSetting: 'Type !hexploration set to see every setting.', + calibrateNeedsTokens: + 'Snap a token to the centre of a hex and select it. Select a second token snapped to a neighbouring hex in the same row (Hex V) or column (Hex H) to correct the hex size too.', + calibrateFailed: + 'Two tokens must be in the same row (Hex V) or the same column (Hex H), at least one hex apart.', + unexpected: 'Details are in the API console log.', + }, + help: { + menu: 'Show the menu.', + fill: 'Cover the selected drawn shapes with hexes.', + fillInverse: 'Cover the whole page except inside the selected shapes.', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: 'Reveal the selected hexes, and the hexes under the selected shapes and tokens.', + revealPage: 'Reveal every hex on the page without announcements.', + conceal: 'Cover the area under the selected shapes and tokens with hexes again.', + explore: 'Reveal around the selected tokens as if they had just moved there.', + resetPage: 'Remove every hex on the page (asks first).', + name: 'Name the selected hexes, or the hexes under the selected tokens. Leave the name empty to clear it.', + mark: 'Turn the selected tokens into hidden locations.', + unmark: 'Stop the selected tokens being hidden locations.', + set: 'Change a setting, or show all settings.', + pageSet: 'Override a reveal setting on the current page only.', + pageClear: 'Remove the current page’s overrides.', + rescan: 'Rebuild the page’s hex list, for example after copying a page or game.', + calibrate: 'Line the hex grid up with one or two selected tokens snapped to hex centres.', + calibrateReset: 'Remove the current page’s calibration.', + status: 'Show what Hexploration knows about the current page.', + journal: 'Rebuild the Help and Command Deck handouts.', + help: 'Show this list.', + handout: 'Full instructions are in the "{name}" handout.', + }, + deck: { + subtitle: 'Command Deck', + drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', + revealDesc: + 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', + locationsDesc: + 'Select tokens to hide them as locations under hexes. Select hexes or tokens to name a hex.', + toolsDesc: + 'Settings, page overrides, status, rescanning copied pages and calibrating the grid.', + footer: 'See the "{help}" handout for full instructions.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex exploration for Roll20', + footer: 'Use the "{deck}" handout for one-click controls.', + overview: { + heading: 'Overview', + body: 'Hexploration covers a hex map with opaque hexes. As the party moves, the hexes they pass through (and, if you like, the hexes around them) are removed, so the map is uncovered one hex at a time. Hidden locations can be placed under hexes and are announced when found. It works in Jumpgate and Legacy games, on Hex (V) and Hex (H) grids of any size.', + demo: 'Watch a short demo (from version 1)', + }, + quickStart: { + heading: 'Quick Start', + steps: [ + 'Open a page whose grid is set to Hex (V) or Hex (H).', + 'Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide.', + 'Select the shapes and click Fill in the Command Deck (or type !hexploration fill). The shapes are replaced by hexes.', + 'Optional: before filling, select tokens for important places and click Mark Location. They are hidden under the hexes and announced when discovered.', + 'Move a player token. Every hex it passes through, and the hexes within its Sight Distance, are revealed.', + ], + }, + commands: { + heading: 'Commands', + intro: + 'Only GMs can use these commands. Most act on the selected objects; the rest act on the page you are viewing.', + colCommand: 'Command', + colDesc: 'What it does', + }, + revealing: { + heading: 'How Revealing Works', + points: [ + 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', + 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', + 'Sight Distance reveals the hexes around each of those hexes. With Line of Sight on, a hex is only revealed if no covered hex lies in between.', + 'Hex Reveal Distance is stored on hexes as they are drawn. Those hexes are only revealed from within that many hexes, however far a token can see. Use it for mountains or forests that hide what is behind them.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them.', + 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + ], + }, + locations: { + heading: 'Named Hexes and Locations', + points: [ + 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', + 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', + 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', + ], + }, + settings: { + heading: 'Settings', + intro: + 'Change settings with !hexploration set (or the Settings button). Hex Layer, Tokens That Reveal and Language can also be set on the Mod’s settings page.', + colKey: 'Key', + colName: 'Setting', + colDesc: 'Description', + perPage: '(Can be set per page.)', + }, + jumpgate: { + heading: 'Jumpgate and Legacy', + points: [ + 'Hexploration works out which engine the game uses and draws the matching kind of shape. Shapes drawn in either editor can be filled.', + 'With Hex Layer set to Auto, hexes are drawn on the foreground layer, above tokens, so players cannot see what is underneath. If the foreground layer is not available, the token layer is used instead.', + 'Jumpgate draws mathematically regular hexes, which are a slightly different shape from Legacy hexes. If the hexes do not line up with a page’s grid, snap a token to a hex centre, select it and click Calibrate. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size too.', + 'When a page or game is copied, its hexes get new IDs. Run Rescan on the page to pick them up again, together with their name labels and location tokens.', + ], + }, + upgrading: { + heading: 'Upgrading from Version 1', + points: [ + 'Version 2 no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. You can remove them unless another mod uses them.', + 'Existing hex maps, names, location tokens and settings are upgraded automatically on the first start.', + 'The version 1 commands, including the Hexploration_menu macro, still work.', + 'Version 1 let any token that represented a character reveal hexes. Set Tokens That Reveal to Character tokens to keep that behaviour.', + ], + colV1: 'Version 1 command', + colV2: 'Version 2 command', + }, + troubleshooting: { + heading: 'Troubleshooting', + points: [ + 'Nothing happens when a token moves: check the token is on the token layer and matches Tokens That Reveal, and that the page has hexes (!hexploration status).', + 'Hexes are offset from the grid: use Calibrate, then check with a token on a few hexes across the map.', + 'Hexes stopped revealing after copying a page or game: run Rescan on the page.', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: 'Languages', + body: 'Choose a language with !hexploration set language. Available languages:', + }, + credits: { + heading: 'Credits', + original: 'Original mod by', + maintainer: 'Version 2 maintained by', + marketplace: 'Ada’s art packs on the Roll20 Marketplace', + support: + 'If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log.', + }, + }, + }; + + var localeFi = {}; + + var localeFr = {}; + + var localeDe = {}; + + var localeEl = {}; + + var localeHe = {}; + + var localeHu = {}; + + var localeIt = {}; + + var localeJa = {}; + + var localeKo = {}; + + var localePl = {}; + + var localePtPT = {}; + + var localePtBR = {}; + + var localeRu = {}; + + var localeEs = {}; + + var localeSv = {}; + + var localeTr = {}; + + var localeUk = {}; + + const DEFAULT_LOCALE = 'en-US'; + + const LOCALE_DEFINITIONS = Object.freeze([ + { + code: 'af', + name: 'Afrikaans', + direction: 'ltr', + translationFile: 'locale/af.js', + flag: '🇿🇦', + flagLabel: 'Flag of South Africa', + }, + { + code: 'ca', + name: 'Catalan', + nativeName: 'Català', + direction: 'ltr', + translationFile: 'locale/ca.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'zh-TW', + name: 'Chinese (Traditional)', + nativeName: '正體中文', + direction: 'ltr', + translationFile: 'locale/zh-TW.js', + aliases: ['zh'], + flag: '🇹🇼', + flagLabel: 'Flag of Taiwan', + }, + { + code: 'cs', + name: 'Czech', + nativeName: 'Čeština', + direction: 'ltr', + translationFile: 'locale/cs.js', + flag: '🇨🇿', + flagLabel: 'Flag of Czechia', + }, + { + code: 'da', + name: 'Danish', + nativeName: 'Dansk', + direction: 'ltr', + translationFile: 'locale/da.js', + flag: '🇩🇰', + flagLabel: 'Flag of Denmark', + }, + { + code: 'nl', + name: 'Dutch', + nativeName: 'Nederlands', + direction: 'ltr', + translationFile: 'locale/nl.js', + flag: '🇳🇱', + flagLabel: 'Flag of the Netherlands', + }, + { + code: 'en-US', + name: 'English', + nativeName: 'English', + direction: 'ltr', + translationFile: 'locale/en-US.js', + aliases: ['en'], + flag: '🇺🇸', + flagLabel: 'Flag of the United States', + }, + { + code: 'fi', + name: 'Finnish', + nativeName: 'Suomeksi', + direction: 'ltr', + translationFile: 'locale/fi.js', + flag: '🇫🇮', + flagLabel: 'Flag of Finland', + }, + { + code: 'fr', + name: 'French', + nativeName: 'Français', + direction: 'ltr', + translationFile: 'locale/fr.js', + flag: '🇫🇷', + flagLabel: 'Flag of France', + }, + { + code: 'de', + name: 'German', + nativeName: 'Deutsch', + direction: 'ltr', + translationFile: 'locale/de.js', + flag: '🇩🇪', + flagLabel: 'Flag of Germany', + }, + { + code: 'el', + name: 'Greek', + nativeName: 'Ελληνικά', + direction: 'ltr', + translationFile: 'locale/el.js', + flag: '🇬🇷', + flagLabel: 'Flag of Greece', + }, + { + code: 'he', + name: 'Hebrew', + nativeName: 'עברית', + direction: 'rtl', + translationFile: 'locale/he.js', + flag: '🇮🇱', + flagLabel: 'Flag of Israel', + }, + { + code: 'hu', + name: 'Hungarian', + nativeName: 'Magyar', + direction: 'ltr', + translationFile: 'locale/hu.js', + flag: '🇭🇺', + flagLabel: 'Flag of Hungary', + }, + { + code: 'it', + name: 'Italian', + nativeName: 'Italiano', + direction: 'ltr', + translationFile: 'locale/it.js', + flag: '🇮🇹', + flagLabel: 'Flag of Italy', + }, + { + code: 'ja', + name: 'Japanese', + nativeName: '日本語', + direction: 'ltr', + translationFile: 'locale/ja.js', + flag: '🇯🇵', + flagLabel: 'Flag of Japan', + }, + { + code: 'ko', + name: 'Korean', + nativeName: '한국어', + direction: 'ltr', + translationFile: 'locale/ko.js', + flag: '🇰🇷', + flagLabel: 'Flag of South Korea', + }, + { + code: 'pl', + name: 'Polish', + nativeName: 'Polski', + direction: 'ltr', + translationFile: 'locale/pl.js', + flag: '🇵🇱', + flagLabel: 'Flag of Poland', + }, + { + code: 'pt-PT', + name: 'Portuguese (Portugal)', + nativeName: 'Português - Portugal', + direction: 'ltr', + translationFile: 'locale/pt-PT.js', + aliases: ['pt'], + flag: '🇵🇹', + flagLabel: 'Flag of Portugal', + }, + { + code: 'pt-BR', + name: 'Portuguese (Brazil)', + nativeName: 'Português - Brasil', + direction: 'ltr', + translationFile: 'locale/pt-BR.js', + flag: '🇧🇷', + flagLabel: 'Flag of Brazil', + }, + { + code: 'ru', + name: 'Russian', + nativeName: 'Русский', + direction: 'ltr', + translationFile: 'locale/ru.js', + flag: '🇷🇺', + flagLabel: 'Flag of Russia', + }, + { + code: 'es', + name: 'Spanish', + nativeName: 'Español', + direction: 'ltr', + translationFile: 'locale/es.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'sv', + name: 'Swedish', + nativeName: 'Svenska', + direction: 'ltr', + translationFile: 'locale/sv.js', + flag: '🇸🇪', + flagLabel: 'Flag of Sweden', + }, + { + code: 'tr', + name: 'Turkish', + nativeName: 'Türkçe', + direction: 'ltr', + translationFile: 'locale/tr.js', + flag: '🇹🇷', + flagLabel: 'Flag of Turkey', + }, + { + code: 'uk', + name: 'Ukrainian', + nativeName: 'Українська', + direction: 'ltr', + translationFile: 'locale/uk.js', + flag: '🇺🇦', + flagLabel: 'Flag of Ukraine', + }, + ]); + + const SUPPORTED_LOCALES = Object.freeze(LOCALE_DEFINITIONS.map(({ code }) => code)); + const VALID_LOCALES = new Set(SUPPORTED_LOCALES); + const LOCALE_ALIASES = Object.freeze( + LOCALE_DEFINITIONS.reduce((aliases, locale) => { + for (const alias of locale.aliases || []) { + aliases[alias] = locale.code; + } + return aliases; + }, {}) + ); + const LOCALE_LABELS = Object.freeze( + LOCALE_DEFINITIONS.reduce((labels, locale) => { + const displayName = locale.nativeName + ? `${locale.code} - ${locale.name} (${locale.nativeName})` + : `${locale.code} - ${locale.name}`; + labels[locale.code] = displayName; + return labels; + }, {}) + ); + SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); + + const TRANSLATIONS = { + af: TRANSLATION$4, + ca: TRANSLATION$3, + 'zh-TW': TRANSLATION$2, + cs: TRANSLATION$1, + da: TRANSLATION, + nl: localeNl, + 'en-US': localeEnUS, + fi: localeFi, + fr: localeFr, + de: localeDe, + el: localeEl, + he: localeHe, + hu: localeHu, + it: localeIt, + ja: localeJa, + ko: localeKo, + pl: localePl, + 'pt-PT': localePtPT, + 'pt-BR': localePtBR, + ru: localeRu, + es: localeEs, + sv: localeSv, + tr: localeTr, + uk: localeUk, + }; + + /** + * Returns the canonical locale for a supported locale string or alias. + * Matching is case-insensitive after exact matches are checked. + * + * @param {string} lang Locale string or alias (e.g. 'en', 'fr', 'zh-TW'). + * @returns {string} Canonical locale code, or an empty string when unsupported. + */ + function normalizeLocale(lang) { + const s = typeof lang === 'string' ? lang.trim() : ''; + if (VALID_LOCALES.has(s)) { + return s; + } + if (LOCALE_ALIASES[s]) { + return LOCALE_ALIASES[s]; + } + const normalized = s.toLowerCase(); + const found = Array.from(VALID_LOCALES).find((locale) => locale.toLowerCase() === normalized); + return ( + found || + Object.entries(LOCALE_ALIASES).find(([alias]) => alias.toLowerCase() === normalized)?.[1] || + '' + ); + } + + /** + * Returns a valid canonical locale, falling back to the default when unsupported. + * + * @param {string} lang Locale string to validate. + * @returns {string} Validated canonical locale. + */ + function getLocale(lang) { + return normalizeLocale(lang) || DEFAULT_LOCALE; + } + + /** + * Navigates a nested object following dot-separated key path segments. + * + * @param {object} obj Root object. + * @param {string[]} parts Key path segments. + * @returns {*} Value at the path, or undefined. + */ + function getNestedValue(obj, parts) { + let current = obj; + for (const part of parts) { + if (current == null || typeof current !== 'object') { + return undefined; + } + current = current[part]; + } + return current; + } + + /** + * Returns the raw translated value (string, array or object) for a key, + * falling back to en-US when the key is missing in the requested locale. + * + * @param {string} key Dot-separated translation key. + * @param {string} locale Locale code. + * @returns {*} Raw value, or undefined when not found. + */ + function tRaw(key, locale) { + const lang = getLocale(locale); + const parts = key.split('.'); + const value = getNestedValue(TRANSLATIONS[lang], parts); + return value === undefined && lang !== DEFAULT_LOCALE + ? getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts) + : value; + } + + /** + * Returns the text direction CSS for a locale. + * + * @param {string} locale Locale code. + * @returns {string} CSS declarations, empty for left-to-right locales. + */ + function getDirectionStyle(locale) { + const lang = getLocale(locale); + const def = LOCALE_DEFINITIONS.find((d) => d.code === lang); + return def?.direction === 'rtl' ? 'direction:rtl;text-align:right;' : ''; + } + + /** + * Returns the translated string for a dot-separated key, interpolating {placeholder} vars. + * Falls back to en-US when the key is missing in the requested locale. + * No HTML escaping is performed — callers must pre-escape HTML-unsafe values. + * + * @param {string} key Dot-separated translation key (e.g. 'errors.noTokensSelected'). + * @param {string} locale Locale code. + * @param {object} [vars] Interpolation variables mapped to {placeholder} names. + * @returns {string} Translated and interpolated string. Returns the key when not found. + */ + function t(key, locale, vars = {}) { + const lang = getLocale(locale); + const parts = key.split('.'); + let value = getNestedValue(TRANSLATIONS[lang], parts); + + if (value === undefined && lang !== DEFAULT_LOCALE) { + value = getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts); + } + + if (typeof value !== 'string') { + return key; + } + + return value.replaceAll(/\{(\w+)\}/g, (_, k) => (k in vars ? String(vars[k]) : `{${k}}`)); + } + + // --------------------------------------------------------------------------- + // Config validation (pure) + // --------------------------------------------------------------------------- + + /** + * Validates one configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Result; `value` is the normalised value when valid. + */ + function validateConfigValue(key, raw) { + const ok = (value) => ({ valid: true, value }); + const bad = { valid: false }; + + switch (key) { + case 'language': { + const lang = normalizeLocale(raw); + return lang ? ok(lang) : bad; + } + case 'hexLayer': + return HEX_LAYER_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealBy': + return REVEAL_BY_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealMode': + return REVEAL_MODE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'announce': + return ANNOUNCE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'fillColor': + case 'strokeColor': + case 'labelColor': + case 'glimpseColor': + return isValidColor(raw) ? ok(toText(raw)) : bad; + case 'strokeWidth': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 ? bad : ok(clamp(n, 0, MAX_STROKE_WIDTH)); + } + case 'revealDistance': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'maxDistance': { + if (raw === null || raw === undefined || ['', '-', 'none', 'off'].includes(toText(raw))) { + return ok(null); + } + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'lineOfSight': + case 'revealPath': + case 'pingDiscoveries': + case 'hideCoveredTokens': { + const b = parseBoolean(raw); + return b === null ? bad : ok(b); + } + default: + return bad; + } + } + + /** + * Merges a possibly incomplete or invalid config with defaults. + * + * @param {object} config Config to merge. + * @param {object} [defaults] Defaults to fall back on. + * @returns {object} Complete config. + */ + function mergeConfig(config, defaults = DEFAULT_CONFIG) { + const c = isRecord(config) ? config : {}; + const merged = {}; + for (const key of Object.keys(DEFAULT_CONFIG)) { + const result = key in c ? validateConfigValue(key, c[key]) : { valid: false }; + merged[key] = result.valid ? result.value : defaults[key]; + } + return merged; + } + + /** + * Keeps only valid per-page overrides. + * + * @param {object} settings Raw page settings. + * @returns {object} Clean page settings. + */ + function mergePageSettings(settings) { + const clean = {}; + if (!isRecord(settings)) { + return clean; + } + for (const key of PAGE_SETTING_KEYS) { + if (key in settings) { + const result = validateConfigValue(key, settings[key]); + if (result.valid) { + clean[key] = result.value; + } + } + } + return clean; + } + + // --------------------------------------------------------------------------- + // State shape and migration (pure) + // --------------------------------------------------------------------------- + + /** + * Creates an empty v2 state object. + * + * @returns {object} Fresh state. + */ + function createDefaultState() { + return { + schemaVersion: SCHEMA_VERSION, + version: SCRIPT_VERSION, + config: { ...DEFAULT_CONFIG }, + pages: {}, + pendingLocations: {}, + lastFill: null, + coveredTokens: {}, + notices: {}, + }; + } + + /** + * Normalises one stored hex record. + * + * @param {string} key "row,col" key. + * @param {object} raw Stored record. + * @returns {object|null} Clean hex record, or null when unusable. + */ + function normaliseHex(key, raw) { + const coords = parseHexKey(key); + if (!coords || !isRecord(raw) || !toText(raw.id)) { + return null; + } + const hex = { + id: toText(raw.id), + type: raw.type === 'pathv2' ? 'pathv2' : raw.type === 'path' ? 'path' : null, + row: coords[0], + col: coords[1], + }; + if (toText(raw.name)) { + hex.name = toText(raw.name); + } + if (toText(raw.nameId)) { + hex.nameId = toText(raw.nameId); + } + if (toText(raw.iconId)) { + hex.iconId = toText(raw.iconId); + } + const maxDistance = validateConfigValue('maxDistance', raw.maxDistance); + if (maxDistance.valid && maxDistance.value !== null) { + hex.maxDistance = maxDistance.value; + } + if (raw.glimpsed === true) { + hex.glimpsed = true; + } + return hex; + } + + /** + * Normalises a page's stored data. + * + * @param {object} raw Stored page data. + * @returns {object} Clean page data. + */ + function normalisePage(raw) { + const page = { hexes: {}, settings: {}, calibration: null }; + if (!isRecord(raw)) { + return page; + } + if (isRecord(raw.hexes)) { + for (const [key, value] of Object.entries(raw.hexes)) { + const hex = normaliseHex(key, value); + if (hex) { + page.hexes[`${hex.row},${hex.col}`] = hex; + } + } + } + page.settings = mergePageSettings(raw.settings); + if (isRecord(raw.calibration)) { + const cal = {}; + for (const k of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(raw.calibration[k])) { + cal[k] = raw.calibration[k]; + } + } + page.calibration = Object.keys(cal).length === 4 ? cal : null; + } + return page; + } + + /** + * Converts any stored state (v1, v2 or damaged) into a clean v2 state. + * + * v1 stored hexes in `pageHexes[pageId]["row,col"]` with a parallel `hexIdMap`, + * and a flat config. Its defaults differed (no reveal distance), so missing + * v1 values fall back to v1 behaviour rather than the new defaults. + * + * @param {*} raw Stored state. + * @returns {{state: object, migratedFrom: number|null}} Clean state and the + * schema it was migrated from (null when no migration was needed). + */ + function migrateState(raw) { + const fresh = createDefaultState(); + if (!isRecord(raw)) { + return { state: fresh, migratedFrom: null }; + } + + if (isRecord(raw.pageHexes) && !isRecord(raw.pages)) { + const v1Defaults = { ...DEFAULT_CONFIG, revealDistance: 0, strokeWidth: 0 }; + fresh.config = mergeConfig(raw.config, v1Defaults); + for (const [pageId, hexes] of Object.entries(raw.pageHexes)) { + const page = normalisePage({ hexes }); + if (Object.keys(page.hexes).length > 0) { + fresh.pages[pageId] = page; + } + } + return { state: fresh, migratedFrom: 1 }; + } + + fresh.config = mergeConfig(raw.config); + if (isRecord(raw.pages)) { + for (const [pageId, page] of Object.entries(raw.pages)) { + fresh.pages[pageId] = normalisePage(page); + } + } + if (isRecord(raw.pendingLocations)) { + for (const [tokenId, pageId] of Object.entries(raw.pendingLocations)) { + if (toText(pageId)) { + fresh.pendingLocations[tokenId] = toText(pageId); + } + } + } + if (isRecord(raw.lastFill)) { + fresh.lastFill = raw.lastFill; + } + if (isRecord(raw.coveredTokens)) { + for (const [tokenId, entry] of Object.entries(raw.coveredTokens)) { + if (isRecord(entry) && toText(entry.pageId) && isRecord(entry.saved)) { + fresh.coveredTokens[tokenId] = { + pageId: toText(entry.pageId), + saved: { ...entry.saved }, + }; + } + } + } + if (isRecord(raw.notices)) { + fresh.notices = { ...raw.notices }; + } + return { state: fresh, migratedFrom: null }; + } + + // --------------------------------------------------------------------------- + // Persistent state access (Roll20) + // --------------------------------------------------------------------------- + + let pathIndex = null; + + /** + * Loads, migrates and validates the persistent state. Call once on ready. + * + * @returns {number|null} The schema migrated from, or null. + */ + function initialiseState() { + const { state: clean, migratedFrom } = migrateState(state[STATE_KEY]); + clean.version = SCRIPT_VERSION; + state[STATE_KEY] = clean; + pathIndex = null; + return migratedFrom; + } + + /** + * Returns the persistent state, creating it when missing. + * + * @returns {object} State branch. + */ + function getState() { + if (!isRecord(state[STATE_KEY]) || state[STATE_KEY].schemaVersion !== SCHEMA_VERSION) { + initialiseState(); + } + return state[STATE_KEY]; + } + + /** + * Returns the global configuration. + * + * @returns {object} Config. + */ + function getConfig() { + return getState().config; + } + + /** + * Sets one global configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setConfigValue(key, raw) { + if (!(key in DEFAULT_CONFIG)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getState().config[key] = result.value; + } + return result; + } + + /** + * Imports Roll20 One-Click useroptions into the persisted config. + * + * @returns {void} + */ + function applyGlobalConfig() { + if (typeof globalconfig === 'undefined' || !isRecord(globalconfig)) { + return; + } + const branch = globalconfig[STATE_KEY.toLowerCase()] || globalconfig[STATE_KEY]; + if (!isRecord(branch)) { + return; + } + const options = isRecord(branch.useroptions) ? branch.useroptions : branch; + const s = getState(); + // useroptions only change when the GM edits them, so remember what was last + // applied and only re-apply on change; otherwise chat changes would be + // overwritten on every restart. + const applied = isRecord(s.notices.useroptions) ? s.notices.useroptions : {}; + for (const key of ['hexLayer', 'revealBy', 'language']) { + if (key in options && options[key] !== applied[key]) { + setConfigValue(key, options[key]); + applied[key] = options[key]; + } + } + s.notices.useroptions = applied; + } + + /** + * Returns a page's stored data. + * + * @param {string} pageId Page ID. + * @param {boolean} [create=false] Create the record when missing. + * @returns {object|null} Page data. + */ + function getPageData(pageId, create = false) { + const s = getState(); + if (!s.pages[pageId] && create) { + s.pages[pageId] = { hexes: {}, settings: {}, calibration: null }; + } + return s.pages[pageId] || null; + } + + /** + * Returns the IDs of every page with stored data. + * + * @returns {string[]} Page IDs. + */ + function getPageIds() { + return Object.keys(getState().pages); + } + + /** + * Removes a page's stored data entirely. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function deletePageData(pageId) { + const s = getState(); + const page = s.pages[pageId]; + if (page && pathIndex) { + for (const hex of Object.values(page.hexes)) { + pathIndex.delete(hex.id); + } + } + delete s.pages[pageId]; + } + + /** + * Returns the settings in force on a page: global config plus page overrides. + * + * @param {string} pageId Page ID. + * @returns {object} Effective settings. + */ + function getPageSettings(pageId) { + const page = getPageData(pageId); + return { ...getConfig(), ...(page ? page.settings : {}) }; + } + + /** + * Sets a per-page override. + * + * @param {string} pageId Page ID. + * @param {string} key Setting key (must be in PAGE_SETTING_KEYS). + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setPageSetting(pageId, key, raw) { + if (!PAGE_SETTING_KEYS.includes(key)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getPageData(pageId, true).settings[key] = result.value; + } + return result; + } + + /** + * Clears all per-page overrides. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function clearPageSettings(pageId) { + const page = getPageData(pageId); + if (page) { + page.settings = {}; + } + } + + /** + * Stores or clears a page's grid calibration. + * + * @param {string} pageId Page ID. + * @param {object|null} calibration Calibration, or null to clear. + * @returns {void} + */ + function setCalibration(pageId, calibration) { + getPageData(pageId, true).calibration = calibration ? { ...calibration } : null; + } + + // --------------------------------------------------------------------------- + // Hex records + // --------------------------------------------------------------------------- + + /** + * Builds the in-memory path ID index on first use. + * + * @returns {Map} Map of path ID to [pageId, key]. + */ + function getIndex() { + if (!pathIndex) { + pathIndex = new Map(); + for (const [pageId, page] of Object.entries(getState().pages)) { + for (const [key, hex] of Object.entries(page.hexes)) { + pathIndex.set(hex.id, [pageId, key]); + } + } + } + return pathIndex; + } + + /** + * Returns a hex record. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} Hex record. + */ + function getHex(pageId, key) { + return getPageData(pageId)?.hexes[key] || null; + } + + /** + * Returns every hex record on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Hex records. + */ + function getPageHexes(pageId) { + const page = getPageData(pageId); + return page ? Object.values(page.hexes) : []; + } + + /** + * Returns the hex record drawn by a path, with its page. + * + * @param {string} pathId Path object ID. + * @returns {{pageId: string, key: string, hex: object}|null} Lookup result. + */ + function getHexByPathId(pathId) { + const entry = getIndex().get(pathId); + if (!entry) { + return null; + } + const [pageId, key] = entry; + const hex = getHex(pageId, key); + return hex ? { pageId, key, hex } : null; + } + + /** + * Stores a hex record, replacing any record at the same cell. + * + * @param {string} pageId Page ID. + * @param {object} hex Hex record with row and col. + * @returns {object} The stored record. + */ + function putHex(pageId, hex) { + const key = `${hex.row},${hex.col}`; + const page = getPageData(pageId, true); + const old = page.hexes[key]; + if (old && old.id !== hex.id) { + getIndex().delete(old.id); + } + page.hexes[key] = hex; + getIndex().set(hex.id, [pageId, key]); + return hex; + } + + /** + * Removes a hex record (not its Roll20 objects). + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} The removed record. + */ + function deleteHexRecord(pageId, key) { + const page = getPageData(pageId); + const hex = page?.hexes[key]; + if (!hex) { + return null; + } + delete page.hexes[key]; + getIndex().delete(hex.id); + return hex; + } + + // --------------------------------------------------------------------------- + // Pending locations and undo + // --------------------------------------------------------------------------- + + /** + * Returns pending location token IDs on a page (tokens marked as locations + * before the area under them was filled). + * + * @param {string} pageId Page ID. + * @returns {string[]} Token IDs. + */ + function getPendingLocations(pageId) { + return Object.entries(getState().pendingLocations) + .filter(([, page]) => page === pageId) + .map(([tokenId]) => tokenId); + } + + /** + * Adds or removes a pending location. + * + * @param {string} tokenId Token ID. + * @param {string|null} pageId Page ID, or null to remove. + * @returns {void} + */ + function setPendingLocation(tokenId, pageId) { + const pending = getState().pendingLocations; + if (pageId) { + pending[tokenId] = pageId; + } else { + delete pending[tokenId]; + } + } + + /** + * Returns the record of the last fill, used by undo. + * + * @returns {object|null} Last fill record. + */ + function getLastFill() { + return getState().lastFill; + } + + /** + * Stores or clears the record of the last fill. + * + * @param {object|null} record Fill record. + * @returns {void} + */ + function setLastFill(record) { + getState().lastFill = record; + } + + /** + * Returns the saved player-visible properties of tokens hidden under hexes. + * + * @returns {object} Map of token ID to { pageId, saved }. + */ + function getCoveredTokens() { + return getState().coveredTokens; + } + + /** + * Builds the hex grid for a page, including any calibration. + * + * @param {object} page Roll20 page. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function buildPageGrid(page) { + const pageId = page.get('_id'); + return createGrid({ + gridType: page.get('grid_type'), + // snapping_increment is 0 when snapping is off; the grid is still drawn at 1 unit. + scale: Number(page.get('snapping_increment')) || 1, + jumpgate: isJumpgate(), + // Set by Jumpgate's map alignment tool. + offsetX: Number(page.get('grid_offset_x')) || 0, + offsetY: Number(page.get('grid_offset_y')) || 0, + calibration: getPageData(pageId)?.calibration || null, + }); + } + + /** + * Returns everything needed to work on a page's hexes. + * + * @param {string} pageId Page ID. + * @returns {{ok: true, pageId: string, page: object, grid: object}|{ok: false, reason: string}} + * Context, or the reason it is unavailable ('noPage' or 'notHex'). + */ + function getPageContext(pageId) { + const page = pageId ? getObj('page', pageId) : null; + if (!page) { + return { ok: false, reason: 'noPage' }; + } + const grid = buildPageGrid(page); + if (!grid) { + return { ok: false, reason: 'notHex' }; + } + return { ok: true, pageId, page, grid }; + } + + // Hiding tokens' player-visible details while they are under a hex. + // + // Hexes hide the token image, but Roll20 draws nameplates, bars and auras + // above the foreground layer, so a monster under a hex would still give its + // position away. While a token's centre is under a covered (not glimpsed) hex, + // its player-visible flags are switched off; the saved values are restored + // when it is uncovered, moved out, or the setting is turned off. + + /** + * Returns true when a token's centre is under a covered hex. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @returns {boolean} True when covered. + */ + function isCovered(ctx, token) { + if (token.get('layer') !== LAYER_TOKEN || token.get('_subtype') !== 'token') { + return false; + } + const [row, col] = pixelToHex(ctx.grid, Number(token.get('left')), Number(token.get('top'))); + const hex = getHex(ctx.pageId, hexKey(row, col)); + return !!hex && !hex.glimpsed; + } + + /** + * Switches a token's player-visible details off, saving their values. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function hideDetails(token) { + const covered = getCoveredTokens(); + const id = token.get('_id'); + if (covered[id]) { + return; + } + const saved = {}; + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + saved[prop] = token.get(prop) === true; + updates[prop] = false; + } + covered[id] = { pageId: token.get('_pageid'), saved }; + token.set(updates); + } + + /** + * Restores a token's saved player-visible details. + * + * @param {string} tokenId Token ID. + * @returns {void} + */ + function restoreDetails(tokenId) { + const covered = getCoveredTokens(); + const entry = covered[tokenId]; + if (!entry) { + return; + } + delete covered[tokenId]; + const token = getObj('graphic', tokenId); + if (token) { + token.set({ ...entry.saved }); + } + } + + /** + * Keeps a covered token's details hidden when the GM switches one on while it + * is covered: the new value is saved for when the token is uncovered. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleCoveredChange(token, prev) { + const entry = getCoveredTokens()[token.get('_id')]; + if (!entry || !prev) { + return; + } + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + if (token.get(prop) === true && prev[prop] !== true) { + entry.saved[prop] = true; + updates[prop] = false; + } + } + if (Object.keys(updates).length > 0) { + token.set(updates); + } + } + + /** + * Hides or restores one token's details to match whether it is covered. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function refreshToken(token) { + const ctx = getPageContext(token.get('_pageid')); + if (getConfig().hideCoveredTokens && ctx.ok && isCovered(ctx, token)) { + hideDetails(token); + } else { + restoreDetails(token.get('_id')); + } + } + + /** + * Hides or restores the details of every token on a page. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function refreshPage(pageId) { + const ctx = getPageContext(pageId); + const enabled = getConfig().hideCoveredTokens && ctx.ok; + const covered = getCoveredTokens(); + for (const token of findObjs({ _type: 'graphic', _pageid: pageId, _subtype: 'token' })) { + if (enabled && isCovered(ctx, token)) { + hideDetails(token); + } else if (covered[token.get('_id')]) { + restoreDetails(token.get('_id')); + } + } + // Forget tokens that were deleted while hidden. + for (const [tokenId, entry] of Object.entries(covered)) { + if (entry.pageId === pageId && !getObj('graphic', tokenId)) { + delete covered[tokenId]; + } + } + } + + /** + * Restores every hidden token in the game (used when the setting is turned off). + * + * @returns {void} + */ + function restoreAll() { + for (const tokenId of Object.keys(getCoveredTokens())) { + restoreDetails(tokenId); + } + } + + // Named hexes and hidden location tokens. + // + // A hex can carry a name (shown to the GM as a label on the GM layer) and an + // icon (a token hidden on the GM layer). Both are announced when the hex is + // revealed, and the icon is moved back to the token layer. + + /** + * Returns the token attached to a hex as its icon, if it still exists. + * + * @param {object} hex Hex record. + * @returns {object|null} Roll20 graphic. + */ + function getHexIcon(hex) { + return hex.iconId ? getObj('graphic', hex.iconId) || null : null; + } + + /** + * Returns the name announced when a hex is discovered: the icon's name, or + * the hex's own name. + * + * @param {object} hex Hex record. + * @returns {string} Discovery name (empty when the hex is unnamed). + */ + function getDiscoveryName(hex) { + const icon = getHexIcon(hex); + return toText(icon?.get('name')) || toText(hex.name); + } + + /** + * Removes a hex's GM-layer name label. + * + * @param {object} hex Hex record. + * @returns {void} + */ + function removeLabel(hex) { + if (hex.nameId) { + getObj('text', hex.nameId)?.remove(); + delete hex.nameId; + } + } + + /** + * Sets or clears a hex's name and redraws its GM-layer label. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record. + * @param {string} name New name (empty to clear). + * @returns {void} + */ + function setHexName(ctx, hex, name) { + removeLabel(hex); + const clean = toText(name).slice(0, MAX_NAME_LENGTH); + if (!clean) { + delete hex.name; + return; + } + hex.name = clean; + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + const label = createObj('text', { + _pageid: ctx.pageId, + layer: LAYER_GM, + left: x, + top: y, + text: clean, + color: getConfig().labelColor, + }); + if (label) { + hex.nameId = label.get('_id'); + } + } + + /** + * Attaches a token to a hex as its hidden icon. + * + * @param {object} hex Hex record. + * @param {object} token Roll20 graphic. + * @returns {string} The token's layer before it was hidden (for undo). + */ + function attachIcon(hex, token) { + const previousLayer = token.get('layer'); + hex.iconId = token.get('_id'); + token.set('layer', LAYER_GM); + setPendingLocation(hex.iconId, null); + return previousLayer; + } + + /** + * Detaches a hex's icon and returns it to the token layer. + * + * @param {object} hex Hex record. + * @param {boolean} [show=true] Move the icon back to the token layer. + * @returns {void} + */ + function detachIcon(hex, show = true) { + const icon = getHexIcon(hex); + if (icon && show) { + icon.set('layer', LAYER_TOKEN); + } + delete hex.iconId; + } + + /** + * Returns the hex records on a page keyed by the ID of their icon. + * + * @param {string} pageId Page ID. + * @returns {Map} Map of icon ID to hex record. + */ + function hexesByIcon(pageId) { + const map = new Map(); + for (const hex of getPageHexes(pageId)) { + if (hex.iconId) { + map.set(hex.iconId, hex); + } + } + return map; + } + + /** + * Returns location tokens waiting for a hex on a page, keyed by hex cell: + * tokens marked with `mark`, plus (as in v1) tokens with the white-tower + * status marker. Tokens already attached to a hex are ignored. + * + * @param {object} ctx Page context. + * @returns {Map} Map of "row,col" to Roll20 graphic. + */ + function findLocationTokens(ctx) { + const attached = hexesByIcon(ctx.pageId); + const tokens = new Map(); + const consider = (token) => { + if (!token || attached.has(token.get('_id'))) { + return; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + tokens.set(hexKey(row, col), token); + }; + + for (const tokenId of getPendingLocations(ctx.pageId)) { + const token = getObj('graphic', tokenId); + if (token) { + consider(token); + } else { + setPendingLocation(tokenId, null); + } + } + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId })) { + if (tokenHasMarker(token, LOCATION_MARKER)) { + consider(token); + } + } + return tokens; + } + + /** + * Marks tokens as hidden locations. A token already under a hex is attached + * immediately; otherwise it waits for the next fill that covers it. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {{attached: number, pending: number}} Counts. + */ + function markLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + let attachedCount = 0; + let pendingCount = 0; + for (const token of tokens) { + if (attached.has(token.get('_id'))) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + attachIcon(hex, token); + attachedCount++; + } else { + setPendingLocation(token.get('_id'), ctx.pageId); + pendingCount++; + } + } + return { attached: attachedCount, pending: pendingCount }; + } + + /** + * Stops tokens being hidden locations. Attached tokens return to the token layer. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number} Number of tokens unmarked. + */ + function unmarkLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + const pending = new Set(getPendingLocations(ctx.pageId)); + let count = 0; + for (const token of tokens) { + const id = token.get('_id'); + const hex = attached.get(id); + if (hex) { + detachIcon(hex); + count++; + } else if (pending.has(id)) { + setPendingLocation(id, null); + count++; + } + } + return count; + } + + // Polygon maths for Roll20 drawn shapes. Pure functions only: callers pass + // plain property objects, so the module can be unit tested in Node. + // + // Both kinds of Roll20 path store points relative to their own bounding box + // and are placed by their centre: + // - Legacy `path`: `_path` is a JSON list of SVG-like commands (M, L, Q, C), + // placed by left/top, sized by width/height, scaled by scaleX/scaleY. + // - Jumpgate `pathv2`: `points` is a JSON list of [x, y] pairs interpreted by + // `shape` (pol, free, rec, eli) and placed by x/y. It has no scale. + // Both can be rotated by `rotation` degrees about their centre. + + const UNIT_PX = 70; + const ELLIPSE_SEGMENTS = 32; + const CURVE_SEGMENTS = 8; + + /** + * Returns the bounding box of a list of points. + * + * @param {number[][]} points Array of [x, y]. + * @returns {{left: number, top: number, right: number, bottom: number}} Bounding box. + */ + function boundingBox(points) { + let left = Infinity; + let top = Infinity; + let right = -Infinity; + let bottom = -Infinity; + for (const [x, y] of points) { + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x); + bottom = Math.max(bottom, y); + } + return { left, top, right, bottom }; + } + + /** + * Tests whether a point lies inside a polygon ring (even-odd rule). The ring + * is treated as closed whether or not its last point repeats the first. + * + * @param {number[]} point [x, y]. + * @param {number[][]} ring Array of [x, y]. + * @returns {boolean} True when inside. + */ + function pointInRing(point, ring) { + const [x, y] = point; + let inside = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const [xi, yi] = ring[i]; + const [xj, yj] = ring[j]; + const crosses = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi; + if (crosses) { + inside = !inside; + } + } + return inside; + } + + /** + * Tests whether a point lies inside any of a shape's rings (even-odd across + * rings, so a ring drawn inside another makes a hole). + * + * @param {number[]} point [x, y]. + * @param {number[][][]} rings Array of rings. + * @returns {boolean} True when inside. + */ + function pointInShape(point, rings) { + let inside = false; + for (const ring of rings) { + if (ring.length >= 3 && pointInRing(point, ring)) { + inside = !inside; + } + } + return inside; + } + + /** + * Builds a transform from path-local coordinates to page pixels. + * + * @param {object} t Transform values. + * @returns {(x: number, y: number) => number[]} Point transform. + */ + function makeTransform({ width, height, cx, cy, scaleX = 1, scaleY = 1, rotation = 0 }) { + const angle = ((Number(rotation) || 0) * Math.PI) / 180; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + return (x, y) => { + const lx = (x - width / 2) * scaleX; + const ly = (y - height / 2) * scaleY; + return [cx + lx * cos - ly * sin, cy + lx * sin + ly * cos]; + }; + } + + /** + * Samples a quadratic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 Control point. + * @param {number[]} p2 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleQuadratic(p0, p1, p2) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + points.push([ + u * u * p0[0] + 2 * u * t * p1[0] + t * t * p2[0], + u * u * p0[1] + 2 * u * t * p1[1] + t * t * p2[1], + ]); + } + return points; + } + + /** + * Samples a cubic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 First control point. + * @param {number[]} p2 Second control point. + * @param {number[]} p3 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleCubic(p0, p1, p2, p3) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + const a = u * u * u; + const b = 3 * u * u * t; + const c = 3 * u * t * t; + const d = t * t * t; + points.push([ + a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], + a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1], + ]); + } + return points; + } + + /** + * Converts a Legacy path's command list into rings in path-local coordinates. + * + * @param {Array[]} commands Parsed `_path` commands. + * @returns {number[][][]} Rings. + */ + function legacyCommandsToRings(commands) { + const rings = []; + let ring = []; + let prevType = null; + for (const cmd of commands) { + if (!Array.isArray(cmd)) { + continue; + } + const [type, ...args] = cmd; + const nums = args.map(Number); + const prev = ring.at(-1); + if (type === 'M' && prevType !== 'M') { + if (ring.length > 0) { + rings.push(ring); + } + ring = [[nums[0], nums[1]]]; + } else if (type === 'L' || type === 'M') { + // Two consecutive Ms are drawn by Roll20 as a line, so treat the second as L. + ring.push([nums[0], nums[1]]); + } else if (type === 'Q' && prev) { + ring.push(...sampleQuadratic(prev, [nums[0], nums[1]], [nums[2], nums[3]])); + } else if (type === 'C' && prev) { + ring.push(...sampleCubic(prev, [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]])); + } + prevType = type; + } + if (ring.length > 0) { + rings.push(ring); + } + return rings; + } + + /** + * Returns points approximating an ellipse inside a box. + * + * @param {number} width Box width. + * @param {number} height Box height. + * @returns {number[][]} Points in box-local coordinates. + */ + function ellipsePoints(width, height) { + const points = []; + for (let i = 0; i < ELLIPSE_SEGMENTS; i++) { + const angle = (i / ELLIPSE_SEGMENTS) * Math.PI * 2; + points.push([ + width / 2 + (Math.cos(angle) * width) / 2, + height / 2 + (Math.sin(angle) * height) / 2, + ]); + } + return points; + } + + /** + * Parses a JSON string, returning null on failure. + * + * @param {string} text JSON text. + * @returns {*} Parsed value, or null. + */ + function safeJson(text) { + try { + return JSON.parse(text); + } catch { + return null; + } + } + + /** + * Converts a Legacy path's properties into page-space rings. + * + * @param {object} props Path properties (_path, left, top, width, height, scaleX, scaleY, rotation). + * @param {object} [page] Page size in units ({ width, height }) for mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function legacyPathToRings(props, page = {}) { + const raw = String(props._path || props.path || '') + .replaceAll('mapWidth', String((Number(page.width) || 0) * UNIT_PX)) + .replaceAll('mapHeight', String((Number(page.height) || 0) * UNIT_PX)); + const commands = safeJson(raw); + if (!Array.isArray(commands)) { + return []; + } + const transform = makeTransform({ + width: Number(props.width) || 0, + height: Number(props.height) || 0, + cx: Number(props.left) || 0, + cy: Number(props.top) || 0, + scaleX: Number(props.scaleX) || 1, + scaleY: Number(props.scaleY) || 1, + rotation: props.rotation, + }); + return legacyCommandsToRings(commands).map((ring) => ring.map(([x, y]) => transform(x, y))); + } + + /** + * Converts a Jumpgate pathv2's properties into page-space rings. + * + * @param {object} props Path properties (points, shape, x, y, rotation). + * @returns {number[][][]} Rings in page pixels. + */ + function pathV2ToRings(props) { + const parsed = safeJson(props.points); + if (!Array.isArray(parsed) || parsed.length === 0) { + return []; + } + const raw = parsed + .filter((p) => Array.isArray(p) && p.length >= 2) + .map(([x, y]) => [Number(x), Number(y)]) + .filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)); + if (raw.length === 0) { + return []; + } + + // Points are normalised so the bounding box starts at 0,0. + const box = boundingBox(raw); + const local = raw.map(([x, y]) => [x - box.left, y - box.top]); + const width = box.right - box.left; + const height = box.bottom - box.top; + + let ring; + if (props.shape === 'rec') { + ring = [ + [0, 0], + [width, 0], + [width, height], + [0, height], + ]; + } else if (props.shape === 'eli') { + ring = ellipsePoints(width, height); + } else { + ring = local; + } + + const transform = makeTransform({ + width, + height, + cx: Number(props.x) || 0, + cy: Number(props.y) || 0, + rotation: props.rotation, + }); + return [ring.map(([x, y]) => transform(x, y))]; + } + + /** + * Converts either kind of path into page-space rings. + * + * @param {object} props Path properties including `type` ('path' or 'pathv2'). + * @param {object} [page] Page size in units, for Legacy mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function pathToRings(props, page) { + if (props.type === 'pathv2') { + return pathV2ToRings(props); + } + return legacyPathToRings(props, page); + } + + /** + * Builds the properties for a closed polygon as either kind of path. + * Points are made relative to their bounding box, and the path is placed by + * its centre, matching how Roll20 stores both path types. + * + * @param {number[][]} points Polygon corners in page pixels. + * @param {boolean} jumpgate True to build a pathv2, false for a Legacy path. + * @returns {object} Geometry properties for createObj. + */ + function polygonPathProps(points, jumpgate) { + const box = boundingBox(points); + const width = box.right - box.left; + const height = box.bottom - box.top; + const cx = box.left + width / 2; + const cy = box.top + height / 2; + const round = (n) => Math.round(n * 1000) / 1000; + const local = points.map(([x, y]) => [round(x - box.left), round(y - box.top)]); + const closed = [...local, local[0]]; + + if (jumpgate) { + return { + shape: 'pol', + points: JSON.stringify(closed), + x: cx, + y: cy, + }; + } + + const commands = closed.map(([x, y], i) => [i === 0 ? 'M' : 'L', x, y]); + return { + _path: JSON.stringify(commands), + left: cx, + top: cy, + width, + height, + }; + } + + /** + * Returns the centroid of a ring's distinct vertices. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[]} [x, y]. + */ + function ringCentre(ring) { + const pts = distinctVertices(ring); + const sum = pts.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [0, 0]); + return [sum[0] / pts.length, sum[1] / pts.length]; + } + + /** + * Returns a ring's vertices with a repeated closing point removed. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[][]} Distinct vertices. + */ + function distinctVertices(ring) { + if (ring.length > 1) { + const first = ring[0]; + const last = ring.at(-1); + if (Math.abs(first[0] - last[0]) < 0.01 && Math.abs(first[1] - last[1]) < 0.01) { + return ring.slice(0, -1); + } + } + return ring; + } + + // Roll20 object access for drawn shapes. Jumpgate games draw `pathv2` + // objects; Legacy games draw `path` objects. Everything that reads or writes a + // path goes through this module so the rest of the mod never cares which. + + // Set when the foreground layer turns out to be unavailable, so later hexes + // go straight to the token layer instead of failing one by one. + let foregroundUnavailable = false; + + /** + * Returns a path object of either type by ID. + * + * @param {string} id Object ID. + * @param {string|null} [type] Known type, checked first. + * @returns {object|null} Roll20 path or pathv2 object. + */ + function getPathObject(id, type = null) { + if (!id) { + return null; + } + const types = activePathTypes(); + const order = type && types.includes(type) ? [type, ...types.filter((t) => t !== type)] : types; + for (const t of order) { + const obj = getObj(t, id); + if (obj) { + return obj; + } + } + return null; + } + + /** + * Returns true when a Roll20 object is a path of either type. + * + * @param {object} obj Roll20 object. + * @returns {boolean} True for path and pathv2. + */ + function isPathObject(obj) { + return !!obj && PATH_TYPES.includes(obj.get('_type')); + } + + /** + * Copies the properties the polygon module needs from a path. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {object} Plain properties including `type`. + */ + function readPathProps(obj) { + const type = obj.get('_type'); + const base = { + type, + pageId: obj.get('_pageid'), + layer: obj.get('layer'), + rotation: obj.get('rotation'), + fill: obj.get('fill'), + stroke: obj.get('stroke'), + stroke_width: obj.get('stroke_width'), + }; + if (type === PATH_TYPE_V2) { + return { + ...base, + shape: obj.get('shape'), + points: obj.get('points'), + x: obj.get('x'), + y: obj.get('y'), + }; + } + return { + ...base, + _path: obj.get('_path'), + left: obj.get('left'), + top: obj.get('top'), + width: obj.get('width'), + height: obj.get('height'), + scaleX: obj.get('scaleX'), + scaleY: obj.get('scaleY'), + }; + } + + /** + * Returns a path's outline as page-space rings. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {number[][][]} Rings. + */ + function getPathRings(obj) { + const props = readPathProps(obj); + const page = getObj('page', props.pageId); + return pathToRings(props, page ? { width: page.get('width'), height: page.get('height') } : {}); + } + + /** + * Recreates a path from properties saved by readPathProps (used by undo). + * + * @param {object} props Saved properties. + * @returns {object|null} New Roll20 object. + */ + function recreatePath(props) { + const { type, pageId, ...rest } = props; + const attrs = { _pageid: pageId }; + for (const [key, value] of Object.entries(rest)) { + if (value !== undefined && value !== null) { + attrs[key] = value; + } + } + // A Legacy game cannot create pathv2 objects, and vice versa. + const createType = type === PATH_TYPE_V2 && !isJumpgate() ? PATH_TYPE_LEGACY : type; + return createObj(createType, attrs) || null; + } + + /** + * Returns the layer new hexes should be drawn on. + * + * @returns {string} Roll20 layer. + */ + function getHexLayer() { + const setting = getConfig().hexLayer; + if (setting === 'objects' || foregroundUnavailable) { + return LAYER_TOKEN; + } + return LAYER_FOREGROUND; + } + + /** + * Draws a hex outline as a path. + * + * The foreground layer is tried first (unless the GM chose the token layer); + * if the game rejects it, the hex is drawn on the token layer instead and the + * fallback is remembered for the rest of the session. + * + * @param {string} pageId Page ID. + * @param {number[][]} corners Hex corners in page pixels. + * @param {object} style Style with fill, stroke and strokeWidth. + * @returns {{obj: object, fellBack: boolean}|null} New path, or null when it could not be created. + */ + function createHexPath(pageId, corners, style) { + const jumpgate = isJumpgate(); + const type = jumpgate ? PATH_TYPE_V2 : PATH_TYPE_LEGACY; + const geometry = polygonPathProps(corners, jumpgate); + const attrs = { + ...geometry, + _pageid: pageId, + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + controlledby: '', + }; + + const layer = getHexLayer(); + let obj = createObj(type, { ...attrs, layer }); + if (obj && obj.get('layer') === layer) { + return { obj, fellBack: false }; + } + + if (layer === LAYER_FOREGROUND) { + if (obj) { + obj.remove(); + } + foregroundUnavailable = true; + obj = createObj(type, { ...attrs, layer: LAYER_TOKEN }); + return obj ? { obj, fellBack: true } : null; + } + return obj ? { obj, fellBack: false } : null; + } + + /** + * Removes a Roll20 object if it still exists. + * + * @param {object|null} obj Roll20 object. + * @returns {void} + */ + function safeRemove(obj) { + if (obj) { + try { + obj.remove(); + } catch (err) { + log(`Hexploration: could not remove object: ${err?.message || err}`); + } + } + } + + /** + * Returns every path of either type on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Roll20 path objects. + */ + function getPagePaths(pageId) { + return activePathTypes().flatMap((type) => findObjs({ _type: type, _pageid: pageId })); + } + + /** + * Returns the path types that can exist in this game. Jumpgate games can + * hold both (old API-made paths survive); Legacy games only have `path`. + * + * @returns {string[]} Path types. + */ + function activePathTypes() { + return isJumpgate() ? PATH_TYPES : [PATH_TYPE_LEGACY]; + } + + // Creating, removing and maintaining hexes on a page: fill, inverse fill, + // conceal, reset, rescan, calibrate and undo. + + /** + * Returns the hex style from the current config. + * + * @returns {{fill: string, stroke: string, strokeWidth: number, maxDistance: number|null}} Style. + */ + function currentStyle() { + const config = getConfig(); + return { + fill: config.fillColor, + stroke: config.strokeColor, + strokeWidth: config.strokeWidth, + maxDistance: config.maxDistance, + }; + } + + /** + * Draws one hex and stores its record. + * + * @param {object} ctx Page context. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {object} style Hex style. + * @param {object} [extra] Extra record fields (name, iconId…). + * @returns {{hex: object, fellBack: boolean}|null} New record, or null on failure. + */ + function drawHex(ctx, row, col, style, extra = {}) { + const created = createHexPath(ctx.pageId, hexCorners(ctx.grid, row, col), style); + if (!created) { + return null; + } + const hex = { id: created.obj.get('_id'), type: created.obj.get('_type'), row, col, ...extra }; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } + putHex(ctx.pageId, hex); + return { hex, fellBack: created.fellBack }; + } + + /** + * Removes a hex: its record, its path and its name label. Its icon is moved + * back to the token layer when `showIcon` is true, otherwise left hidden. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @param {boolean} [showIcon=false] Return the icon to the token layer. + * @returns {object|null} The removed record. + */ + function removeHex(pageId, key, showIcon = false) { + const hex = deleteHexRecord(pageId, key); + if (!hex) { + return null; + } + removeLabel(hex); + if (showIcon) { + detachIcon(hex); + } + safeRemove(getPathObject(hex.id, hex.type)); + return hex; + } + + /** + * Returns the cells whose centres lie inside any of the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects on the page. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function cellsInPaths(ctx, paths) { + const seen = new Set(); + const cells = []; + for (const path of paths) { + const rings = getPathRings(path); + if (rings.length === 0) { + continue; + } + const box = boundingBox(rings.flat()); + for (const [row, col] of hexesInBox(ctx.grid, box)) { + const key = hexKey(row, col); + if (!seen.has(key) && pointInShape(hexToPixel(ctx.grid, row, col), rings)) { + seen.add(key); + cells.push([row, col]); + } + } + } + return cells; + } + + /** + * Returns every cell on the page except those inside the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects to leave uncovered. + * @returns {number[][]} Array of [row, col]. + */ + function cellsOutsidePaths(ctx, paths) { + const omit = new Set(cellsInPaths(ctx, paths).map(([r, c]) => hexKey(r, c))); + const width = Number(ctx.page.get('width')) * 70; + const height = Number(ctx.page.get('height')) * 70; + return hexesCoveringPage(ctx.grid, width, height).filter(([r, c]) => !omit.has(hexKey(r, c))); + } + + /** + * Covers cells with hexes. Existing hexes are restyled rather than replaced, + * so their names and icons are kept. Location tokens in a covered cell are + * attached as icons. Work is batched; `onDone` receives a summary. + * + * @param {object} ctx Page context. + * @param {number[][]} cells Cells to cover. + * @param {object} options Fill options. + * @param {object[]} [options.sources] Saved properties of the polygons used (for undo). + * @param {string} options.kind Fill kind for undo ('fill', 'fillInverse', 'conceal'). + * @param {(summary: object) => void} options.onDone Completion callback. + * @returns {{started: boolean, reason?: string}} Whether the fill started. + */ + function fillCells(ctx, cells, { sources = [], kind, onDone }) { + if (cells.length > MAX_FILL_HEXES) { + return { started: false, reason: 'tooMany' }; + } + + const style = currentStyle(); + const locations = findLocationTokens(ctx); + const record = { + pageId: ctx.pageId, + kind, + time: Date.now(), + created: [], + restyled: [], + icons: [], + sources, + }; + const summary = { created: 0, restyled: 0, icons: 0, failed: 0, fellBack: false }; + + runInBatches( + cells, + BATCH_SIZE, + ([row, col]) => { + const key = hexKey(row, col); + let hex = getHex(ctx.pageId, key); + const existingPath = hex ? getPathObject(hex.id, hex.type) : null; + + if (hex && existingPath) { + record.restyled.push({ + key, + fill: existingPath.get('fill'), + stroke: existingPath.get('stroke'), + strokeWidth: existingPath.get('stroke_width'), + maxDistance: hex.maxDistance ?? null, + glimpsed: hex.glimpsed === true, + }); + existingPath.set({ + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + }); + delete hex.glimpsed; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } else { + delete hex.maxDistance; + } + summary.restyled++; + } else { + if (hex) { + // The record outlived its path (deleted while the API was off). + deleteHexRecord(ctx.pageId, key); + } + const drawn = drawHex(ctx, row, col, style); + if (!drawn) { + summary.failed++; + return; + } + hex = drawn.hex; + summary.fellBack = summary.fellBack || drawn.fellBack; + record.created.push({ key, id: hex.id }); + summary.created++; + } + + const token = locations.get(key); + if (token && !hex.iconId) { + record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + attachIcon(hex, token); + summary.icons++; + } + }, + (errors) => { + summary.failed += errors; + setLastFill(record); + onDone(summary); + } + ); + + return { started: true }; + } + + /** + * Removes every hex on a page, returning icons to the token layer. Page + * settings and calibration are kept. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function clearPage(ctx, onDone) { + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + for (const tokenId of getPendingLocations(ctx.pageId)) { + setPendingLocation(tokenId, null); + } + const last = getLastFill(); + if (last?.pageId === ctx.pageId) { + setLastFill(null); + } + runInBatches( + keys, + BATCH_SIZE, + (key) => removeHex(ctx.pageId, key, true), + () => onDone(keys.length) + ); + } + + /** + * Reverses the last fill: removes the hexes it created, restores the style + * of hexes it restyled, returns icons it hid, and redraws the polygons it used. + * + * @returns {{ok: boolean, reason?: string, removed?: number, restored?: number, pageId?: string}} Result. + */ + function undoLastFill() { + const record = getLastFill(); + if (!record) { + return { ok: false, reason: 'nothingToUndo' }; + } + setLastFill(null); + const page = getObj('page', record.pageId); + if (!page) { + return { ok: false, reason: 'noPage' }; + } + + let removed = 0; + for (const { key, id } of record.created || []) { + const hex = getHex(record.pageId, key); + if (hex && hex.id === id) { + removeHex(record.pageId, key, false); + removed++; + } + } + + let restored = 0; + for (const prev of record.restyled || []) { + const hex = getHex(record.pageId, prev.key); + const path = hex ? getPathObject(hex.id, hex.type) : null; + if (path) { + path.set({ fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); + if (Number.isInteger(prev.maxDistance)) { + hex.maxDistance = prev.maxDistance; + } else { + delete hex.maxDistance; + } + if (prev.glimpsed) { + hex.glimpsed = true; + } + restored++; + } + } + + for (const { id, layer } of record.icons || []) { + const token = getObj('graphic', id); + if (token) { + for (const hex of getPageHexes(record.pageId)) { + if (hex.iconId === id) { + delete hex.iconId; + } + } + token.set('layer', layer || LAYER_TOKEN); + } + } + + for (const props of record.sources || []) { + recreatePath(props); + } + + return { ok: true, removed, restored, pageId: record.pageId }; + } + + /** + * Captures the polygons used for a fill so undo can redraw them, then deletes them. + * + * @param {object[]} paths Roll20 path objects. + * @returns {object[]} Saved properties. + */ + function consumeSourcePaths(paths) { + // A selected path may itself be a hex; only plain drawings are consumed. + const drawings = paths.filter((path) => !getHexByPathId(path.get('_id'))); + const sources = drawings.map(readPathProps); + for (const path of drawings) { + safeRemove(path); + } + return sources; + } + + /** + * Returns the hex a path draws, judged by its shape: a six-cornered polygon + * centred on a hex cell and roughly the size of a hex. + * + * @param {object} ctx Page context. + * @param {object} path Roll20 path object. + * @returns {number[]|null} [row, col], or null when the path is not a hex. + */ + function matchHexShape(ctx, path) { + const rings = getPathRings(path); + if (rings.length !== 1) { + return null; + } + const vertices = distinctVertices(rings[0]); + if (vertices.length !== 6) { + return null; + } + const [x, y] = ringCentre(vertices); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + if (Math.hypot(x - cx, y - cy) > ctx.grid.colStep * RESCAN_CENTRE_TOLERANCE) { + return null; + } + const actual = boundingBox(vertices); + const expected = boundingBox(hexCorners(ctx.grid, row, col)); + const ratioW = (actual.right - actual.left) / (expected.right - expected.left); + const ratioH = (actual.bottom - actual.top) / (expected.bottom - expected.top); + if (ratioW < 0.75 || ratioW > 1.25 || ratioH < 0.75 || ratioH > 1.25) { + return null; + } + return [row, col]; + } + + /** + * Rebuilds a page's hex list from what is actually on the page: + * - drops records whose path is gone, and label/icon links that are broken; + * - re-files hexes whose cell changed (after calibration); + * - adopts hex-shaped paths the mod does not know about (duplicated pages, + * Legacy games copied to Jumpgate); + * - re-links GM-layer labels and white-tower icons sitting on hexes. + * + * @param {object} ctx Page context. + * @returns {{kept: number, dropped: number, moved: number, adopted: number, labels: number, icons: number}} Counts. + */ + function rescanPage(ctx) { + const counts = { kept: 0, dropped: 0, moved: 0, adopted: 0, labels: 0, icons: 0 }; + const pageData = getPageData(ctx.pageId, true); + + // 1. Check existing records. + for (const hex of Object.values(pageData.hexes)) { + const key = hexKey(hex.row, hex.col); + const path = getPathObject(hex.id, hex.type); + if (!path) { + removeLabel(hex); + deleteHexRecord(ctx.pageId, key); + counts.dropped++; + continue; + } + hex.type = path.get('_type'); + if (hex.nameId && !getObj('text', hex.nameId)) { + delete hex.nameId; + } + if (hex.iconId && !getHexIcon(hex)) { + delete hex.iconId; + } + const cell = matchHexShape(ctx, path); + if ( + cell && + hexKey(cell[0], cell[1]) !== key && + !getHex(ctx.pageId, hexKey(cell[0], cell[1])) + ) { + deleteHexRecord(ctx.pageId, key); + putHex(ctx.pageId, { ...hex, row: cell[0], col: cell[1] }); + counts.moved++; + } else { + counts.kept++; + } + } + + // 2. Adopt unknown hex-shaped paths. + for (const path of getPagePaths(ctx.pageId)) { + const id = path.get('_id'); + if (getHexByPathId(id)) { + continue; + } + const cell = matchHexShape(ctx, path); + if (!cell || getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + continue; + } + putHex(ctx.pageId, { id, type: path.get('_type'), row: cell[0], col: cell[1] }); + counts.adopted++; + } + + // 3. Re-link GM-layer labels sitting on hex centres. + const linkedLabels = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.nameId) + .filter(Boolean) + ); + for (const text of findObjs({ _type: 'text', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedLabels.has(text.get('_id'))) { + continue; + } + const x = Number(text.get('left')); + const y = Number(text.get('top')); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + hex.nameId = text.get('_id'); + hex.name = String(text.get('text') || '').trim() || hex.name; + counts.labels++; + } + } + + // 4. Re-link hidden white-tower icons. + const linkedIcons = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.iconId) + .filter(Boolean) + ); + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedIcons.has(token.get('_id')) || !tokenHasMarker(token, LOCATION_MARKER)) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + hex.iconId = token.get('_id'); + counts.icons++; + } + } + + return counts; + } + + /** + * Calibrates a page's grid from tokens snapped to hex centres, then rescans + * so existing hexes are filed under their corrected cells. + * + * @param {object} ctx Page context. + * @param {object[]} tokens One or two Roll20 graphics. + * @returns {{ok: boolean, calibration?: object, counts?: object}} Result. + */ + function calibratePage(ctx, tokens) { + const points = tokens.slice(0, 2).map((t) => [Number(t.get('left')), Number(t.get('top'))]); + // Calibrate against the uncalibrated profile so repeated calibration does not drift. + setCalibration(ctx.pageId, null); + const base = buildPageGrid(ctx.page); + const calibration = calibrateGrid(base, points); + if (!calibration) { + return { ok: false }; + } + setCalibration(ctx.pageId, calibration); + const fresh = { ...ctx, grid: buildPageGrid(ctx.page) }; + return { ok: true, calibration, counts: rescanPage(fresh) }; + } + + /** + * Clears a page's calibration and rescans. + * + * @param {object} ctx Page context. + * @returns {object} Rescan counts. + */ + function resetCalibration(ctx) { + setCalibration(ctx.pageId, null); + return rescanPage({ ...ctx, grid: buildPageGrid(ctx.page) }); + } + + /** + * Removes stored hexes whose paths no longer exist, on every page. Run on + * startup, since paths deleted while the API was off fire no events. + * + * @returns {{dropped: number, pages: number}} Counts. + */ + function pruneMissingHexes() { + let dropped = 0; + let pages = 0; + for (const pageId of getPageIds()) { + if (!getObj('page', pageId)) { + dropped += getPageHexes(pageId).length; + deletePageData(pageId); + pages++; + continue; + } + for (const hex of getPageHexes(pageId)) { + if (!getPathObject(hex.id, hex.type)) { + deleteHexRecord(pageId, hexKey(hex.row, hex.col)); + dropped++; + } + } + } + return { dropped, pages }; + } + + // Journal handouts: the Help handout and the Command Deck. + + const STYLE = { + outer: `background:${COLOR_CARD_BG_BOTTOM};color:${COLOR_TEXT};padding:14px 18px;border:1px solid ${COLOR_BORDER};border-radius:6px;font-family:Arial,sans-serif;line-height:1.5;`, + header: `background:${COLOR_HEADER_BG};padding:12px;border-radius:4px;text-align:center;border-bottom:3px solid ${COLOR_ACCENT};margin-bottom:12px;`, + h1: `color:${COLOR_HEADER_TEXT};margin:0;font-size:1.8em;letter-spacing:0.05em;`, + subtitle: `color:${COLOR_MUTED};margin:4px 0 0 0;font-size:0.9em;`, + h2: `color:${COLOR_ACCENT};border-bottom:1px solid ${COLOR_BORDER};padding-bottom:3px;margin:18px 0 8px 0;font-size:1.25em;`, + p: `color:${COLOR_TEXT};margin:6px 0;`, + li: `color:${COLOR_TEXT};margin:3px 0;`, + table: 'width:100%;border-collapse:collapse;margin:6px 0;font-size:0.92em;', + th: `background:${COLOR_HEADER_BG};color:${COLOR_HEADER_TEXT};padding:5px 8px;text-align:left;border:1px solid ${COLOR_BORDER};`, + td: `padding:5px 8px;border:1px solid ${COLOR_BORDER};vertical-align:top;color:${COLOR_TEXT};`, + code: 'font-family:monospace;color:#f3d48b;white-space:nowrap;', + link: `color:${COLOR_ACCENT};`, + footer: `color:${COLOR_MUTED};font-size:0.85em;text-align:center;margin-top:16px;border-top:1px solid ${COLOR_BORDER};padding-top:8px;`, + btn: `background:${COLOR_BUTTON_BG};color:${COLOR_BUTTON_TEXT};padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;font-weight:bold;`, + btnDark: `background:#2c4034;color:${COLOR_TEXT};border:1px solid #4d6b56;padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;`, + section: `background:${COLOR_HEADER_BG};color:${COLOR_ACCENT};padding:4px 8px;font-variant:small-caps;font-weight:bold;letter-spacing:0.05em;border-left:3px solid ${COLOR_ACCENT};margin:12px 0 4px 0;`, + desc: `color:${COLOR_MUTED};font-size:0.85em;margin:0 0 4px 8px;`, + }; + + /** + * Builds a table. + * + * @param {string[]} headings Column headings (escaped). + * @param {string[][]} rows Row cells (trusted HTML). + * @returns {string} HTML string. + */ + function table(headings, rows) { + const head = headings.map((h) => `${escapeHtml(h)}`).join(''); + const body = rows + .map((cells) => `${cells.map((c) => `${c}`).join('')}`) + .join(''); + return `${head}${body}
    `; + } + + /** + * Builds a paragraph list from a translated array. + * + * @param {*} items Translated value (array of strings expected). + * @param {boolean} [ordered=false] Use a numbered list. + * @returns {string} HTML string. + */ + function list(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const lis = (Array.isArray(items) ? items : []) + .map((item) => `
  • ${escapeHtml(item)}
    • `) + .join(''); + return `<${tag}>${lis}`; + } + + /** + * Builds a link. + * + * @param {string} url URL. + * @param {string} label Link text. + * @returns {string} HTML anchor. + */ + function link(url, label) { + return `${escapeHtml(label)}`; + } + + /** + * Builds the Help handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildHelpHtml(locale) { + const lang = getLocale(locale); + const h = (key, vars) => escapeHtml(t(`handout.${key}`, lang, vars)); + const raw = (key) => tRaw(`handout.${key}`, lang); + const code = (text) => `${escapeHtml(text)}`; + const section = (key, body) => `

    ${h(`${key}.heading`)}

    ${body}`; + + const commands = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ].map(([cmd, key]) => [code(`${COMMAND} ${cmd}`.trim()), escapeHtml(t(`help.${key}`, lang))]); + + const settings = Object.keys(DEFAULT_CONFIG).map((key) => [ + code(key), + escapeHtml(t(`settings.${key}.label`, lang)), + escapeHtml(t(`settings.${key}.desc`, lang)) + + (PAGE_SETTING_KEYS.includes(key) ? ` ${h('settings.perPage')}` : ''), + ]); + + const legacyCommands = [ + ['!hexploration_showMenuMain', `${COMMAND}`], + ['!hexploration_fillPoly', `${COMMAND} fill`], + ['!hexploration_fillInversePoly', `${COMMAND} fill inverse`], + ['!hexploration_hexModifyProperty name&&…', `${COMMAND} name …`], + ['!hexploration_configModifyProperty …', `${COMMAND} set …`], + ].map(([v1, v2]) => [code(v1), code(v2)]); + + const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const { original, maintainer } = AUTHOR_LINKS; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${h('versionLabel')} ${SCRIPT_VERSION} • ${h('subtitle')}

    +
    + ${section('overview', `

    ${h('overview.body')}

    ${link(DEMO_GIF_URL, t('handout.overview.demo', lang))}

    `)} + ${section('quickStart', list(raw('quickStart.steps'), true))} + ${section('commands', `

    ${h('commands.intro')}

    ${table([t('handout.commands.colCommand', lang), t('handout.commands.colDesc', lang)], commands)}`)} + ${section('revealing', list(raw('revealing.points')))} + ${section('locations', list(raw('locations.points')))} + ${section('settings', `

    ${h('settings.intro')}

    ${table([t('handout.settings.colKey', lang), t('handout.settings.colName', lang), t('handout.settings.colDesc', lang)], settings)}`)} + ${section('jumpgate', list(raw('jumpgate.points')))} + ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} + ${section('troubleshooting', list(raw('troubleshooting.points')))} + ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section( + 'credits', + `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    +

    ${h('credits.maintainer')} ${link(maintainer.profile, maintainer.name)} • ${link(maintainer.github, 'GitHub')}

    +

    ${h('credits.support')}

    ` + )} +
    ${SCRIPT_NAME} ${SCRIPT_VERSION} • ${h('footer', { deck: HANDOUT_DECK_NAME })}
    +
    `; + } + + /** + * Builds the Command Deck handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildDeckHtml(locale) { + const lang = getLocale(locale); + const tr = (key, vars) => t(key, lang, vars); + const btn = (key, cmd, dark = false) => + `${escapeHtml(tr(`buttons.${key}`))}`; + const group = (titleKey, descKey, buttons) => + `
    ${escapeHtml(tr(titleKey))}
    ${escapeHtml(tr(descKey))}
    ${buttons.join('')}
    `; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +
    + ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} + ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} + ${group('menu.locations', 'deck.locationsDesc', [btn('mark', 'mark'), btn('unmark', 'unmark', true), btn('name', `name ?{${tr('prompts.name')}}`)])} + ${group('menu.tools', 'deck.toolsDesc', [btn('settings', 'set', true), btn('pageSettings', 'page', true), btn('status', 'status', true), btn('rescan', 'rescan', true), btn('calibrate', 'calibrate', true), btn('calibrateReset', 'calibrate reset', true), btn('help', 'help', true), btn('menu', '', true)])} +
    ${escapeHtml(tr('deck.footer', { help: HANDOUT_HELP_NAME }))}
    +
    `; + } + + /** + * Creates or updates a handout, removing duplicates with the same name. + * + * @param {string} name Handout name. + * @param {string} html Handout notes HTML. + * @returns {void} + */ + function upsertHandout(name, html) { + const existing = findObjs({ _type: 'handout', name }); + const [primary, ...duplicates] = existing; + const handout = primary || createObj('handout', { name }); + if (!handout) { + return; + } + handout.set({ inplayerjournals: '', controlledby: '' }); + handout.set('notes', html); + for (const dup of duplicates) { + dup.remove(); + } + } + + /** + * Creates or refreshes the Help and Command Deck handouts in the current language. + * + * @returns {void} + */ + function installHandouts() { + const lang = getConfig().language; + upsertHandout(HANDOUT_HELP_NAME, buildHelpHtml(lang)); + upsertHandout(HANDOUT_DECK_NAME, buildDeckHtml(lang)); + } + + // Revealing hexes: when tokens move, from GM commands, and through the public API. + + /** + * Returns true when a token should reveal hexes under the page's settings. + * + * @param {object} token Roll20 graphic. + * @param {object} settings Effective page settings. + * @returns {boolean} True when the token reveals. + */ + function tokenReveals(token, settings) { + if (!token || token.get('_subtype') !== 'token' || token.get('layer') !== LAYER_TOKEN) { + return false; + } + switch (settings.revealBy) { + case 'all': + return true; + case 'characters': + return !!token.get('represents'); + default: + return getTokenControllers(token).some((id) => id === 'all' || !playerIsGM(id)); + } + } + + /** + * Announces a discovered location. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record (before removal). + * @param {string} name Location name. + * @param {string} imgsrc Icon image URL (may be empty). + * @param {object} settings Effective page settings. + * @returns {void} + */ + function announceDiscovery(ctx, hex, name, imgsrc, settings) { + if (name && settings.announce !== 'off') { + const lang = getConfig().language; + const img = imgsrc + ? `
    ` + : ''; + const html = buildCard( + t('discovery.title', lang), + `${img}
    ${escapeHtml(name)}
    ` + ); + const prefix = settings.announce === 'gm' ? '/w gm ' : ''; + sendChat(SCRIPT_NAME, `${prefix}${html}`); + } + if (name && settings.pingDiscoveries) { + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + sendPing(x, y, ctx.pageId, null, true); + } + } + + /** + * Reveals one hex: removes it and its label, shows its icon, and announces + * it when named. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {object} settings Effective page settings. + * @param {object} [options] Options. + * @param {number} [options.distance=0] Distance from the revealing token (for maxDistance). + * @param {boolean} [options.announce=true] Announce named discoveries. + * @returns {boolean} True when a hex was revealed. + */ + function revealHex(ctx, key, settings, { distance = 0, announce = true } = {}) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + if (distance > 0 && Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + + const name = getDiscoveryName(hex); + const icon = getHexIcon(hex); + const imgsrc = icon ? toText(icon.get('imgsrc')) : ''; + removeHex(ctx.pageId, key, false); + if (icon) { + icon.set({ layer: LAYER_TOKEN, showname: true }); + } + if (announce) { + announceDiscovery(ctx, hex, name, imgsrc, settings); + } + return true; + } + + /** + * Turns a hex see-through (glimpse mode) without revealing it. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {number} distance Distance from the revealing token. + * @returns {boolean} True when the hex changed. + */ + function glimpseHex(ctx, key, distance) { + const hex = getHex(ctx.pageId, key); + if (!hex || hex.glimpsed) { + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + const path = getPathObject(hex.id, hex.type); + if (!path) { + return false; + } + path.set('fill', getConfig().glimpseColor); + hex.glimpsed = true; + return true; + } + + /** + * Returns true when line of sight from one hex to another is blocked by a + * covered hex. Glimpsed hexes have been seen through, so they do not block. + * + * @param {object} ctx Page context. + * @param {number[]} from [row, col]. + * @param {number[]} to [row, col]. + * @returns {boolean} True when blocked. + */ + function isBlocked(ctx, from, to) { + return hexesBetween(ctx.grid, from, to).some(([r, c]) => { + const hex = getHex(ctx.pageId, hexKey(r, c)); + return hex && !hex.glimpsed; + }); + } + + /** + * Parses a token's lastmove into points. + * + * @param {string} lastmove Roll20 lastmove ("x1,y1,x2,y2,…"). + * @returns {number[][]} Array of [x, y]. + */ + function parseLastMove(lastmove) { + const nums = toText(lastmove) + .split(',') + .map(Number) + .filter((n) => Number.isFinite(n)); + const points = []; + for (let i = 0; i + 1 < nums.length; i += 2) { + points.push([nums[i], nums[i + 1]]); + } + return points; + } + + /** + * Returns the cells a token passed through on its last move, in order, plus + * every cell it now covers. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @param {object|null} prev Previous token properties, when known. + * @param {boolean} followPath Include the route travelled. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function travelledCells(ctx, token, prev, followPath) { + const current = [Number(token.get('left')), Number(token.get('top'))]; + const cells = []; + + if ( + followPath && + prev && + Number.isFinite(Number(prev.left)) && + Number.isFinite(Number(prev.top)) + ) { + const start = [Number(prev.left), Number(prev.top)]; + // lastmove holds the start point and any waypoints of the latest drag. It + // is only trusted when it starts where the token was; moves made by other + // mods leave a stale lastmove behind. + const waypoints = parseLastMove(token.get('lastmove')); + const startsHere = + waypoints.length > 0 && + Math.abs(waypoints[0][0] - start[0]) < 1 && + Math.abs(waypoints[0][1] - start[1]) < 1; + const route = startsHere ? [...waypoints, current] : [start, current]; + for (let i = 1; i < route.length; i++) { + cells.push(...hexesAlongSegment(ctx.grid, route[i - 1], route[i])); + } + } + + cells.push( + ...hexesUnderToken( + ctx.grid, + current[0], + current[1], + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + + const seen = new Set(); + return cells.filter(([r, c]) => { + const key = hexKey(r, c); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); + } + + /** + * Reveals around a list of origin cells using the page's settings. + * + * @param {object} ctx Page context. + * @param {number[][]} origins Cells the token occupied, in order. + * @param {object} settings Effective page settings. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealFromCells(ctx, origins, settings) { + let changed = 0; + for (const origin of origins) { + if (revealHex(ctx, hexKey(origin[0], origin[1]), settings)) { + changed++; + } + for (const cell of hexesWithin(ctx.grid, origin[0], origin[1], settings.revealDistance)) { + const key = hexKey(cell[0], cell[1]); + if (!getHex(ctx.pageId, key)) { + continue; + } + if (settings.lineOfSight && isBlocked(ctx, origin, cell)) { + continue; + } + const distance = hexDistance(ctx.grid, origin, cell); + const done = + settings.revealMode === 'glimpse' + ? glimpseHex(ctx, key, distance) + : revealHex(ctx, key, settings, { distance }); + if (done) { + changed++; + } + } + } + return changed; + } + + /** + * Reveals the hexes a token has moved through and can now see. + * + * @param {object} token Roll20 graphic. + * @param {object|null} [prev] Previous token properties from a change event. + * @param {boolean} [force=false] Skip the "which tokens reveal" check. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealAroundToken(token, prev = null, force = false) { + const pageId = token?.get('_pageid'); + if (!pageId || getPageHexes(pageId).length === 0) { + return 0; + } + const ctx = getPageContext(pageId); + if (!ctx.ok) { + return 0; + } + const settings = getPageSettings(pageId); + if (!force && !tokenReveals(token, settings)) { + return 0; + } + return revealFromCells(ctx, travelledCells(ctx, token, prev, settings.revealPath), settings); + } + + /** + * Handles a graphic change event: reveals when a token moves or arrives on + * the token layer. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleTokenChange(token, prev) { + const moved = prev && (prev.left !== token.get('left') || prev.top !== token.get('top')); + const surfaced = + prev && prev.layer !== token.get('layer') && token.get('layer') === LAYER_TOKEN; + const resized = + prev && (prev.width !== token.get('width') || prev.height !== token.get('height')); + handleCoveredChange(token, prev); + const layerChanged = prev && prev.layer !== token.get('layer'); + if (moved || surfaced || resized) { + if (revealAroundToken(token, moved ? prev : null) > 0) { + // Reveals may uncover other tokens as well as this one. + refreshPage(token.get('_pageid')); + return; + } + } + if (moved || layerChanged) { + refreshToken(token); + } + } + + /** + * Reveals every hex on a page without announcements. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function revealPage(ctx, onDone) { + const settings = getPageSettings(ctx.pageId); + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + let count = 0; + runInBatches( + keys, + BATCH_SIZE, + (key) => { + if (revealHex(ctx, key, settings, { announce: false })) { + count++; + } + }, + () => { + refreshPage(ctx.pageId); + onDone(count); + } + ); + } + + // Settings shown in the menu, in order, with how to prompt for them. + const SETTING_ROWS = [ + { key: 'hexLayer', options: HEX_LAYER_OPTIONS }, + { key: 'fillColor', color: true }, + { key: 'strokeColor', color: true }, + { key: 'labelColor', color: true }, + { key: 'glimpseColor', color: true }, + { key: 'strokeWidth' }, + { key: 'maxDistance' }, + { key: 'revealDistance' }, + { key: 'lineOfSight', options: ['on', 'off'] }, + { key: 'revealPath', options: ['on', 'off'] }, + { key: 'revealBy', options: REVEAL_BY_OPTIONS }, + { key: 'revealMode', options: REVEAL_MODE_OPTIONS }, + { key: 'announce', options: ANNOUNCE_OPTIONS }, + { key: 'pingDiscoveries', options: ['on', 'off'] }, + { key: 'hideCoveredTokens', options: ['on', 'off'] }, + { key: 'language' }, + ]; + + /** + * Returns the active locale. + * + * @returns {string} Locale code. + */ + function lang() { + return getConfig().language; + } + + /** + * Translates a key in the active locale. + * + * @param {string} key Translation key. + * @param {object} [vars] Interpolation variables. + * @returns {string} Translated text. + */ + function tr(key, vars) { + return t(key, lang(), vars); + } + + /** + * Whispers a translated error with its hint. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `errors.` (the hint lives under `hints.`). + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function fail(playerId, key, vars) { + const hint = t(`hints.${key}`, lang(), vars); + whisperError(playerId, tr(`errors.${key}`, vars), hint === `hints.${key}` ? '' : hint); + } + + /** + * Whispers a short translated confirmation. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `messages.`. + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function done(playerId, key, vars) { + whisper(playerId, SCRIPT_NAME, `
    ${escapeHtml(tr(`messages.${key}`, vars))}
    `); + } + + /** + * Formats a setting value for display. + * + * @param {string} key Setting key. + * @param {*} value Setting value. + * @returns {string} Display text. + */ + function formatValue(key, value) { + if (typeof value === 'boolean') { + return tr(value ? 'values.on' : 'values.off'); + } + if (value === null || value === undefined) { + return tr('values.none'); + } + if (key === 'language') { + return LOCALE_LABELS[value] || value; + } + if (['hexLayer', 'revealBy', 'revealMode', 'announce'].includes(key)) { + return tr(`values.${key}.${value}`); + } + return String(value); + } + + /** + * Builds a Roll20 query prompting for a setting's new value. + * + * @param {object} row Setting row definition. + * @param {*} current Current value. + * @returns {string} Query text. + */ + function settingQuery(row, current) { + const label = tr(`settings.${row.key}.label`).replaceAll(/[|}]/g, ''); + if (row.options) { + return `?{${label}|${row.options.join('|')}}`; + } + if (row.key === 'language') { + return `?{${label}|${SUPPORTED_LOCALES.join('|')}}`; + } + const shown = current === null || current === undefined ? '' : String(current); + return `?{${label}|${shown.replaceAll(/[|}]/g, '')}}`; + } + + // --------------------------------------------------------------------------- + // Selection and page helpers + // --------------------------------------------------------------------------- + + /** + * Sorts the selection into drawn shapes, hexes and tokens. + * + * @param {object} msg Chat message. + * @returns {{paths: object[], hexes: object[], tokens: object[], pageId: string|null}} Selection. + */ + function readSelection(msg) { + const selection = { paths: [], hexes: [], tokens: [], pageId: null }; + for (const sel of msg.selected || []) { + const obj = getObj(sel._type, sel._id); + if (!obj) { + continue; + } + selection.pageId = selection.pageId || obj.get('_pageid'); + if (isPathObject(obj)) { + const found = getHexByPathId(sel._id); + if (found) { + selection.hexes.push(found); + } else { + selection.paths.push(obj); + } + } else if (sel._type === 'graphic' && obj.get('_subtype') === 'token') { + selection.tokens.push(obj); + } + } + return selection; + } + + /** + * Returns the context for the selection's page, or the GM's current page. + * Whispers an error when the page cannot be used. + * + * @param {object} msg Chat message. + * @param {object} selection Selection from readSelection. + * @returns {object|null} Page context. + */ + function pageContextFor(msg, selection) { + const ctx = getPageContext(selection.pageId || getPlayerPageId(msg.playerid)); + if (!ctx.ok) { + fail(msg.playerid, ctx.reason); + return null; + } + return ctx; + } + + /** + * Returns the cells under the selected tokens. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number[][]} Array of [row, col]. + */ + function cellsUnderTokens(ctx, tokens) { + return tokens.flatMap((token) => + hexesUnderToken( + ctx.grid, + Number(token.get('left')), + Number(token.get('top')), + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + } + + /** + * Reports the end of a fill. + * + * @param {string} playerId Player ID. + * @param {object} summary Fill summary. + * @returns {void} + */ + function reportFill(playerId, summary) { + done(playerId, 'filled', summary); + if (summary.fellBack) { + whisperWarning(playerId, tr('warnings.foregroundUnavailable')); + } + if (summary.failed > 0) { + whisperWarning(playerId, tr('warnings.someFailed', { count: summary.failed })); + } + } + + /** + * Starts a fill and reports its outcome. + * + * @param {object} msg Chat message. + * @param {object} ctx Page context. + * @param {number[][]} allCells Cells to cover (duplicates are ignored). + * @param {object[]} sources Saved source polygons. + * @param {string} kind Fill kind. + * @returns {void} + */ + function startFill(msg, ctx, allCells, sources, kind) { + const seen = new Set(); + const cells = allCells.filter(([r, c]) => { + const key = hexKey(r, c); + return seen.has(key) ? false : seen.add(key); + }); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const result = fillCells(ctx, cells, { + sources, + kind, + onDone: (summary) => { + refreshPage(ctx.pageId); + reportFill(msg.playerid, summary); + }, + }); + if (!result.started) { + fail(msg.playerid, result.reason, { count: cells.length }); + } + } + + // --------------------------------------------------------------------------- + // Command handlers + // --------------------------------------------------------------------------- + + /** + * `fill` and `fill inverse`: cover the selected polygons (or everything + * outside them) with hexes. + * + * @param {object} msg Chat message. + * @param {boolean} inverse Fill outside the polygons. + * @returns {void} + */ + function commandFill(msg, inverse) { + const selection = readSelection(msg); + if (selection.paths.length === 0) { + fail(msg.playerid, 'noPolygons'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = inverse + ? cellsOutsidePaths(ctx, selection.paths) + : cellsInPaths(ctx, selection.paths); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, inverse ? 'fillInverse' : 'fill'); + } + + /** + * `conceal`: cover the cells under the selected polygons and tokens again. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandConceal(msg) { + const selection = readSelection(msg); + if (selection.paths.length === 0 && selection.tokens.length === 0) { + fail(msg.playerid, 'nothingToConceal'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]; + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, 'conceal'); + } + + /** + * `reveal`: reveal the selected hexes and the hexes under selected polygons + * and tokens. `reveal page` reveals everything on the page silently. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReveal(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + + if (args[0] === 'page') { + revealPage(ctx, (count) => done(msg.playerid, 'revealedPage', { count })); + return; + } + + const keys = new Set(selection.hexes.filter((h) => h.pageId === ctx.pageId).map((h) => h.key)); + for (const [r, c] of [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]) { + keys.add(hexKey(r, c)); + } + if (keys.size === 0) { + fail(msg.playerid, 'nothingToReveal'); + return; + } + consumeSourcePaths(selection.paths); + const settings = getPageSettings(ctx.pageId); + let count = 0; + for (const key of keys) { + if (revealHex(ctx, key, settings)) { + count++; + } + } + refreshPage(ctx.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `explore`: reveal around the selected tokens as if they had just moved + * there. Useful after moving tokens with other mods. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandExplore(msg) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const count = selection.tokens.reduce( + (sum, token) => sum + revealAroundToken(token, null, true), + 0 + ); + refreshPage(selection.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `reset page [confirm]`: remove every hex on the page. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReset(msg, args) { + if (args[0] !== 'page') { + fail(msg.playerid, 'unknownCommand', { command: `reset ${args.join(' ')}` }); + return; + } + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const count = getPageHexes(ctx.pageId).length; + if (args[1] !== 'confirm') { + whisper(msg.playerid, tr('titles.confirm'), [ + `
    ${escapeHtml(tr('messages.confirmReset', { count, page: ctx.page.get('name') }))}
    `, + `
    ${buildButton(tr('buttons.confirmReset'), `${COMMAND} reset page confirm`)}
    `, + ]); + return; + } + clearPage(ctx, (removed) => { + refreshPage(ctx.pageId); + done(msg.playerid, 'resetPage', { count: removed }); + }); + } + + /** + * `undo`: reverse the last fill. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandUndo(msg) { + const result = undoLastFill(); + if (!result.ok) { + fail(msg.playerid, result.reason); + return; + } + refreshPage(result.pageId); + done(msg.playerid, 'undone', result); + } + + /** + * `name `: name the selected hexes (or the hexes under selected tokens). + * An empty name clears it. + * + * @param {object} msg Chat message. + * @param {string} rawName Name text. + * @returns {void} + */ + function commandName(msg, rawName) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const keys = new Set(selection.hexes.map((h) => h.key)); + for (const token of selection.tokens) { + const [r, c] = cellsUnderTokens(ctx, [token])[0]; + keys.add(hexKey(r, c)); + } + const hexes = [...keys].map((key) => getHex(ctx.pageId, key)).filter(Boolean); + if (hexes.length === 0) { + fail(msg.playerid, 'noHexes'); + return; + } + for (const hex of hexes) { + setHexName(ctx, hex, rawName); + } + done(msg.playerid, toText(rawName) ? 'named' : 'unnamed', { + count: hexes.length, + name: toText(rawName), + }); + } + + /** + * `mark` / `unmark`: turn the selected tokens into hidden locations, or back. + * + * @param {object} msg Chat message. + * @param {boolean} mark True to mark, false to unmark. + * @returns {void} + */ + function commandMark(msg, mark) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (mark) { + done(msg.playerid, 'marked', markLocations(ctx, selection.tokens)); + } else { + done(msg.playerid, 'unmarked', { count: unmarkLocations(ctx, selection.tokens) }); + } + } + + /** + * `set [key] [value]`: change a global setting, or show the settings card. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandSet(msg, args) { + const [key, ...rest] = args; + if (!key) { + showSettings(msg.playerid); + return; + } + if (!(key in DEFAULT_CONFIG)) { + fail(msg.playerid, 'unknownSetting', { key }); + return; + } + const raw = rest.join(' '); + if (key === 'language' && !raw) { + showLanguages(msg.playerid); + return; + } + const result = setConfigValue(key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + if (key === 'language') { + installHandouts(); + } + if (key === 'hideCoveredTokens') { + if (result.value) { + getPageIds().forEach(refreshPage); + } else { + restoreAll(); + } + } + done(msg.playerid, 'settingChanged', { + setting: tr(`settings.${key}.label`), + value: formatValue(key, result.value), + }); + showSettings(msg.playerid); + } + + /** + * `page [set | clear]`: per-page overrides. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandPage(msg, args) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const [action, key, ...rest] = args; + if (action === 'set') { + if (!PAGE_SETTING_KEYS.includes(key)) { + fail(msg.playerid, 'unknownPageSetting', { + key: key || '', + keys: PAGE_SETTING_KEYS.join(', '), + }); + return; + } + const raw = rest.join(' '); + const result = setPageSetting(ctx.pageId, key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + } else if (action === 'clear') { + clearPageSettings(ctx.pageId); + } else if (action) { + fail(msg.playerid, 'unknownCommand', { command: `page ${args.join(' ')}` }); + return; + } + showPageSettings(msg.playerid, ctx); + } + + /** + * `rescan`: rebuild the page's hex list from the objects on it. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandRescan(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (ctx) { + const counts = rescanPage(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'rescanned', counts); + } + } + + /** + * `calibrate [reset]`: line the grid up with tokens snapped to hex centres. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandCalibrate(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (args[0] === 'reset') { + const counts = resetCalibration(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrationReset', counts); + return; + } + if (selection.tokens.length === 0) { + fail(msg.playerid, 'calibrateNeedsTokens'); + return; + } + const result = calibratePage(ctx, selection.tokens); + if (!result.ok) { + fail(msg.playerid, 'calibrateFailed'); + return; + } + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrated', { + ...result.counts, + colStep: result.calibration.colStep.toFixed(2), + rowStep: result.calibration.rowStep.toFixed(2), + }); + } + + /** + * `journal rebuild`: recreate the help and Command Deck handouts. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandJournal(msg) { + installHandouts(); + done(msg.playerid, 'journalRebuilt', { help: HANDOUT_HELP_NAME, deck: HANDOUT_DECK_NAME }); + } + + // --------------------------------------------------------------------------- + // Cards + // --------------------------------------------------------------------------- + + /** + * Whispers the main menu. + * + * @param {string|null} playerId Player ID (null for every GM). + * @returns {void} + */ + function showMainMenu(playerId) { + const b = (key, cmd) => buildButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + const s = (key, cmd) => buildSecondaryButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + whisper(playerId, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, [ + buildSectionLabel(tr('menu.draw')), + `
    ${b('fill', 'fill')}${b('fillInverse', 'fill inverse')}${s('undo', 'undo')}
    `, + buildSectionLabel(tr('menu.reveal')), + `
    ${b('reveal', 'reveal')}${b('conceal', 'conceal')}${b('explore', 'explore')}
    `, + `
    ${s('revealPage', 'reveal page')}${s('resetPage', 'reset page')}
    `, + buildSectionLabel(tr('menu.locations')), + `
    ${b('mark', 'mark')}${s('unmark', 'unmark')}${b('name', `name ?{${tr('prompts.name')}}`)}
    `, + buildSectionLabel(tr('menu.tools')), + `
    ${s('settings', 'set')}${s('pageSettings', 'page')}${s('status', 'status')}
    `, + `
    ${s('rescan', 'rescan')}${s('calibrate', 'calibrate')}${s('help', 'help')}
    `, + ]); + } + + /** + * Whispers the global settings card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showSettings(playerId) { + const config = getConfig(); + const rows = SETTING_ROWS.map((row) => { + const value = config[row.key]; + const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} set ${row.key} ${settingQuery(row, value)}` + ); + return buildRow(tr(`settings.${row.key}.label`), `${shown} ${button}`); + }); + whisper(playerId, tr('titles.settings'), [ + ...rows, + buildDivider(), + `
    ${escapeHtml(tr('menu.layerInUse', { layer: tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) }))}
    `, + `
    ${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the list of languages. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showLanguages(playerId) { + const buttons = SUPPORTED_LOCALES.map((code) => + buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + ); + whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); + } + + /** + * Whispers a page's settings and overrides. + * + * @param {string} playerId Player ID. + * @param {object} ctx Page context. + * @returns {void} + */ + function showPageSettings(playerId, ctx) { + const overrides = getPageData(ctx.pageId)?.settings || {}; + const effective = getPageSettings(ctx.pageId); + const rows = PAGE_SETTING_KEYS.map((key) => { + const row = SETTING_ROWS.find((r) => r.key === key); + const marker = key in overrides ? ' ★' : ''; + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} page set ${key} ${settingQuery(row, effective[key])}` + ); + return buildRow( + `${tr(`settings.${key}.label`)}${marker}`, + `${escapeHtml(formatValue(key, effective[key]))} ${button}` + ); + }); + whisper(playerId, tr('titles.pageSettings', { page: ctx.page.get('name') }), [ + `
    ${escapeHtml(tr('menu.pageSettingsHelp'))}
    `, + ...rows, + `
    ${buildSecondaryButton(tr('buttons.clearOverrides'), `${COMMAND} page clear`)}${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the status of the current page. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function showStatus(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const hexes = getPageHexes(ctx.pageId); + const data = getPageData(ctx.pageId); + const last = getLastFill(); + const row = (key, value) => buildRow(tr(`status.${key}`), escapeHtml(String(value))); + whisper(msg.playerid, tr('titles.status', { page: ctx.page.get('name') }), [ + row('engine', isJumpgate() ? 'Jumpgate' : 'Legacy'), + row('grid', tr(`values.orientation.${ctx.grid.orientation}`)), + row( + 'layer', + tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) + ), + row('hexes', hexes.length), + row('named', hexes.filter((h) => h.name).length), + row('icons', hexes.filter((h) => h.iconId).length), + row('glimpsed', hexes.filter((h) => h.glimpsed).length), + row('pending', getPendingLocations(ctx.pageId).length), + row('calibrated', tr(data?.calibration ? 'values.on' : 'values.off')), + row('overrides', Object.keys(data?.settings || {}).length), + row('undo', last ? tr(`values.fillKind.${last.kind}`) : tr('values.none')), + ]); + } + + /** + * Whispers the help card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showHelp(playerId) { + const lines = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ]; + const html = lines + .map( + ([cmd, key]) => + `
    ${escapeHtml(`${COMMAND} ${cmd}`.trim())}
    ${escapeHtml(tr(`help.${key}`))}
    ` + ) + .join(''); + whisper(playerId, tr('titles.help'), [ + html, + buildDivider(), + `
    ${escapeHtml(tr('help.handout', { name: HANDOUT_HELP_NAME }))}
    `, + ]); + } + + // --------------------------------------------------------------------------- + // Routing + // --------------------------------------------------------------------------- + + /** + * Routes a parsed command. + * + * @param {object} msg Chat message. + * @param {string} sub Subcommand. + * @param {string[]} args Arguments. + * @param {string} rest Raw text after the subcommand. + * @returns {void} + */ + function routeCommand(msg, sub, args, rest) { + switch (sub) { + case '': + case 'menu': + showMainMenu(msg.playerid); + return; + case 'help': + showHelp(msg.playerid); + return; + case 'fill': + commandFill(msg, args[0] === 'inverse'); + return; + case 'conceal': + case 'hide': + commandConceal(msg); + return; + case 'reveal': + commandReveal(msg, args); + return; + case 'explore': + commandExplore(msg); + return; + case 'reset': + commandReset(msg, args); + return; + case 'undo': + commandUndo(msg); + return; + case 'name': + commandName(msg, rest); + return; + case 'mark': + commandMark(msg, true); + return; + case 'unmark': + commandMark(msg, false); + return; + case 'set': + case 'config': + commandSet(msg, args); + return; + case 'page': + commandPage(msg, args); + return; + case 'rescan': + commandRescan(msg); + return; + case 'calibrate': + commandCalibrate(msg, args); + return; + case 'status': + showStatus(msg); + return; + case 'journal': + commandJournal(msg); + return; + default: + fail(msg.playerid, 'unknownCommand', { command: sub }); + } + } + + /** + * Maps a v1 command to the v2 handlers. + * + * @param {object} msg Chat message. + * @param {string} action Legacy action from LEGACY_COMMANDS. + * @param {string} rest Raw text after the command. + * @returns {void} + */ + function routeLegacy(msg, action, rest) { + const params = rest.split(LEGACY_ARG_SEPARATOR).map((p) => p.trim()); + switch (action) { + case 'fill': + commandFill(msg, false); + return; + case 'fillInverse': + commandFill(msg, true); + return; + case 'menu': + showMainMenu(msg.playerid); + return; + case 'legacyHex': + if (params[0] === 'name') { + commandName(msg, params.slice(1).join(LEGACY_ARG_SEPARATOR)); + } + return; + case 'legacyConfig': { + const [prop, ...values] = params; + // v1 defaults when a colour prompt is left empty. + const updates = { + color: () => ({ + fillColor: values[0] || 'black', + strokeColor: values[1] || 'transparent', + labelColor: values[2] || 'white', + }), + strokeWidth: () => ({ strokeWidth: values[0] || '0' }), + maxDistance: () => ({ maxDistance: values[0] || '' }), + revealDistance: () => ({ revealDistance: values[0] || '0' }), + }[prop]; + if (!updates) { + fail(msg.playerid, 'unknownSetting', { key: prop || '' }); + return; + } + for (const [key, value] of Object.entries(updates())) { + if (!setConfigValue(key, value).valid) { + fail(msg.playerid, 'invalidValue', { key, value }); + } + } + showSettings(msg.playerid); + return; + } + } + } + + /** + * Handles chat input: `!hexploration …` and the v1 commands. GM only. + * + * @param {object} msg Roll20 chat message. + * @returns {void} + */ + function handleInput(msg) { + if (msg.type !== 'api') { + return; + } + const content = toText(msg.content); + const [first] = content.split(/\s+/, 1); + const isMain = first === COMMAND; + const legacy = LEGACY_COMMANDS[first]; + if (!isMain && !legacy) { + return; + } + if (!playerIsGM(msg.playerid)) { + return; + } + + try { + const rest = content.slice(first.length).trim(); + if (legacy) { + routeLegacy(msg, legacy, rest); + return; + } + const [sub = '', ...args] = rest.split(/\s+/).filter(Boolean); + const afterSub = rest.slice(sub.length).trim(); + routeCommand(msg, sub.toLowerCase(), args, afterSub); + } catch (err) { + log(`${SCRIPT_NAME} ERROR: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + fail(msg.playerid, 'unexpected', { message: err?.message || String(err) }); + } + } + + let ready = false; + + /** + * Runs a handler, logging instead of crashing the sandbox on errors. + * + * @param {string} label Handler name for the log. + * @param {Function} fn Handler. + * @returns {Function} Wrapped handler. + */ + function guarded(label, fn) { + return (...args) => { + if (!ready) { + return; + } + try { + fn(...args); + } catch (err) { + log(`${SCRIPT_NAME} ERROR in ${label}: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }; + } + + /** + * Forgets a hex whose path was deleted by hand. + * + * @param {object} path Deleted Roll20 path. + * @returns {void} + */ + function handlePathDestroyed(path) { + const found = getHexByPathId(path.get('_id')); + if (found) { + removeLabel(found.hex); + deleteHexRecord(found.pageId, found.key); + refreshPage(found.pageId); + } + } + + /** + * Forgets a deleted token as a pending location or hidden token. + * + * @param {object} token Deleted Roll20 graphic. + * @returns {void} + */ + function handleGraphicDestroyed(token) { + setPendingLocation(token.get('_id'), null); + delete getCoveredTokens()[token.get('_id')]; + } + + /** + * Forgets a deleted page's hexes. + * + * @param {object} page Deleted Roll20 page. + * @returns {void} + */ + function handlePageDestroyed(page) { + const pageId = page.get('_id'); + if (getPageIds().includes(pageId)) { + deletePageData(pageId); + } + } + + /** + * Registers with TokenMod (if installed) so tokens it moves reveal hexes; + * the API does not raise change events for moves made by other mods. + * + * @returns {void} + */ + function observeOtherMods() { + if (typeof TokenMod !== 'undefined' && typeof TokenMod?.ObserveTokenChange === 'function') { + TokenMod.ObserveTokenChange(guarded('TokenMod observer', handleTokenChange)); + } + } + + /** + * Publishes the API other mods can call. + * + * @returns {void} + */ + function publishApi() { + globalThis.Hexploration = Object.freeze({ + version: SCRIPT_VERSION, + /** + * Reveals around a token as if it had just moved, for mods that move tokens. + * + * @param {object|string} tokenOrId Roll20 graphic or its ID. + * @param {object} [prev] Previous left/top, to reveal along the route. + * @returns {number} Number of hexes revealed or glimpsed. + */ + revealAround(tokenOrId, prev = null) { + const token = typeof tokenOrId === 'string' ? getObj('graphic', tokenOrId) : tokenOrId; + if (!ready || !token) { + return 0; + } + try { + const changed = revealAroundToken(token, prev); + refreshPage(token.get('_pageid')); + return changed; + } catch (err) { + log(`${SCRIPT_NAME} ERROR in revealAround: ${err?.message || err}`); + return 0; + } + }, + }); + } + + /** + * Startup: migrate state, clean up, install handouts and greet the GM. + * + * @returns {void} + */ + function checkInstall() { + const migratedFrom = initialiseState(); + applyGlobalConfig(); + const pruned = pruneMissingHexes(); + for (const pageId of new Set([ + ...getPageIds(), + ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), + ])) { + refreshPage(pageId); + } + installHandouts(); + registerEngineHandlers(); + observeOtherMods(); + publishApi(); + ready = true; + + log( + `-=> ${SCRIPT_NAME} v${SCRIPT_VERSION} [Updated: ${SCRIPT_LAST_UPDATED}] (${isJumpgate() ? 'Jumpgate' : 'Legacy'}) <=-` + ); + + const lang = getConfig().language; + const lines = [`
    ${escapeHtml(t('titles.ready', lang))}
    `]; + if (migratedFrom === 1) { + lines.push(`
    ${escapeHtml(t('messages.migrated', lang))}
    `); + } + if (pruned.dropped > 0) { + lines.push( + `
    ${escapeHtml(t('messages.pruned', lang, pruned))}
    ` + ); + } + lines.push( + `
    ${escapeHtml(t('messages.readyHint', lang))}
    ` + ); + whisper(null, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, lines); + if (migratedFrom === 1 || pruned.dropped > 0) { + showMainMenu(null); + } + } + + /** + * Registers all Roll20 event handlers. + * + * @returns {void} + */ + function registerEventHandlers() { + on('ready', () => { + try { + checkInstall(); + } catch (err) { + log(`${SCRIPT_NAME} ERROR during startup: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }); + on('chat:message', (msg) => { + if (ready) { + handleInput(msg); + } + }); + on('change:graphic', guarded('change:graphic', handleTokenChange)); + on('add:graphic', guarded('add:graphic', refreshToken)); + on('destroy:graphic', guarded('destroy:graphic', handleGraphicDestroyed)); + on('destroy:page', guarded('destroy:page', handlePageDestroyed)); + on(`destroy:${PATH_TYPE_LEGACY}`, guarded('destroy:path', handlePathDestroyed)); + } + + /** + * Registers handlers that depend on the game engine. pathv2 objects only + * exist in Jumpgate, and the engine is only known once the game has loaded. + * + * @returns {void} + */ + function registerEngineHandlers() { + if (isJumpgate()) { + on(`destroy:${PATH_TYPE_V2}`, guarded('destroy:pathv2', handlePathDestroyed)); + } + } + + registerEventHandlers(); +})(); diff --git a/Hexploration/script.json b/Hexploration/script.json index abc01ed38d..9efd9c3ea7 100644 --- a/Hexploration/script.json +++ b/Hexploration/script.json @@ -1,13 +1,82 @@ { - "name": "Hexploration", - "script": "Hexploration.js", - "version": "1.3", - "previousversions": ["1.0", "1.1", "1.2"], - "description": "# Hexploration\r\r_v1.3 Updates:_\r* Fixed a couple state bugs.\r\rThis script allows GMs to draw a polygon on a hex-gridded map and fill in\reach hex inside that polygon with an opaque hexagon. It's great for hex-based\rmaps where the PCs must explore and discover each area hex by hex.\r\r## General Usage\r\rThis script's actions and configurations are accessible through its menu\rdisplayed in the chat (Visible only to the GM).\rTo open the script's menu, activate the 'Hexploration_menu' macro installed\rby the script.\r\rNote that this script only works for maps whose grid types are set to either\r'Hex (V)' or 'Hex (H)'. The opaque hexes will be aligned to the page's hex\rgrid.\r\rWhen you move a token representing a character into an area concealed by a hex,\rthe hex will be revealed. If the script's reveal distance is set greater than 0,\rthen adjacent hexes out to that distance (in hex units) will also be revealed.\r\rWatch https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif\rfor a short demo of the basics of how the script works.\r\r### Rendering Hexes\r\rTo create a hex-filled area, first draw one or more polygons containing the\rarea you want filled with hexes. Then select the polygons and press the\r'Fill Polygon' action from the script's menu. That's it!\r\r### Naming Hexes\r\rHexes can be named to represent locations that are concealing. The names of\rthe hexes will be shown on the GM layer, invisible to the PCs. When a named\rhex is revealed, it will announce that its location has been discovered in the\rchat.\r\rThere are two ways to name locations hidden by hexes:\r\rBefore rendering the hexes using the 'Fill Polygon' action, create named tokens\rwith the 'white-tower' status representing the locations you want to conceal\rwith the hexes. This will also set the icon for the hex to that of the named\rtoken.\r\rTo name a hex that's already been rendered, select the hex and set its name\rusing the 'Name Hex' action from the menu.\r\r### Setting a Hex's Icon\r\rHexes can be assigned a named icon. The icon will be hidden on the GM layer,\rand it and its name will be revealed when its hex is revealed.\r\rTo make a hex with an icon, create a named token with the 'white-tower' status\rrepresenting the location you want to conceal within a hex. Then fill the area\rcontaining that token with hexes. It will be automatically concealed and\rassigned to the hex it was in.\r\r## Actions\r\rThe script contains the following actions available from the script's chat menu:\r\r### Fill Polygon\r\rThis renders hexes within one more more polygon areas.\rSelect one or more polygons, then use this action to fill their areas with\rhexes.\r\r### Inverse Fill\r\rThis works like the 'Fill Polygon' action, except that it renders hexes\reverywhere on the page except inside the selected polygons' areas instead.\r\r### Name Hex\r\rThis allows you to name a hex after it has been rendered. Select the hex you\rwant to name, then use this action to specify a name for it.\r\r## Configurations\r\rThe script contains the following configurations that can be set from the\rscript's chat menu:\r\r### Drawing configs\r\rThese configurations set properties for hexes as you are drawing them.\r\r#### Hex Color\r\rThis allows you to specify the color, border color, and label color of hexes.\r\r#### Border Width\r\rThis sets the width of the border outlines on hexes.\r\r#### Hex Reveal Distance\r\rIf this is set, then a character can only reveal the hexes being drawn if they\rare within the specified number of hexes away from them.\r\rE.g., if a hex is drawn while this config is set to 3, then a character must be\rwithin 3 hexes from it to reveal it. The hex will not be revealed if the\rcharacter is 4 or more hexes away from it, even if the global reveal distance\ris set very high.\r\rIf this is not set, then the hex can be revealed from a theoretically infinite\rdistance away (out to the line of sight distance).\r\r### Global configs\r\rThese configs apply globally throughout the use of this script.\r\r#### Line of Sight\r\rThis is the global reveal distance. It specifies how far out (in units) hexes\rare revealed when a character token is moved.\r\r## Help\r\rMy scripts are provided 'as-is', without warranty of any kind, expressed or implied.\r\rThat said, if you experience any issues while using this script,\rneed help using it, or if you have a neat suggestion for a new feature,\rplease shoot me a PM:\rhttps://app.roll20.net/users/46544/ada-l\r\rWhen messaging me about an issue, please be sure to include any error messages that\rappear in your API Console Log, any configurations you've got set up for the\rscript in the VTT, and any options you've got set up for the script on your\rgame's API Scripts page. The more information you provide me, the better the\rchances I'll be able to help.\r\r## Show Support\r\rIf you would like to show your appreciation and support for the work I do in writing,\rupdating, maintaining, and providing tech support my API scripts,\rplease consider buying one of my art packs from the Roll20 marketplace:\r\rhttps://marketplace.roll20.net/browse/publisher/165/ada-lindberg\r", - "authors": "Ada Lindberg", - "roll20userid": 46544, - "useroptions": [], - "dependencies": ["HTML Builder", "MatrixMath", "Path Math", "Vector Math"], - "modifies": {}, - "conflicts": [] + "name": "Hexploration", + "script": "Hexploration.js", + "version": "2.0.0", + "previousversions": [ + "1.0", + "1.1", + "1.2", + "1.3" + ], + "description": "# Hexploration\n\nCover a hex map with opaque hexes that are revealed as the party explores. Draw a polygon over the area to hide, fill it with hexes, and every hex a player token moves through (and, optionally, the hexes around it) is uncovered. Hidden locations are announced in chat when they are discovered.\n\n**Version 2.0.0 is a full rewrite that works in Jumpgate and in Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. Existing v1 hex maps and the v1 `!hexploration_*` commands keep working.\n\n## Getting started\n\n1. Use a page with a **Hex (V)** or **Hex (H)** grid.\n2. Draw one or more polygons over the area to hide and select them.\n3. Type `!hexploration fill`, or open the **Hexploration - Command Deck** handout and click **Fill**.\n4. Move a player token and watch the map open up.\n\nType `!hexploration` for the menu, or `!hexploration help` for every command. The **Hexploration - Help** handout is created in the Journal on startup.\n\n## Features\n\n* Works with Jumpgate (`pathv2`) and Legacy paths, on both hex grid orientations and any cell size.\n* Hexes are drawn on the foreground layer when the game has one, otherwise on the token layer.\n* Reveals along the whole path a token travels, covers every hex a large token occupies, and respects line of sight.\n* Optional glimpse mode: nearby hexes turn see-through and clear when a token enters them.\n* Named locations and hidden location tokens, announced (and optionally pinged) when discovered.\n* Reveal or re-cover selected hexes, reveal or clear a page, undo the last fill, and per-page settings.\n* Rescan rebuilds the hex list after a page is duplicated or a Legacy game is copied to Jumpgate.\n* Grid calibration for maps whose hexes do not line up.\n* Translated into 24 languages.\n\nOriginal mod by Ada Lindberg. Version 2 is maintained by MidNiteShadow7.", + "authors": "Ada Lindberg, MidNiteShadow7", + "roll20userid": "46544, 16506286", + "useroptions": [ + { + "name": "hexLayer", + "displayname": "Hex Layer", + "type": "select", + "options": [ + "auto", + "foreground", + "objects" + ], + "default": "auto", + "description": "Where new hexes are drawn. Auto uses the foreground layer when the game supports it, otherwise the token (objects) layer." + }, + { + "name": "revealBy", + "displayname": "Tokens That Reveal", + "type": "select", + "options": [ + "players", + "characters", + "all" + ], + "default": "players", + "description": "Which tokens on the token layer reveal hexes when they move: players (controlled by a player), characters (represent any character, the v1 behaviour) or all tokens." + }, + { + "name": "language", + "displayname": "Language", + "type": "select", + "options": [ + "af", + "ca", + "zh-TW", + "cs", + "da", + "nl", + "en-US", + "fi", + "fr", + "de", + "el", + "he", + "hu", + "it", + "ja", + "ko", + "pl", + "pt-PT", + "pt-BR", + "ru", + "es", + "sv", + "tr", + "uk" + ], + "default": "en-US", + "description": "Language code for GM messages, menus and handouts. Run !hexploration set language to see all supported codes." + } + ], + "dependencies": [], + "modifies": { + "path": "read,write", + "pathv2": "read,write", + "graphic": "read,write", + "text": "read,write", + "handouts": "read,write" + }, + "conflicts": [] } From 91a261ae6f205263058d7512b3dbdb8e571369fb Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 08:29:14 +0000 Subject: [PATCH 06/24] feat(Hexploration): Translate into 23 languages The locale files committed with the rewrite were mostly English stubs, so every language other than English fell back to the en-US strings. Machine-translate the full en-US set into the other 23 locales, re-translating the count messages that were reworded to the "Label: n" style and the new covered-token strings. Strings the translator returned in English or half-translated were retranslated; those left matching English are shared words or Roll20's own names, such as "Status" and "Hex (V)". Format the locale files with the project's Prettier settings, and rebuild the script and the 2.0.0 snapshot so they carry the translations. Signed-off-by: Steve Roberts --- Hexploration/2.0.0/Hexploration.js | 7017 +++++++++++++++++++++- Hexploration/Hexploration.js | 7017 +++++++++++++++++++++- Hexploration/src/locales/locale/af.js | 386 +- Hexploration/src/locales/locale/ca.js | 359 +- Hexploration/src/locales/locale/cs.js | 483 +- Hexploration/src/locales/locale/da.js | 467 +- Hexploration/src/locales/locale/de.js | 383 +- Hexploration/src/locales/locale/el.js | 376 +- Hexploration/src/locales/locale/es.js | 378 +- Hexploration/src/locales/locale/fi.js | 374 +- Hexploration/src/locales/locale/fr.js | 379 +- Hexploration/src/locales/locale/he.js | 366 +- Hexploration/src/locales/locale/hu.js | 377 +- Hexploration/src/locales/locale/it.js | 377 +- Hexploration/src/locales/locale/ja.js | 372 +- Hexploration/src/locales/locale/ko.js | 370 +- Hexploration/src/locales/locale/nl.js | 376 +- Hexploration/src/locales/locale/pl.js | 374 +- Hexploration/src/locales/locale/pt-BR.js | 374 +- Hexploration/src/locales/locale/pt-PT.js | 374 +- Hexploration/src/locales/locale/ru.js | 375 +- Hexploration/src/locales/locale/sv.js | 370 +- Hexploration/src/locales/locale/tr.js | 373 +- Hexploration/src/locales/locale/uk.js | 376 +- Hexploration/src/locales/locale/zh-TW.js | 481 +- 25 files changed, 21532 insertions(+), 1422 deletions(-) diff --git a/Hexploration/2.0.0/Hexploration.js b/Hexploration/2.0.0/Hexploration.js index 87a8b34aff..684e4bf2a0 100644 --- a/Hexploration/2.0.0/Hexploration.js +++ b/Hexploration/2.0.0/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T02:20:55.900Z + * Built: 2026-10-29T08:23:06.249Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T02:20:55.900Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T08:23:06.249Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1102,7 +1102,7 @@ const HexplorationMod = (() => { return calibration; } - const TRANSLATION$4 = { + const TRANSLATION$m = { titles: { ready: 'Heeksplorasie is gereed.', settings: 'Heksplorasie-instellings', @@ -1245,6 +1245,10 @@ const HexplorationMod = (() => { label: 'Ping Ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, + hideCoveredTokens: { + label: 'Versteek bedekte tekens', + desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + }, }, status: { engine: 'Spel enjin', @@ -1261,31 +1265,31 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.', - revealed: '{count} hekkies geopenbaar.', - revealedPage: 'Alle {count} hekse op die bladsy is geopenbaar.', + 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Hekse geopenbaar: {count}.', + revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', confirmReset: - 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: '{count} hekse van die bladsy verwyder.', + 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Hekse verwyder van die bladsy: {count}.', undone: - 'Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.', - named: '{count} heksies genaamd "{name}".', - unnamed: 'Naam verwyder van {count} hekse.', + 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', + named: 'Hekse genaamd "{name}": {count}.', + unnamed: 'Name skoongemaak: {count}.', marked: - '{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.', - unmarked: '{count} tekens is nie meer liggings nie.', + 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', + unmarked: 'Tekens wat nie meer liggings is nie: {count}.', settingChanged: '{setting} gestel na {value}.', rescanned: - "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', calibrated: - 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', calibrationReset: - 'Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", pruned: - '{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', readyHint: 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, @@ -1293,14 +1297,14 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', someFailed: - '{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.', + 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', }, errors: { noPage: 'Kon nie die bladsy vind om aan te werk nie.', notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", noPolygons: 'Kies een of meer getekende vorms om te vul.', emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', - tooMany: 'Dit sal {count} hexes skep, wat te veel in een slag is.', + tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', noTokens: 'Kies eers een of meer tekens.', @@ -1405,6 +1409,7 @@ const HexplorationMod = (() => { "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { @@ -1471,7 +1476,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$3 = { + const TRANSLATION$l = { titles: { ready: "L'exploració està a punt.", settings: "Configuració d'exploració", @@ -1614,6 +1619,10 @@ const HexplorationMod = (() => { label: 'Ping Descobriments', desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', }, + hideCoveredTokens: { + label: 'Amaga les fitxes cobertes', + desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + }, }, status: { engine: 'Motor de joc', @@ -1630,31 +1639,31 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.', - revealed: '{count} hexadecimals revelats.', - revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + revealed: 'Hexagones revelats: {count}.', + revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", confirmReset: - 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: '{count} hexadecimals eliminats de la pàgina.', + 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', undone: - 'Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.', - named: '{count} hexadecimals anomenats "{name}".', - unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + named: 'Hexadecimals anomenats "{name}": {count}.', + unnamed: 'Noms esborrats: {count}.', marked: - "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", - unmarked: 'Les fitxes {count} ja no són ubicacions.', + 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", calibrated: - 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.', + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", pruned: - "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", readyHint: 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', }, @@ -1662,14 +1671,14 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', someFailed: - "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", + tooMany: "Això crearia massa hexagones d'una vegada ({count}).", nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', noTokens: 'Seleccioneu primer un o més fitxes.', @@ -1776,6 +1785,7 @@ const HexplorationMod = (() => { "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { @@ -1842,7 +1852,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$2 = { + const TRANSLATION$k = { titles: { ready: 'H探索已準備就緒。', settings: 'H探索設置', @@ -1901,7 +1911,7 @@ const HexplorationMod = (() => { }, revealBy: { players: '玩家代幣', - characters: 'Character tokens', + characters: '字元標記', all: '所有代幣', }, revealMode: { @@ -1984,6 +1994,10 @@ const HexplorationMod = (() => { label: '平發現', desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', }, + hideCoveredTokens: { + label: '隱藏覆蓋的令牌', + desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + }, }, status: { engine: '遊戲引擎', @@ -1999,40 +2013,40 @@ const HexplorationMod = (() => { undo: '可以撤銷', }, messages: { - filled: '填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。', - revealed: '{count} 十六進位顯示。', - revealedPage: '顯示頁面上的所有 {count} 十六進位。', + filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', + revealed: '六角形顯示：{count}。', + revealedPage: '顯示頁面上的每個十六進位 ({count})。', confirmReset: - '從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。', - resetPage: '從頁面中刪除了 {count} 十六進位。', - undone: '上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。', - named: '{count} 名為「{name}」的十六進位。', - unnamed: '從 {count} 十六進位清除名稱。', - marked: '{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。', - unmarked: '{count} 標記不再是位置。', + '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', + resetPage: '從頁面中刪除的十六進位：{count}。', + undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', + named: '名為「{name}」的六角形：{count}。', + unnamed: '已清除的名稱：{count}。', + marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', + unmarked: '不再是位置的標記：{count}。', settingChanged: '{setting} 設定為 {value}。', rescanned: - '重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_', + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', calibrated: - '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', - calibrationReset: '校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', - journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', pruned: - '{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', + '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', }, warnings: { foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', - someFailed: '無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。', + someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', }, errors: { noPage: '找不到要處理的頁面。', notHex: '此頁面不使用六角網格。', noPolygons: '選擇一個或多個要填滿的繪製形狀。', emptyArea: '所選區域不包含任何六角形中心。', - tooMany: '這會建立 {count} 六角形，一次性就太多了。', + tooMany: '這會一次建立太多的六角形 ({count})。', nothingToConceal: '選擇要隱藏的繪製形狀或標記。', nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', noTokens: '首先選擇一個或多個令牌。', @@ -2064,7 +2078,7 @@ const HexplorationMod = (() => { menu: '顯示選單。', fill: '用六角形覆蓋選定的繪製形狀。', fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', - undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', revealPage: '顯示頁面上的每個十六進制，無需公告。', conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', @@ -2128,6 +2142,7 @@ const HexplorationMod = (() => { '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', ], }, locations: { @@ -2175,8 +2190,8 @@ const HexplorationMod = (() => { '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', - 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', - 'For anything else, check the API console log and include its messages when asking for help.', + 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { @@ -2194,7 +2209,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$1 = { + const TRANSLATION$j = { titles: { ready: 'Heexploration je připraven.', settings: 'Nastavení Heexploration', @@ -2337,6 +2352,10 @@ const HexplorationMod = (() => { label: 'Ping Discovery', desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', }, + hideCoveredTokens: { + label: 'Skryjte kryté žetony', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + }, }, status: { engine: 'Herní engine', @@ -2353,45 +2372,46 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.', - revealed: '{count} odhalených hexů.', - revealedPage: 'Všechny {count} hexy na stránce odhaleny.', + 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + revealed: 'Odhalené hexy: {count}.', + revealedPage: 'Každé odhalené hex na stránce ({count}).', confirmReset: - 'Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', - resetPage: '{count} hexy odstraněny ze stránky.', + 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - 'Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.', - named: '{count} hexy s názvem „{name}“.', - unnamed: 'Název byl vymazán z {count} hexů.', + 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + named: 'Hexusy s názvem „{name}“: {count}.', + unnamed: 'Jména vymazána: {count}.', marked: - '{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.', - unmarked: '{count} tokeny již nejsou umístění.', + 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', + unmarked: 'Tokeny, které již nejsou umístěními: {count}.', settingChanged: '{setting} nastaveno na {value}.', rescanned: - 'Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.', + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', calibrationReset: - 'Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', pruned: - '{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', readyHint: 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', }, warnings: { foregroundUnavailable: 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', - someFailed: '{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.', + someFailed: + 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', - tooMany: 'To by vytvořilo {count} hexů, což je příliš mnoho najednou.', + tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', noTokens: 'Nejprve vyberte jeden nebo více žetonů.', @@ -2493,6 +2513,7 @@ const HexplorationMod = (() => { 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', ], }, locations: { @@ -2559,7 +2580,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION = { + const TRANSLATION$i = { titles: { ready: 'Hexploration er klar.', settings: 'Indstillinger for Hexploration', @@ -2671,7 +2692,7 @@ const HexplorationMod = (() => { desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: 'Hex Reveal Distance', + label: 'Hex afsløre afstand', desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { @@ -2691,7 +2712,7 @@ const HexplorationMod = (() => { desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { - label: 'Reveal Mode', + label: 'Afsløringstilstand', desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', }, announce: { @@ -2702,6 +2723,10 @@ const HexplorationMod = (() => { label: 'Ping opdagelser', desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', }, + hideCoveredTokens: { + label: 'Skjul dækkede tokens', + desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + }, }, status: { engine: 'Spil motor', @@ -2718,45 +2743,45 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.', - revealed: '{count} hexes afsløret.', - revealedPage: 'Alle {count} hexes på siden afsløret.', + 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexer afsløret: {count}.', + revealedPage: 'Hver hex på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: '{count} sekskanter fjernet fra siden.', + 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexer fjernet fra siden: {count}.', undone: - 'Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.', - named: '{count} hexes med navnet "{name}".', - unnamed: 'Navnet er ryddet fra {count} hexes.', + 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', + named: 'Hexer med navnet "{name}": {count}.', + unnamed: 'Navne ryddet: {count}.', marked: - '{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.', - unmarked: '{count} tokens er ikke længere placeringer.', + 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + unmarked: 'Tokens, der ikke længere er placeringer: {count}.', settingChanged: '{setting} indstillet til {value}.', rescanned: - 'Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.', + 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.', + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', calibrationReset: - 'Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', pruned: - '{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', readyHint: 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', }, warnings: { foregroundUnavailable: 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', - someFailed: '{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.', + someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { noPage: 'Kunne ikke finde siden at arbejde på.', notHex: 'Denne side bruger ikke et hex-gitter.', noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', emptyArea: 'Det valgte område indeholder ingen hex-centre.', - tooMany: 'Det ville skabe {count} hexes, hvilket er for mange på én gang.', + tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', noTokens: 'Vælg først et eller flere tokens.', @@ -2859,6 +2884,7 @@ const HexplorationMod = (() => { 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", ], }, locations: { @@ -2915,7 +2941,7 @@ const HexplorationMod = (() => { body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', }, credits: { - heading: 'Credits', + heading: 'Kreditter', original: 'Original mod af', maintainer: 'Version 2 vedligeholdes af', marketplace: 'Adas kunstpakker på Roll20 Marketplace', @@ -2925,7 +2951,380 @@ const HexplorationMod = (() => { }, }; - var localeNl = {}; + const TRANSLATION$h = { + titles: { + ready: 'Hexploratie is klaar.', + settings: 'Hexploratie-instellingen', + languages: 'Kies een taal', + pageSettings: 'Pagina-instellingen: {page}', + status: 'Hverkenningsstatus: {page}', + help: 'Hexploratie-opdrachten', + confirm: 'Bevestig alstublieft', + }, + discovery: { + title: 'Locatie ontdekt', + }, + menu: { + draw: 'Tekenen', + reveal: 'Onthullen en verbergen', + locations: 'Locaties', + tools: 'Hulpmiddelen', + layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + pageSettingsHelp: + 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', + }, + buttons: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + undo: 'Vulling ongedaan maken', + reveal: 'Onthullen', + conceal: 'Maskeren', + explore: 'Ontdekken', + revealPage: 'Pagina onthullen', + resetPage: 'Pagina opnieuw instellen', + mark: 'Markeer locatie', + unmark: 'Markering opheffen', + name: 'Naam Hex', + settings: 'Instellingen', + pageSettings: 'Pagina-instellingen', + status: 'Status', + rescan: 'Opnieuw scannen', + calibrate: 'Kalibreren', + calibrateReset: 'Kalibratie opnieuw instellen', + help: 'Hulp', + change: 'Wijziging', + menu: 'Menu', + clearOverrides: 'Wis overschrijvingen', + confirmReset: 'Ja, verwijder alle vakjes', + }, + prompts: { + name: 'Locatienaam (leeg laten om te wissen)', + }, + values: { + on: 'Op', + off: 'Uit', + none: 'Geen', + hexLayer: { + auto: 'Automatisch (voorgrond indien beschikbaar)', + foreground: 'voorgrond laag', + objects: 'token laag', + }, + revealBy: { + players: 'Spelerfiches', + characters: 'Karakterfiches', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Duidelijk', + glimpse: 'Glimp', + }, + announce: { + all: 'Iedereen', + gm: 'Alleen GM', + off: 'Uit', + }, + orientation: { + vertical: 'Zeskant (V)', + horizontal: 'Zeskant (H)', + }, + fillKind: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + conceal: 'Maskeren', + }, + }, + settings: { + language: { + label: 'Taal', + desc: "Taal voor menu's, berichten en hand-outs.", + }, + hexLayer: { + label: 'Hex-laag', + desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van de omtrek van nieuwe vakjes.', + }, + labelColor: { + label: 'Etiketkleur', + desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + }, + glimpseColor: { + label: 'Glimp kleur', + desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + }, + strokeWidth: { + label: 'Randbreedte', + desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Hex onthullen afstand', + desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', + }, + revealDistance: { + label: 'Zicht afstand', + desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + }, + lineOfSight: { + label: 'Zichtlijn', + desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', + }, + revealPath: { + label: 'Onthul langs het pad', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + }, + revealBy: { + label: 'Tokens die onthullen', + desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + }, + revealMode: { + label: 'Onthullingsmodus', + desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + }, + announce: { + label: 'Ontdekkingen aankondigen', + desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + }, + pingDiscoveries: { + label: 'Ping-ontdekkingen', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + }, + hideCoveredTokens: { + label: 'Verberg afgedekte tokens', + desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + }, + }, + status: { + engine: 'Game-engine', + grid: 'Rooster', + layer: 'Hex-laag', + hexes: 'Hexen', + named: 'Genoemde hexen', + icons: 'Locatiefiches', + glimpsed: 'Glimp van hexen', + pending: 'Locaties die wachten op vulling', + calibrated: 'Gekalibreerd', + overrides: 'Pagina-overschrijvingen', + undo: 'Ongedaan maken beschikbaar', + }, + messages: { + filled: + 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Hexen onthuld: {count}.', + revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + confirmReset: + 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Hexes verwijderd van de pagina: {count}.', + undone: + 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', + named: 'Hexen met de naam "{name}": {count}.', + unnamed: 'Namen gewist: {count}.', + marked: + 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + unmarked: 'Tokens die niet langer locaties zijn: {count}.', + settingChanged: '{setting} ingesteld op {value}.', + rescanned: + 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + calibrated: + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + calibrationReset: + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', + migrated: + 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + pruned: + 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + readyHint: + 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + someFailed: + 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + }, + errors: { + noPage: 'Kon de pagina niet vinden om aan te werken.', + notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', + noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', + emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', + tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', + nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + noTokens: 'Selecteer eerst een of meer tokens.', + noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', + unknownCommand: 'Onbekend commando: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellingen die per pagina kunnen worden ingesteld: {keys}', + invalidValue: '"{value}" is geen geldige waarde voor {key}.', + calibrateNeedsTokens: + 'Selecteer een of twee tokens die op de middelpunten van de zeshoeken zijn vastgemaakt.', + calibrateFailed: 'Deze tokens kunnen niet worden gebruikt om te kalibreren.', + unexpected: 'Er is iets misgegaan: {message}', + }, + hints: { + noPage: 'Open de pagina waaraan u wilt werken of selecteer er iets op.', + notHex: 'Stel het paginaraster in op Hex (V) of Hex (H) in Pagina-instellingen.', + noPolygons: + 'Teken een veelhoek, rechthoek, ellips of vorm uit de vrije hand rond het gebied, selecteer het en probeer het opnieuw.', + emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', + tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', + noHexes: + 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', + unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', + calibrateNeedsTokens: + 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + calibrateFailed: + 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', + unexpected: 'Details staan ​​in het API-consolelogboek.', + }, + help: { + menu: 'Laat de menukaart zien.', + fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', + undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + reveal: + 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', + revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', + explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', + resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', + name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + mark: 'Verander de geselecteerde tokens in verborgen locaties.', + unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', + set: 'Wijzig een instelling of toon alle instellingen.', + pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', + pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', + rescan: + 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + calibrate: + 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', + status: 'Laat zien wat Hexploration weet over de huidige pagina.', + journal: 'Herbouw de Help- en Command Deck-hand-outs.', + help: 'Laat deze lijst zien.', + handout: 'Volledige instructies vindt u in de hand-out "{name}".', + }, + deck: { + subtitle: 'Commandodek', + drawDesc: + 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + revealDesc: + 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + locationsDesc: + 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + toolsDesc: + "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", + footer: 'Zie de hand-out "{help}" voor volledige instructies.', + }, + handout: { + versionLabel: 'Versie', + subtitle: 'Hex-voor-hex verkenning voor Roll20', + footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', + overview: { + heading: 'Overzicht', + body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + demo: 'Bekijk een korte demo (vanaf versie 1)', + }, + quickStart: { + heading: 'Snel beginnen', + steps: [ + 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', + 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', + 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + ], + }, + commands: { + heading: "Commando's", + intro: + "Alleen GM's kunnen deze commando's gebruiken. De meeste werken op de geselecteerde objecten; de rest handelt op de pagina die u bekijkt.", + colCommand: 'Commando', + colDesc: 'Wat het doet', + }, + revealing: { + heading: 'Hoe onthullen werkt', + points: [ + 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", + 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', + 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', + 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + ], + }, + locations: { + heading: 'Genoemde velden en locaties', + points: [ + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', + 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', + 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + ], + }, + settings: { + heading: 'Instellingen', + intro: + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beschrijving', + perPage: '(Kan per pagina worden ingesteld.)', + }, + jumpgate: { + heading: 'Jumpgate en erfenis', + points: [ + 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', + 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', + "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + ], + }, + upgrading: { + heading: 'Upgraden vanaf versie 1', + points: [ + 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', + 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', + 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + ], + colV1: 'Versie 1-opdracht', + colV2: 'Versie 2-opdracht', + }, + troubleshooting: { + heading: 'Problemen oplossen', + points: [ + 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', + 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', + 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', + 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', + ], + }, + languages: { + heading: 'Talen', + body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + }, + credits: { + heading: 'Kredieten', + original: 'Originele mod door', + maintainer: 'Versie 2 onderhouden door', + marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", + support: + 'Als je een bug vindt of een idee hebt, plaats dan een bericht op het Roll20 Mod-forum of open een probleem op GitHub, en voeg eventuele berichten uit het API-consolelogboek toe.', + }, + }, + }; var localeEnUS = { titles: { @@ -3294,39 +3693,6353 @@ const HexplorationMod = (() => { }, }; - var localeFi = {}; - - var localeFr = {}; - - var localeDe = {}; - - var localeEl = {}; - - var localeHe = {}; - - var localeHu = {}; - - var localeIt = {}; - - var localeJa = {}; - - var localeKo = {}; - - var localePl = {}; - - var localePtPT = {}; - - var localePtBR = {}; - - var localeRu = {}; - - var localeEs = {}; - - var localeSv = {}; - - var localeTr = {}; - - var localeUk = {}; + const TRANSLATION$g = { + titles: { + ready: 'Hexploration on valmis.', + settings: 'Tutkimusasetukset', + languages: 'Valitse kieli', + pageSettings: 'Sivuasetukset: {page}', + status: 'Tutkimuksen tila: {page}', + help: 'Hexploration komennot', + confirm: 'Ole hyvä ja vahvista', + }, + discovery: { + title: 'Sijainti löydetty', + }, + menu: { + draw: 'Piirrä', + reveal: 'Paljasta ja piilota', + locations: 'Sijainnit', + tools: 'Työkalut', + layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + pageSettingsHelp: + 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', + }, + buttons: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + undo: 'Kumoa täyttö', + reveal: 'Paljastaa', + conceal: 'Salata', + explore: 'Tutkia', + revealPage: 'Paljasta sivu', + resetPage: 'Nollaa sivu', + mark: 'Merkitse sijainti', + unmark: 'Poista merkintä', + name: 'Nimi Hex', + settings: 'Asetukset', + pageSettings: 'Sivun asetukset', + status: 'Status', + rescan: 'Skannaa uudelleen', + calibrate: 'Kalibroida', + calibrateReset: 'Nollaa kalibrointi', + help: 'Auttaa', + change: 'Muuttaa', + menu: 'Valikko', + clearOverrides: 'Tyhjennä ohitukset', + confirmReset: 'Kyllä, poista kaikki heksit', + }, + prompts: { + name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', + }, + values: { + on: 'Päällä', + off: 'Pois', + none: 'Ei mitään', + hexLayer: { + auto: 'Automaattinen (etualalla, jos saatavilla)', + foreground: 'etualan kerros', + objects: 'merkkikerros', + }, + revealBy: { + players: 'Pelaajan merkit', + characters: 'Hahmomerkit', + all: 'Kaikki merkit', + }, + revealMode: { + clear: 'Selkeä', + glimpse: 'Vilkkaus', + }, + announce: { + all: 'Kaikki', + gm: 'Vain GM', + off: 'Pois', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + conceal: 'Salata', + }, + }, + settings: { + language: { + label: 'Kieli', + desc: 'Valikkojen, viestien ja monisteiden kieli.', + }, + hexLayer: { + label: 'Hex kerros', + desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + }, + fillColor: { + label: 'Täyttöväri', + desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Reunuksen väri', + desc: 'Uusien kuusioiden ääriviivan väri.', + }, + labelColor: { + label: 'Etiketin väri', + desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + }, + strokeWidth: { + label: 'Reunan leveys', + desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', + }, + maxDistance: { + label: 'Hex paljastaa etäisyyttä', + desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', + }, + revealDistance: { + label: 'Näköetäisyys', + desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', + }, + lineOfSight: { + label: 'Näkökenttä', + desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', + }, + revealPath: { + label: 'Paljasta polun varrella', + desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + }, + revealBy: { + label: 'Tokenit jotka paljastavat', + desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + }, + revealMode: { + label: 'Paljastustila', + desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + }, + announce: { + label: 'Ilmoita löydökset', + desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', + }, + pingDiscoveries: { + label: 'Ping löydöt', + desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', + }, + hideCoveredTokens: { + label: 'Piilota peitetyt rahakkeet', + desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + }, + }, + status: { + engine: 'Pelin moottori', + grid: 'Ruudukko', + layer: 'Hex kerros', + hexes: 'Hexes', + named: 'Nimetyt heksat', + icons: 'Sijaintitunnukset', + glimpsed: 'Näytetyt kuusiot', + pending: 'Täyttöä odottavat paikat', + calibrated: 'Kalibroitu', + overrides: 'Sivun ohitukset', + undo: 'Kumoa käytettävissä', + }, + messages: { + filled: + 'Täyttö valmis. Heksat piirretty: {created}. Uudelleen muotoiltu: {restyled}. Piilotetut sijainnit: {icons}.', + revealed: 'Heksat paljastettiin: {count}.', + revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', + confirmReset: + 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Heksit poistettu sivulta: {count}.', + undone: + 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksaalit nimeltä "{name}": {count}.', + unnamed: 'Poistetut nimet: {count}.', + marked: + 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + settingChanged: '{setting} asetettu arvoon {value}.', + rescanned: + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + calibrated: + 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + calibrationReset: + 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', + migrated: + 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + pruned: + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', + readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + }, + warnings: { + foregroundUnavailable: + 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', + }, + errors: { + noPage: 'Työstettävää sivua ei löytynyt.', + notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', + emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', + tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', + nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + noTokens: 'Valitse ensin yksi tai useampi merkki.', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + nothingToUndo: 'Kumoavaa täyttöä ei ole.', + unknownCommand: 'Tuntematon komento: {command}', + unknownSetting: 'Tuntematon asetus: {key}', + unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', + invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', + calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', + calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + unexpected: 'Jotain meni pieleen: {message}', + }, + hints: { + noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', + notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + noPolygons: + 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', + emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', + tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', + noHexes: + 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', + unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', + calibrateNeedsTokens: + 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + calibrateFailed: + 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', + }, + help: { + menu: 'Näytä valikko.', + fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', + reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + explore: + 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', + resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', + mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', + unmark: 'Estä valittujen merkkien piilottaminen.', + set: 'Muuta asetusta tai näytä kaikki asetukset.', + pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', + pageClear: 'Poista nykyisen sivun ohitukset.', + rescan: + 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + calibrate: + 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + calibrateReset: 'Poista nykyisen sivun kalibrointi.', + status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', + journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + help: 'Näytä tämä luettelo.', + handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', + }, + deck: { + subtitle: 'Komentolevy', + drawDesc: + 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + revealDesc: + 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + locationsDesc: + 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + toolsDesc: + 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', + footer: 'Katso täydelliset ohjeet monisteesta "{help}".', + }, + handout: { + versionLabel: 'Versio', + subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', + overview: { + heading: 'Yleiskatsaus', + body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + demo: 'Katso lyhyt esittely (versiosta 1)', + }, + quickStart: { + heading: 'Pika-aloitus', + steps: [ + 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', + 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', + 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + ], + }, + commands: { + heading: 'komennot', + intro: + 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', + colCommand: 'Komento', + colDesc: 'Mitä se tekee', + }, + revealing: { + heading: 'Kuinka paljastaminen toimii', + points: [ + 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', + 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', + 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', + 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + ], + }, + locations: { + heading: 'Nimetty Heksit ja sijainnit', + points: [ + 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', + 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + ], + }, + settings: { + heading: 'Asetukset', + intro: + 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + colKey: 'Avain', + colName: 'Asetus', + colDesc: 'Kuvaus', + perPage: '(Voidaan asettaa sivukohtaisesti.)', + }, + jumpgate: { + heading: 'Jumpgate ja Legacy', + points: [ + 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', + 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', + 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + ], + }, + upgrading: { + heading: 'Päivitys versiosta 1', + points: [ + 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', + 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', + 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + ], + colV1: 'Version 1 komento', + colV2: 'Version 2 komento', + }, + troubleshooting: { + heading: 'Vianetsintä', + points: [ + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', + 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', + 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', + 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', + ], + }, + languages: { + heading: 'Kielet', + body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + }, + credits: { + heading: 'Krediitit', + original: 'Alkuperäinen mod', + maintainer: 'Versio 2 ylläpitäjä', + marketplace: 'Adan taidepaketit Roll20 Marketplacessa', + support: + 'Jos löydät virheen tai sinulla on idea, kirjoita viesti Roll20 Mod -foorumille tai avaa ongelma GitHubissa ja sisällytä kaikki viestit API-konsolin lokista.', + }, + }, + }; + + const TRANSLATION$f = { + titles: { + ready: "L'exploration est prête.", + settings: "Paramètres d'exploration", + languages: 'Choisissez une langue', + pageSettings: 'Paramètres de la page : {page}', + status: "Statut d'exploration : {page}", + help: "Commandes d'exploration", + confirm: 'Veuillez confirmer', + }, + discovery: { + title: 'Emplacement découvert', + }, + menu: { + draw: 'Dessiner', + reveal: 'Révéler et masquer', + locations: 'Emplacements', + tools: 'Outils', + layerInUse: 'De nouveaux hexagones sont dessinés sur le {layer}.', + pageSettingsHelp: + "Ces paramètres s'appliquent uniquement à cette page. Les paramètres marqués ★ remplacent les paramètres globaux.", + }, + buttons: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + undo: 'Annuler le remplissage', + reveal: 'Révéler', + conceal: 'Cacher', + explore: 'Explorer', + revealPage: 'Révéler la page', + resetPage: 'Page de réinitialisation', + mark: "Marquer l'emplacement", + unmark: 'Décocher', + name: 'Nom Hex', + settings: 'Paramètres', + pageSettings: 'Paramètres des pages', + status: 'Statut', + rescan: 'Nouvelle analyse', + calibrate: 'Étalonner', + calibrateReset: "Réinitialiser l'étalonnage", + help: 'Aide', + change: 'Changement', + menu: 'Menu', + clearOverrides: 'Effacer les remplacements', + confirmReset: 'Oui, supprimer tous les hexagones', + }, + prompts: { + name: 'Nom du lieu (laissez vide pour effacer)', + }, + values: { + on: 'Sur', + off: 'Désactivé', + none: 'Aucun', + hexLayer: { + auto: 'Auto (premier plan si disponible)', + foreground: 'calque de premier plan', + objects: 'couche de jetons', + }, + revealBy: { + players: 'Jetons de joueur', + characters: 'Jetons de personnage', + all: 'Tous les jetons', + }, + revealMode: { + clear: 'Clair', + glimpse: 'Aperçu', + }, + announce: { + all: 'Tout le monde', + gm: 'GM uniquement', + off: 'Désactivé', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + conceal: 'Cacher', + }, + }, + settings: { + language: { + label: 'Langue', + desc: 'Langue des menus, des messages et des documents.', + }, + hexLayer: { + label: 'Couche hexagonale', + desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', + }, + fillColor: { + label: 'Couleur de remplissage', + desc: 'Couleur des nouveaux hexagones. Utilisez rgba() pour les hexagones transparents, par exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Couleur de la bordure', + desc: 'Couleur du contour des nouveaux hexagones.', + }, + labelColor: { + label: "Couleur de l'étiquette", + desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + }, + glimpseColor: { + label: 'Aperçu de la couleur', + desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + }, + strokeWidth: { + label: 'Largeur de la bordure', + desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + }, + maxDistance: { + label: 'Distance de révélation hexagonale', + desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", + }, + revealDistance: { + label: 'Distance de vue', + desc: "Combien d'hexagones autour d'un jeton en mouvement sont révélés (0 à 20). 0 révèle uniquement les hexagones traversés par le jeton.", + }, + lineOfSight: { + label: 'Ligne de vue', + desc: "Lorsque cette option est activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre lui et le jeton.", + }, + revealPath: { + label: 'Révéler le long du chemin', + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + }, + revealBy: { + label: 'Des jetons qui révèlent', + desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", + }, + revealMode: { + label: 'Mode Révéler', + desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + }, + announce: { + label: 'Annoncer des découvertes', + desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", + }, + pingDiscoveries: { + label: 'Découvertes Ping', + desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", + }, + hideCoveredTokens: { + label: 'Masquer les jetons couverts', + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + }, + }, + status: { + engine: 'Moteur de jeu', + grid: 'Grille', + layer: 'Couche hexagonale', + hexes: 'Hexagones', + named: 'Hexs nommés', + icons: 'Jetons de localisation', + glimpsed: 'Hexs aperçus', + pending: "Emplacements en attente d'un remplissage", + calibrated: 'Calibré', + overrides: 'Remplacements de page', + undo: 'Annuler disponible', + }, + messages: { + filled: + 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + revealed: 'Hexs révélés : {count}.', + revealedPage: 'Chaque hexagone de la page révélé ({count}).', + confirmReset: + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', + resetPage: 'Hexs supprimés de la page : {count}.', + undone: + 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', + named: 'Hexs nommés "{name}" : {count}.', + unnamed: 'Noms effacés : {count}.', + marked: + 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', + settingChanged: '{setting} défini sur {value}.', + rescanned: + 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + calibrated: + 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + calibrationReset: + 'Calibrage supprimé. Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + journalRebuilt: 'Les documents « {help} » et « {deck} » ont été reconstruits.', + migrated: + "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", + pruned: + "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + readyHint: + 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + }, + warnings: { + foregroundUnavailable: + 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', + someFailed: + "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + }, + errors: { + noPage: 'Impossible de trouver la page sur laquelle travailler.', + notHex: "Cette page n'utilise pas de grille hexadécimale.", + noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', + emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", + tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", + nothingToConceal: 'Sélectionnez des formes dessinées ou des jetons à masquer.', + nothingToReveal: 'Sélectionnez des hexagones, des formes dessinées ou des jetons à révéler.', + noTokens: "Sélectionnez d'abord un ou plusieurs jetons.", + noHexes: + "Sélectionnez d'abord un ou plusieurs hexagones (ou des jetons placés sur des hexagones).", + nothingToUndo: "Il n'y a aucun remplissage à défaire.", + unknownCommand: 'Commande inconnue : {command}', + unknownSetting: 'Paramètre inconnu : {key}', + unknownPageSetting: 'Paramètres pouvant être définis par page : {keys}', + invalidValue: '"{value}" n\'est pas une valeur valide pour {key}.', + calibrateNeedsTokens: 'Sélectionnez un ou deux jetons accrochés aux centres des hexagones.', + calibrateFailed: 'Ces jetons ne peuvent pas être utilisés pour calibrer.', + unexpected: "Un problème s'est produit : {message}", + }, + hints: { + noPage: + 'Ouvrez la page sur laquelle vous souhaitez travailler ou sélectionnez quelque chose dessus.', + notHex: 'Définissez la grille de la page sur Hex (V) ou Hex (H) dans Paramètres de page.', + noPolygons: + 'Dessinez un polygone, un rectangle, une ellipse ou une forme à main levée autour de la zone, sélectionnez-le, puis réessayez.', + emptyArea: + 'Dessinez une forme plus grande ou vérifiez les paramètres de la grille de la page.', + tooMany: 'Remplissez une zone plus petite ou divisez la zone en plusieurs formes.', + noHexes: + 'Les hexagones sont au premier plan ou sur la couche de jetons ; passez à ce calque pour les sélectionner.', + unknownCommand: 'Tapez !hexploration help pour lister les commandes.', + unknownSetting: 'Tapez !hexploration set pour voir tous les paramètres.', + calibrateNeedsTokens: + "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + calibrateFailed: + "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + unexpected: 'Les détails se trouvent dans le journal de la console API.', + }, + help: { + menu: 'Afficher le menu.', + fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', + fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", + undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + reveal: + 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', + revealPage: 'Révélez chaque hexagone de la page sans annonce.', + conceal: + 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', + explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", + mark: 'Transformez les jetons sélectionnés en emplacements cachés.', + unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", + set: 'Modifiez un paramètre ou affichez tous les paramètres.', + pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', + pageClear: 'Supprimez les remplacements de la page actuelle.', + rescan: + 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + calibrate: + 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', + calibrateReset: 'Supprimez le calibrage de la page actuelle.', + status: 'Montre ce que Hexploration sait de la page actuelle.', + journal: "Reconstruisez les documents d'aide et de commande.", + help: 'Montrez cette liste.', + handout: 'Les instructions complètes se trouvent dans le document « {name} ».', + }, + deck: { + subtitle: 'Pont de commandement', + drawDesc: + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + revealDesc: + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + locationsDesc: + "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", + toolsDesc: + 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Exploration hex par hex pour Roll20', + footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', + overview: { + heading: 'Aperçu', + body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + demo: 'Regardez une courte démo (à partir de la version 1)', + }, + quickStart: { + heading: 'Démarrage rapide', + steps: [ + 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', + 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', + 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", + "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + ], + }, + commands: { + heading: 'Commandes', + intro: + 'Seuls les MJ peuvent utiliser ces commandes. La plupart agissent sur les objets sélectionnés ; le reste agit sur la page que vous consultez.', + colCommand: 'Commande', + colDesc: 'Ce que ça fait', + }, + revealing: { + heading: 'Comment fonctionne la révélation', + points: [ + 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', + "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + ], + }, + locations: { + heading: 'Hexs et emplacements nommés', + points: [ + 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', + "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", + "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + ], + }, + settings: { + heading: 'Paramètres', + intro: + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + colKey: 'Clé', + colName: 'Paramètre', + colDesc: 'Description', + perPage: '(Peut être défini par page.)', + }, + jumpgate: { + heading: 'Jumpgate et héritage', + points: [ + "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", + "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", + ], + }, + upgrading: { + heading: 'Mise à niveau à partir de la version 1', + points: [ + "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", + 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', + 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', + "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + ], + colV1: 'Commande version 1', + colV2: 'Commande version 2', + }, + troubleshooting: { + heading: 'Dépannage', + points: [ + "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', + "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", + ], + }, + languages: { + heading: 'Langues', + body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + }, + credits: { + heading: 'Crédits', + original: 'Mod original par', + maintainer: 'Version 2 maintenue par', + marketplace: "Les packs artistiques d'Ada sur le Marketplace Roll20", + support: + 'Si vous trouvez un bug ou avez une idée, publiez-le sur le forum Roll20 Mod ou ouvrez un problème sur GitHub et incluez tous les messages du journal de la console API.', + }, + }, + }; + + const TRANSLATION$e = { + titles: { + ready: 'Hexploration ist fertig.', + settings: 'Erkundungseinstellungen', + languages: 'Wählen Sie eine Sprache', + pageSettings: 'Seiteneinstellungen: {page}', + status: 'Erkundungsstatus: {page}', + help: 'Erkundungsbefehle', + confirm: 'Bitte bestätigen', + }, + discovery: { + title: 'Standort entdeckt', + }, + menu: { + draw: 'Ziehen', + reveal: 'Enthüllen und Verstecken', + locations: 'Standorte', + tools: 'Werkzeuge', + layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + pageSettingsHelp: + 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', + }, + buttons: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + undo: 'Füllung rückgängig machen', + reveal: 'Aufdecken', + conceal: 'Verbergen', + explore: 'Erkunden', + revealPage: 'Seite enthüllen', + resetPage: 'Seite zurücksetzen', + mark: 'Standort markieren', + unmark: 'Markierung aufheben', + name: 'Name Hex', + settings: 'Einstellungen', + pageSettings: 'Seiteneinstellungen', + status: 'Status', + rescan: 'Erneut scannen', + calibrate: 'Kalibrieren', + calibrateReset: 'Kalibrierung zurücksetzen', + help: 'Helfen', + change: 'Ändern', + menu: 'Speisekarte', + clearOverrides: 'Überschreibungen löschen', + confirmReset: 'Ja, alle Verhexungen entfernen', + }, + prompts: { + name: 'Standortname (zum Löschen leer lassen)', + }, + values: { + on: 'An', + off: 'Aus', + none: 'Keiner', + hexLayer: { + auto: 'Auto (Vordergrund, falls verfügbar)', + foreground: 'Vordergrundebene', + objects: 'Token-Schicht', + }, + revealBy: { + players: 'Spielertoken', + characters: 'Charaktertoken', + all: 'Alle Token', + }, + revealMode: { + clear: 'Klar', + glimpse: 'Blick', + }, + announce: { + all: 'Alle', + gm: 'Nur GM', + off: 'Aus', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Sechskant (H)', + }, + fillKind: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Sprache', + desc: 'Sprache für Menüs, Nachrichten und Handouts.', + }, + hexLayer: { + label: 'Hex-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + }, + fillColor: { + label: 'Füllfarbe', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randfarbe', + desc: 'Farbe der Umrisse neuer Hexfelder.', + }, + labelColor: { + label: 'Etikettenfarbe', + desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', + }, + glimpseColor: { + label: 'Einblick in die Farbe', + desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + }, + strokeWidth: { + label: 'Randbreite', + desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', + }, + maxDistance: { + label: 'Hex-Enthüllungsabstand', + desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', + }, + revealDistance: { + label: 'Sichtweite', + desc: 'Wie viele Hexfelder um einen beweglichen Spielstein herum angezeigt werden (0 bis 20). 0 zeigt nur die Hexfelder an, die der Token durchquert.', + }, + lineOfSight: { + label: 'Sichtlinie', + desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', + }, + revealPath: { + label: 'Auf dem Weg enthüllen', + desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', + }, + revealBy: { + label: 'Zeichen, die offenbaren', + desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + }, + revealMode: { + label: 'Reveal-Modus', + desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + }, + announce: { + label: 'Kündigen Sie Entdeckungen an', + desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', + }, + pingDiscoveries: { + label: 'Ping-Entdeckungen', + desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', + }, + hideCoveredTokens: { + label: 'Verdeckte Token ausblenden', + desc: 'Roll20 zeichnet Namen, Balken und Auren über Hexfeldern. Wenn diese Option aktiviert ist, werden der für den Spieler sichtbare Name, die Balken und die Auren von Spielsteinen unter einem abgedeckten Hexfeld ausgeschaltet und wieder eingeschaltet, wenn sie aufgedeckt werden.', + }, + }, + status: { + engine: 'Spiel-Engine', + grid: 'Netz', + layer: 'Hex-Schicht', + hexes: 'Verhexungen', + named: 'Benannte Verhexungen', + icons: 'Standorttoken', + glimpsed: 'Gesehene Verhexungen', + pending: 'Orte, die auf eine Besetzung warten', + calibrated: 'Kalibriert', + overrides: 'Seitenüberschreibungen', + undo: 'Rückgängig machen verfügbar', + }, + messages: { + filled: + 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', + revealed: 'Aufgedeckte Verhexungen: {count}.', + revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + confirmReset: + 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + undone: + 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexen mit dem Namen „{name}“: {count}.', + unnamed: 'Gelöschte Namen: {count}.', + marked: + 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', + unmarked: 'Token, die keine Standorte mehr sind: {count}.', + settingChanged: '{setting} wird auf {value} gesetzt.', + rescanned: + 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + calibrated: + 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + calibrationReset: + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', + migrated: + 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + pruned: + 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + readyHint: + 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + }, + warnings: { + foregroundUnavailable: + 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', + someFailed: + 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + }, + errors: { + noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', + notHex: 'Diese Seite verwendet kein Hex-Raster.', + noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', + emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', + tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + nothingToConceal: + 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + nothingToReveal: + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', + noHexes: + 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', + nothingToUndo: 'Es gibt keine Füllung, die rückgängig gemacht werden könnte.', + unknownCommand: 'Unbekannter Befehl: {command}', + unknownSetting: 'Unbekannte Einstellung: {key}', + unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', + invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', + calibrateNeedsTokens: + 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', + unexpected: 'Es ist ein Fehler aufgetreten: {message}', + }, + hints: { + noPage: + 'Öffnen Sie die Seite, an der Sie arbeiten möchten, oder wählen Sie etwas darauf aus.', + notHex: + 'Stellen Sie das Seitenraster in den Seiteneinstellungen auf Hex (V) oder Hex (H) ein.', + noPolygons: + 'Zeichnen Sie ein Polygon, ein Rechteck, eine Ellipse oder eine Freihandform um den Bereich, wählen Sie es aus und versuchen Sie es erneut.', + emptyArea: + 'Zeichnen Sie eine größere Form oder überprüfen Sie die Seitenrastereinstellungen.', + tooMany: + 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', + noHexes: + 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', + unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', + calibrateNeedsTokens: + 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', + calibrateFailed: + 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + unexpected: 'Details finden Sie im API-Konsolenprotokoll.', + }, + help: { + menu: 'Zeigen Sie das Menü an.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', + undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + reveal: + 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', + revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + conceal: + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + explore: + 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', + set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', + pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', + rescan: + 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + calibrate: + 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', + status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', + journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + help: 'Diese Liste anzeigen.', + handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', + }, + deck: { + subtitle: 'Kommandodeck', + drawDesc: + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + revealDesc: + 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + locationsDesc: + 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + toolsDesc: + 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', + footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-für-Hex-Erkundung für Roll20', + footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', + overview: { + heading: 'Überblick', + body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', + }, + quickStart: { + heading: 'Schnellstart', + steps: [ + 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', + 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', + 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', + 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + ], + }, + commands: { + heading: 'Befehle', + intro: + 'Nur GMs können diese Befehle verwenden. Die meisten wirken auf die ausgewählten Objekte; Der Rest wirkt auf der Seite, die Sie gerade betrachten.', + colCommand: 'Befehl', + colDesc: 'Was es bewirkt', + }, + revealing: { + heading: 'Wie Offenlegung funktioniert', + points: [ + 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', + 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', + 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + ], + }, + locations: { + heading: 'Benannte Hexfelder und Orte', + points: [ + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', + 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', + 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + ], + }, + settings: { + heading: 'Einstellungen', + intro: + 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + colKey: 'Schlüssel', + colName: 'Einstellung', + colDesc: 'Beschreibung', + perPage: '(Kann pro Seite eingestellt werden.)', + }, + jumpgate: { + heading: 'Jumpgate und Legacy', + points: [ + 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', + 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + ], + }, + upgrading: { + heading: 'Upgrade von Version 1', + points: [ + 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', + 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', + 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + ], + colV1: 'Befehl der Version 1', + colV2: 'Befehl der Version 2', + }, + troubleshooting: { + heading: 'Fehlerbehebung', + points: [ + 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', + 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', + 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', + ], + }, + languages: { + heading: 'Sprachen', + body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + }, + credits: { + heading: 'Credits', + original: 'Original-Mod von', + maintainer: 'Version 2 verwaltet von', + marketplace: 'Adas Kunstpakete auf dem Roll20-Marktplatz', + support: + 'Wenn Sie einen Fehler finden oder eine Idee haben, posten Sie im Roll20 Mod-Forum oder öffnen Sie ein Problem auf GitHub und fügen Sie alle Meldungen aus dem API-Konsolenprotokoll hinzu.', + }, + }, + }; + + const TRANSLATION$d = { + titles: { + ready: 'Η εξερεύνηση είναι έτοιμη.', + settings: 'Ρυθμίσεις εξερεύνησης', + languages: 'Επιλέξτε μια γλώσσα', + pageSettings: 'Ρυθμίσεις σελίδας: {page}', + status: 'Κατάσταση εξερεύνησης: {page}', + help: 'Εντολές Εξερεύνησης', + confirm: 'Επιβεβαιώστε', + }, + discovery: { + title: 'Ανακαλύφθηκε τοποθεσία', + }, + menu: { + draw: 'Ισοπαλία', + reveal: 'Αποκάλυψη και απόκρυψη', + locations: 'Τοποθεσίες', + tools: 'Εργαλεία', + layerInUse: 'Νέα εξάγωνα σχεδιάζονται στο {layer}.', + pageSettingsHelp: + 'Αυτές οι ρυθμίσεις ισχύουν μόνο για αυτήν τη σελίδα. Οι ρυθμίσεις με την ένδειξη ★ αντικαθιστούν τις καθολικές ρυθμίσεις.', + }, + buttons: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + undo: 'Αναίρεση συμπλήρωσης', + reveal: 'Αποκαλύπτω', + conceal: 'Απόκρυψη', + explore: 'Εξερευνώ', + revealPage: 'Αποκάλυψη σελίδας', + resetPage: 'Επαναφορά σελίδας', + mark: 'Επισήμανση τοποθεσίας', + unmark: 'Κατάργηση επισήμανσης', + name: 'Όνομα Hex', + settings: 'Ρυθμίσεις', + pageSettings: 'Ρυθμίσεις σελίδας', + status: 'Κατάσταση', + rescan: 'Εκ νέου σάρωση', + calibrate: 'Μετρώ την διάμετρο', + calibrateReset: 'Επαναφορά βαθμονόμησης', + help: 'Βοήθεια', + change: 'Αλλαγή', + menu: 'Μενού', + clearOverrides: 'Εκκαθάριση παρακάμψεων', + confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + }, + prompts: { + name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', + }, + values: { + on: 'Επί', + off: 'Μακριά από', + none: 'Κανένας', + hexLayer: { + auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', + foreground: 'στρώμα πρώτου πλάνου', + objects: 'συμβολικό στρώμα', + }, + revealBy: { + players: 'Μαρκάρια παίκτη', + characters: 'Μαρκάρια χαρακτήρων', + all: 'Όλες οι μάρκες', + }, + revealMode: { + clear: 'Σαφής', + glimpse: 'Ματιά', + }, + announce: { + all: 'Καθένας', + gm: 'Μόνο GM', + off: 'Μακριά από', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + conceal: 'Απόκρυψη', + }, + }, + settings: { + language: { + label: 'Γλώσσα', + desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', + }, + hexLayer: { + label: 'Εξάγωνο στρώμα', + desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + }, + fillColor: { + label: 'Χρώμα πλήρωσης', + desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Χρώμα περιγράμματος', + desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + }, + labelColor: { + label: 'Χρώμα ετικέτας', + desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', + }, + glimpseColor: { + label: 'Χρώμα Glimpse', + desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + }, + strokeWidth: { + label: 'Πλάτος περιγράμματος', + desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + }, + maxDistance: { + label: 'Εξάγωνο αποκαλύπτουν απόσταση', + desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', + }, + revealDistance: { + label: 'Απόσταση όρασης', + desc: 'Πόσα εξάγωνα γύρω από ένα κινούμενο διακριτικό αποκαλύπτονται (0 έως 20). Το 0 αποκαλύπτει μόνο τα εξάγωνα από τα οποία διέρχεται το διακριτικό.', + }, + lineOfSight: { + label: 'Γραμμή όρασης', + desc: 'Όταν είναι ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο μεταξύ αυτού και του διακριτικού.', + }, + revealPath: { + label: 'Αποκάλυψη κατά μήκος της διαδρομής', + desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', + }, + revealBy: { + label: 'Tokens που αποκαλύπτουν', + desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + }, + revealMode: { + label: 'Λειτουργία αποκάλυψης', + desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + }, + announce: { + label: 'Ανακοινώστε Ανακαλύψεις', + desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', + }, + pingDiscoveries: { + label: 'Ping ανακαλύψεις', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + }, + hideCoveredTokens: { + label: 'Απόκρυψη καλυμμένων κουπονιών', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + }, + }, + status: { + engine: 'Μηχανή παιχνιδιού', + grid: 'Πλέγμα', + layer: 'Εξάγωνο στρώμα', + hexes: 'Εξάγωνα', + named: 'Ονομασμένα εξάγωνα', + icons: 'Διακριτικά τοποθεσίας', + glimpsed: 'Καθαρά εξάγωνα', + pending: 'Τοποθεσίες που περιμένουν γέμισμα', + calibrated: 'Βαθμονομημένο', + overrides: 'Σελίδα παρακάμπτει', + undo: 'Αναίρεση διαθέσιμη', + }, + messages: { + filled: + 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', + revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + confirmReset: + 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', + resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', + undone: + 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', + named: 'Hexes με όνομα "{name}": {count}.', + unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', + marked: + 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', + settingChanged: 'Το {setting} ορίστηκε σε {value}.', + rescanned: + 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + calibrated: + 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + calibrationReset: + 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', + migrated: + 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + pruned: + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + readyHint: + 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + someFailed: + 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + }, + errors: { + noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', + notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', + unknownCommand: 'Άγνωστη εντολή: {command}', + unknownSetting: 'Άγνωστη ρύθμιση: {key}', + unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', + invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', + unexpected: 'Κάτι πήγε στραβά: {message}', + }, + hints: { + noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', + notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + noPolygons: + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', + noHexes: + 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', + unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', + calibrateNeedsTokens: + 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + calibrateFailed: + 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', + }, + help: { + menu: 'Εμφάνιση του μενού.', + fill: 'Καλύψτε τα επιλεγμένα σχεδιασμένα σχήματα με εξάγωνα.', + fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', + undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', + reveal: + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', + conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', + name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', + mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', + unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', + pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', + pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', + rescan: + 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + calibrate: + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', + status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', + journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + help: 'Εμφάνιση αυτής της λίστας.', + handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', + }, + deck: { + subtitle: 'Κατάστρωμα εντολών', + drawDesc: + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + revealDesc: + 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + locationsDesc: + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + toolsDesc: + 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', + footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', + }, + handout: { + versionLabel: 'Εκδοχή', + subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', + overview: { + heading: 'Επισκόπηση', + body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', + }, + quickStart: { + heading: 'Γρήγορη εκκίνηση', + steps: [ + 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', + 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + ], + }, + commands: { + heading: 'Εντολές', + intro: + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + colCommand: 'Εντολή', + colDesc: 'Τι κάνει', + }, + revealing: { + heading: 'Πώς λειτουργεί η αποκάλυψη', + points: [ + 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', + 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', + 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', + 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + ], + }, + locations: { + heading: 'Με όνομα Hexes and Locations', + points: [ + 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + ], + }, + settings: { + heading: 'Ρυθμίσεις', + intro: + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + colKey: 'Κλειδί', + colName: 'Σύνθεση', + colDesc: 'Περιγραφή', + perPage: '(Μπορεί να οριστεί ανά σελίδα.)', + }, + jumpgate: { + heading: 'Jumpgate και Legacy', + points: [ + 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', + 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + ], + }, + upgrading: { + heading: 'Αναβάθμιση από την έκδοση 1', + points: [ + 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', + 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', + 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + ], + colV1: 'Εντολή έκδοσης 1', + colV2: 'Εντολή έκδοσης 2', + }, + troubleshooting: { + heading: 'Αντιμετώπιση προβλημάτων', + points: [ + 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', + 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', + 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', + 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', + ], + }, + languages: { + heading: 'Γλώσσες', + body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + }, + credits: { + heading: 'Πιστώσεις', + original: 'Πρωτότυπο mod από', + maintainer: 'Έκδοση 2 που διατηρείται από', + marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', + support: + 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', + }, + }, + }; + + const TRANSLATION$c = { + titles: { + ready: 'החקירה מוכנה.', + settings: 'הגדרות החקירה', + languages: 'בחר שפה', + pageSettings: 'הגדרות דף: {page}', + status: 'סטטוס החקירה: {page}', + help: 'פקודות החקירה', + confirm: 'אנא אשר', + }, + discovery: { + title: 'מיקום התגלה', + }, + menu: { + draw: 'לִמְשׁוֹך', + reveal: 'לגלות ולהסתיר', + locations: 'מיקומים', + tools: 'כְּלֵי עֲבוֹדָה', + layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + pageSettingsHelp: + 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', + }, + buttons: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + undo: 'בטל מילוי', + reveal: 'לְגַלוֹת', + conceal: 'לְהַסתִיר', + explore: 'לַחקוֹר', + revealPage: 'גלה עמוד', + resetPage: 'אפס דף', + mark: 'סמן מיקום', + unmark: 'בטל את הסימון', + name: 'שם הקס', + settings: 'הגדרות', + pageSettings: 'הגדרות עמוד', + status: 'סטָטוּס', + rescan: 'סרוק מחדש', + calibrate: 'לְדַרֵג', + calibrateReset: 'אפס כיול', + help: 'עֶזרָה', + change: 'לְשַׁנוֹת', + menu: 'תַפרִיט', + clearOverrides: 'נקה עקיפות', + confirmReset: 'כן, הסר את כל המשושים', + }, + prompts: { + name: 'שם המיקום (השאירו ריק כדי לנקות)', + }, + values: { + on: 'עַל', + off: 'כבוי', + none: 'אַף לֹא אֶחָד', + hexLayer: { + auto: 'אוטומטי (בחזית אם זמין)', + foreground: 'שכבת חזית', + objects: 'שכבת אסימונים', + }, + revealBy: { + players: 'אסימוני שחקן', + characters: 'אסימוני תווים', + all: 'כל האסימונים', + }, + revealMode: { + clear: 'בָּרוּר', + glimpse: 'הֲצָצָה', + }, + announce: { + all: 'כֹּל אֶחָד', + gm: 'GM בלבד', + off: 'כבוי', + }, + orientation: { + vertical: 'משושה (V)', + horizontal: 'משושה (H)', + }, + fillKind: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + conceal: 'לְהַסתִיר', + }, + }, + settings: { + language: { + label: 'שָׂפָה', + desc: 'שפה לתפריטים, הודעות ודפי מידע.', + }, + hexLayer: { + label: 'שכבת משושה', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + }, + fillColor: { + label: 'צבע מילוי', + desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'צבע גבול', + desc: 'צבע קווי המתאר של משושות חדשות.', + }, + labelColor: { + label: 'צבע התווית', + desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + }, + glimpseColor: { + label: 'צבע הצצה', + desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + }, + strokeWidth: { + label: 'רוחב גבול', + desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', + }, + maxDistance: { + label: 'מרחק חשיפת משושה', + desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', + }, + revealDistance: { + label: 'מרחק ראייה', + desc: 'כמה משושים סביב אסימון נע נחשפים (0 עד 20). 0 חושף רק את המשושים שהאסימון עובר דרכם.', + }, + lineOfSight: { + label: 'קו ראייה', + desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', + }, + revealPath: { + label: 'גלה לאורך הנתיב', + desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', + }, + revealBy: { + label: 'אסימונים שחושפים', + desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', + }, + revealMode: { + label: 'מצב חשיפה', + desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + }, + announce: { + label: 'הכריזו על תגליות', + desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", + }, + pingDiscoveries: { + label: 'פינג תגליות', + desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', + }, + hideCoveredTokens: { + label: 'הסתר אסימונים מכוסים', + desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + }, + }, + status: { + engine: 'מנוע משחק', + grid: 'רֶשֶׁת', + layer: 'שכבת משושה', + hexes: 'משושים', + named: 'ששים בשם', + icons: 'אסימוני מיקום', + glimpsed: 'משושים נוצצים', + pending: 'מיקומים ממתינים למילוי', + calibrated: 'מְכוּיָל', + overrides: 'עקיפת עמוד', + undo: 'בטל זמין', + }, + messages: { + filled: + 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', + revealed: 'נחשפו משושים: {count}.', + revealedPage: 'כל hex בדף נחשף ({count}).', + confirmReset: + 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', + resetPage: 'הקסים הוסרו מהדף: {count}.', + undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', + named: 'hexes בשם "{name}": {count}.', + unnamed: 'שמות נוקו: {count}.', + marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', + settingChanged: '{setting} מוגדר ל-{value}.', + rescanned: + 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + calibrated: + 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + calibrationReset: + 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', + migrated: + 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + pruned: + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + readyHint: + 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', + someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + }, + errors: { + noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', + notHex: 'דף זה אינו משתמש ברשת משושה.', + noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', + tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', + nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', + noTokens: 'תחילה בחר אסימון אחד או יותר.', + noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + nothingToUndo: 'אין מילוי לבטל.', + unknownCommand: 'פקודה לא ידועה: {command}', + unknownSetting: 'הגדרה לא ידועה: {key}', + unknownPageSetting: 'הגדרות שניתן להגדיר לכל עמוד: {keys}', + invalidValue: '"{value}" אינו ערך חוקי עבור {key}.', + calibrateNeedsTokens: 'בחר אסימון אחד או שניים שהוצמדו למרכזי משושה.', + calibrateFailed: 'לא ניתן להשתמש באסימונים האלה לכיול.', + unexpected: 'משהו השתבש: {message}', + }, + hints: { + noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', + notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + noPolygons: + 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', + noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', + unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', + unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', + calibrateNeedsTokens: + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + calibrateFailed: + 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', + }, + help: { + menu: 'הצג את התפריט.', + fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', + undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', + revealPage: 'חשוף כל קסם בדף ללא הודעות.', + conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', + resetPage: 'הסר כל hex בדף (שואל תחילה).', + name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', + unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + set: 'שנה הגדרה או הצג את כל ההגדרות.', + pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', + pageClear: 'הסר את העקיפות של הדף הנוכחי.', + rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', + calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + calibrateReset: 'הסר את הכיול של הדף הנוכחי.', + status: 'הצג מה Hexploration יודע על הדף הנוכחי.', + journal: 'בנה מחדש את דפי העזרה והפקודה.', + help: 'הצג רשימה זו.', + handout: 'ההנחיות המלאות נמצאות בדף "{name}".', + }, + deck: { + subtitle: 'סיפון פיקוד', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + revealDesc: + 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + locationsDesc: + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', + footer: 'עיין בדף "{help}" להנחיות מלאות.', + }, + handout: { + versionLabel: 'גִרְסָה', + subtitle: 'חקירה משושה אחר קסם עבור Roll20', + footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', + overview: { + heading: 'סקירה כללית', + body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + demo: 'צפו בהדגמה קצרה (מגרסה 1)', + }, + quickStart: { + heading: 'התחלה מהירה', + steps: [ + 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', + 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + ], + }, + commands: { + heading: 'פקודות', + intro: + 'רק GMs יכולים להשתמש בפקודות אלה. רובם פועלים על האובייקטים שנבחרו; השאר פועלים בדף שבו אתה צופה.', + colCommand: 'פְּקוּדָה', + colDesc: 'מה זה עושה', + }, + revealing: { + heading: 'איך עובד גילוי', + points: [ + 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', + 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + ], + }, + locations: { + heading: 'בשם משושים ומיקומים', + points: [ + 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', + 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', + 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + ], + }, + settings: { + heading: 'הגדרות', + intro: + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + colKey: 'מַפְתֵחַ', + colName: 'סְבִיבָה', + colDesc: 'תֵאוּר', + perPage: '(ניתן להגדיר לכל עמוד.)', + }, + jumpgate: { + heading: 'Jumpgate ומורשת', + points: [ + 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', + 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', + 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', + ], + }, + upgrading: { + heading: 'משדרג מגרסה 1', + points: [ + 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', + 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', + 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + ], + colV1: 'פקודה גרסה 1', + colV2: 'פקודה גרסה 2', + }, + troubleshooting: { + heading: 'פתרון בעיות', + points: [ + 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', + 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', + 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', + ], + }, + languages: { + heading: 'שפות', + body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + }, + credits: { + heading: 'קרדיטים', + original: 'מוד מקורי מאת', + maintainer: 'גרסה 2 מתוחזקת על ידי', + marketplace: 'חבילות האמנות של עדה ב-Roll20 Marketplace', + support: + 'אם אתה מוצא באג או יש לך רעיון, פרסם בפורום Roll20 Mod או פתח בעיה ב-GitHub, וכלול הודעות כלשהן מיומן מסוף ה-API.', + }, + }, + }; + + const TRANSLATION$b = { + titles: { + ready: 'A hexploration készen áll.', + settings: 'Hexexploration beállítások', + languages: 'Válasszon nyelvet', + pageSettings: 'Oldalbeállítások: {page}', + status: 'Heti feltárás állapota: {page}', + help: 'Hexploration parancsok', + confirm: 'Kérjük, erősítse meg', + }, + discovery: { + title: 'Hely felfedezve', + }, + menu: { + draw: 'Rajzolj', + reveal: 'Felfedni és elrejteni', + locations: 'Helyszínek', + tools: 'Eszközök', + layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + pageSettingsHelp: + 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', + }, + buttons: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + undo: 'Kitöltés visszavonása', + reveal: 'Felfedni', + conceal: 'Elrejteni', + explore: 'Fedezze fel', + revealPage: 'Oldal feltárása', + resetPage: 'Oldal visszaállítása', + mark: 'Hely megjelölése', + unmark: 'Törölje a jelölést', + name: 'Név Hex', + settings: 'Beállítások elemre', + pageSettings: 'Oldalbeállítások', + status: 'Állapot', + rescan: 'Újraszkennelés', + calibrate: 'Kalibrálni', + calibrateReset: 'Kalibrálás visszaállítása', + help: 'Segítség', + change: 'Változás', + menu: 'Menü', + clearOverrides: 'Felülbírálások törlése', + confirmReset: 'Igen, távolítsa el az összes hexát', + }, + prompts: { + name: 'Helynév (a törléshez hagyja üresen)', + }, + values: { + on: 'On', + off: 'Le', + none: 'Egyik sem', + hexLayer: { + auto: 'Automatikus (előtérben, ha elérhető)', + foreground: 'előtér réteg', + objects: 'token réteg', + }, + revealBy: { + players: 'Játékos tokenek', + characters: 'Karakter tokenek', + all: 'Minden token', + }, + revealMode: { + clear: 'Világos', + glimpse: 'Bepillantás', + }, + announce: { + all: 'Mindenki', + gm: 'Csak GM', + off: 'Le', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + conceal: 'Elrejteni', + }, + }, + settings: { + language: { + label: 'Nyelv', + desc: 'A menük, üzenetek és tájékoztatók nyelve.', + }, + hexLayer: { + label: 'Hatlapos réteg', + desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + }, + fillColor: { + label: 'Kitöltés színe', + desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Szegély színe', + desc: 'Az új hatszögek körvonalának színe.', + }, + labelColor: { + label: 'Címke színe', + desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + }, + strokeWidth: { + label: 'Határ szélessége', + desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', + }, + maxDistance: { + label: 'Hex Reveal távolság', + desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', + }, + revealDistance: { + label: 'Látótávolság', + desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + }, + lineOfSight: { + label: 'Látóvonal', + desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', + }, + revealPath: { + label: 'Fedezd fel az ösvényen', + desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + }, + revealBy: { + label: 'Tokenek, amelyek felfedik', + desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + }, + revealMode: { + label: 'Felfedezési mód', + desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + }, + announce: { + label: 'Hirdesse a felfedezéseket', + desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', + }, + pingDiscoveries: { + label: 'Ping felfedezések', + desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', + }, + hideCoveredTokens: { + label: 'Fedett tokenek elrejtése', + desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + }, + }, + status: { + engine: 'Játék motor', + grid: 'Rács', + layer: 'Hatlapos réteg', + hexes: 'Hexák', + named: 'Elnevezett hexák', + icons: 'Helyjelzők', + glimpsed: 'Megpillantott hatszögek', + pending: 'Betöltésre váró helyek', + calibrated: 'Kalibrálva', + overrides: 'Oldal felülbírálása', + undo: 'Visszavonás elérhető', + }, + messages: { + filled: + 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', + revealed: 'Felfedezett hatszögek: {count}.', + revealedPage: 'Az oldalon minden hex látható ({count}).', + confirmReset: + 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + resetPage: 'Az oldalról eltávolított hatszögek: {count}.', + undone: + 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', + named: '"{name}" nevű hatszögek: {count}.', + unnamed: 'Törölt nevek: {count}.', + marked: + 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + unmarked: 'Tokenek, amelyek már nem helyek: {count}.', + settingChanged: '{setting} értéke {value}.', + rescanned: + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + calibrated: + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + calibrationReset: + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', + journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + migrated: + 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + pruned: + 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + readyHint: + 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + }, + warnings: { + foregroundUnavailable: + 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', + }, + errors: { + noPage: 'Nem található az oldal, amelyen dolgozni kellene.', + notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', + emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', + nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + nothingToReveal: + 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + noTokens: 'Először válasszon ki egy vagy több tokent.', + noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + nothingToUndo: 'Nincs visszavonható kitöltés.', + unknownCommand: 'Ismeretlen parancs: {command}', + unknownSetting: 'Ismeretlen beállítás: {key}', + unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', + invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', + calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', + unexpected: 'Hiba történt: {message}', + }, + hints: { + noPage: 'Nyissa meg azt az oldalt, amelyen dolgozni szeretne, vagy válasszon rajta valamit.', + notHex: 'Állítsa az oldalrácsot Hex (V) vagy Hex (H) értékre az Oldalbeállításokban.', + noPolygons: + 'Rajzoljon sokszöget, téglalapot, ellipszist vagy szabadkézi alakzatot a terület köré, jelölje ki, majd próbálkozzon újra.', + emptyArea: 'Rajzoljon nagyobb alakzatot, vagy ellenőrizze az oldalrács beállításait.', + tooMany: 'Töltsön ki egy kisebb területet, vagy ossza fel több formára.', + noHexes: + 'A hatszögek az előtérben vagy a token rétegben vannak; váltson át arra a rétegre a kijelölésükhöz.', + unknownCommand: 'Írja be a !hexploration help parancsot a parancsok listázásához.', + unknownSetting: 'Minden beállítás megtekintéséhez írja be a !hexploration set parancsot.', + calibrateNeedsTokens: + 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', + calibrateFailed: + 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + unexpected: 'A részletek az API-konzol naplójában találhatók.', + }, + help: { + menu: 'Mutasd a menüt.', + fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', + undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', + reveal: + 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', + revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + conceal: + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', + name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', + unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', + set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', + pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', + pageClear: 'Távolítsa el az aktuális oldal felülírásait.', + rescan: + 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + calibrate: + 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', + status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', + journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + help: 'Mutasd ezt a listát.', + handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', + }, + deck: { + subtitle: 'Parancsnoki pakli', + drawDesc: + 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', + revealDesc: + 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + locationsDesc: + 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + toolsDesc: + 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', + footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', + }, + handout: { + versionLabel: 'Változat', + subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', + overview: { + heading: 'Áttekintés', + body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + }, + quickStart: { + heading: 'Gyors kezdés', + steps: [ + 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', + 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', + 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', + ], + }, + commands: { + heading: 'Parancsok', + intro: + 'Csak a GM-ek használhatják ezeket a parancsokat. A legtöbb a kiválasztott objektumokra hat; a többi az éppen megtekintett oldalon működik.', + colCommand: 'Parancs', + colDesc: 'Mit csinál', + }, + revealing: { + heading: 'Hogyan működik a feltárás', + points: [ + 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', + 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', + 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', + 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + ], + }, + locations: { + heading: 'Hexák és helyek neve', + points: [ + 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', + 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + ], + }, + settings: { + heading: 'Beállítások elemre', + intro: + 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + colKey: 'Kulcsfontosságú', + colName: 'Beállítás', + colDesc: 'Leírás', + perPage: '(Oldalonként beállítható.)', + }, + jumpgate: { + heading: 'Jumpgate és Legacy', + points: [ + 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', + 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + ], + }, + upgrading: { + heading: 'Frissítés az 1-es verzióról', + points: [ + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', + 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + ], + colV1: '1-es verzió parancs', + colV2: '2-es verzió parancs', + }, + troubleshooting: { + heading: 'Hibaelhárítás', + points: [ + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', + 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', + 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + ], + }, + languages: { + heading: 'Nyelvek', + body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + }, + credits: { + heading: 'Kredit', + original: 'Eredeti mod által', + maintainer: 'A 2-es verziót karbantartja', + marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', + support: + 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + }, + }, + }; + + const TRANSLATION$a = { + titles: { + ready: "L'esplorazione è pronta.", + settings: 'Impostazioni di esplorazione', + languages: 'Scegli una lingua', + pageSettings: 'Impostazioni pagina: {page}', + status: 'Stato esplorazione: {page}', + help: 'Comandi di esplorazione', + confirm: 'Per favore conferma', + }, + discovery: { + title: 'Posizione scoperta', + }, + menu: { + draw: 'Disegno', + reveal: 'Rivelare e nascondere', + locations: 'Posizioni', + tools: 'Utensili', + layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + pageSettingsHelp: + 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', + }, + buttons: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + undo: 'Annulla riempimento', + reveal: 'Svelare', + conceal: 'Nascondere', + explore: 'Esplorare', + revealPage: 'Rivela pagina', + resetPage: 'Reimposta pagina', + mark: 'Segna posizione', + unmark: 'Deseleziona', + name: 'Nome esadecimale', + settings: 'Impostazioni', + pageSettings: 'Impostazioni della pagina', + status: 'Stato', + rescan: 'Nuova scansione', + calibrate: 'Calibrare', + calibrateReset: 'Ripristina calibrazione', + help: 'Aiuto', + change: 'Modifica', + menu: 'Menu', + clearOverrides: 'Cancella sostituzioni', + confirmReset: 'Sì, rimuovi tutti gli esagoni', + }, + prompts: { + name: 'Nome della posizione (lascia vuoto per cancellare)', + }, + values: { + on: 'SU', + off: 'Spento', + none: 'Nessuno', + hexLayer: { + auto: 'Automatico (in primo piano se disponibile)', + foreground: 'strato di primo piano', + objects: 'strato di token', + }, + revealBy: { + players: 'Gettoni del giocatore', + characters: 'Segnalini personaggio', + all: 'Tutti i gettoni', + }, + revealMode: { + clear: 'Chiaro', + glimpse: 'Occhiata', + }, + announce: { + all: 'Tutti', + gm: 'Solo GM', + off: 'Spento', + }, + orientation: { + vertical: 'Esadecimale (V)', + horizontal: 'Esadecimale (H)', + }, + fillKind: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + conceal: 'Nascondere', + }, + }, + settings: { + language: { + label: 'Lingua', + desc: 'Lingua per menu, messaggi e dispense.', + }, + hexLayer: { + label: 'Strato esagonale', + desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + }, + fillColor: { + label: 'Colore riempimento', + desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Colore del bordo', + desc: 'Colore del contorno dei nuovi esagoni.', + }, + labelColor: { + label: "Colore dell'etichetta", + desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', + }, + glimpseColor: { + label: 'Colore scorcio', + desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + }, + strokeWidth: { + label: 'Larghezza del bordo', + desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', + }, + maxDistance: { + label: 'Distanza di rivelazione esadecimale', + desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', + }, + revealDistance: { + label: 'Distanza visiva', + desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', + }, + lineOfSight: { + label: 'Linea di vista', + desc: 'Quando è attivo, un esagono viene rivelato solo se non si trova alcun esagono coperto tra esso e il segnalino.', + }, + revealPath: { + label: 'Rivela lungo il percorso', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + }, + revealBy: { + label: 'Segnalini che rivelano', + desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + }, + revealMode: { + label: 'Modalità Rivela', + desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + }, + announce: { + label: 'Annunciare le scoperte', + desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', + }, + pingDiscoveries: { + label: 'Scoperte del ping', + desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + }, + hideCoveredTokens: { + label: 'Nascondi i token coperti', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + }, + }, + status: { + engine: 'Motore di gioco', + grid: 'Griglia', + layer: 'Strato esagonale', + hexes: 'Esagoni', + named: 'Esagoni con nome', + icons: 'Gettoni di posizione', + glimpsed: 'Esagoni intravisti', + pending: 'Posizioni in attesa di riempimento', + calibrated: 'Calibrato', + overrides: "La pagina esegue l'override", + undo: 'Annulla disponibile', + }, + messages: { + filled: + 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + revealed: 'Esagoni rivelati: {count}.', + revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + confirmReset: + 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + resetPage: 'Esagoni rimossi dalla pagina: {count}.', + undone: + 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', + named: 'Esagoni denominati "{name}": {count}.', + unnamed: 'Nomi cancellati: {count}.', + marked: + 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', + unmarked: 'Token che non rappresentano più posizioni: {count}.', + settingChanged: '{setting} impostato su {value}.', + rescanned: + 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + calibrated: + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + calibrationReset: + 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', + migrated: + 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + pruned: + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + readyHint: + 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + }, + warnings: { + foregroundUnavailable: + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + someFailed: + 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', + }, + errors: { + noPage: 'Impossibile trovare la pagina su cui lavorare.', + notHex: 'Questa pagina non utilizza una griglia esadecimale.', + noPolygons: 'Seleziona una o più forme disegnate da riempire.', + emptyArea: "L'area selezionata non contiene centri esadecimali.", + tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', + nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', + noTokens: 'Seleziona prima uno o più token.', + noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToUndo: "Non c'è nessun riempimento da annullare.", + unknownCommand: 'Comando sconosciuto: {command}', + unknownSetting: 'Impostazione sconosciuta: {key}', + unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', + invalidValue: '"{value}" non è un valore valido per {key}.', + calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', + calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + unexpected: 'Qualcosa è andato storto: {message}', + }, + hints: { + noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', + notHex: + 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + noPolygons: + "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", + emptyArea: + 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', + tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", + noHexes: + 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + unknownCommand: 'Digita !hexploration help per elencare i comandi.', + unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', + calibrateNeedsTokens: + 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + calibrateFailed: + 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + unexpected: 'I dettagli si trovano nel registro della console API.', + }, + help: { + menu: 'Mostra il menù.', + fill: 'Copri le forme disegnate selezionate con esagoni.', + fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", + undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + reveal: + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', + conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", + explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', + unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + set: "Modifica un'impostazione o mostra tutte le impostazioni.", + pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageClear: 'Rimuovi le sostituzioni della pagina corrente.', + rescan: + "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + calibrate: + 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', + status: 'Mostra cosa sa Hexploration sulla pagina corrente.', + journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + help: 'Mostra questo elenco.', + handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + }, + deck: { + subtitle: 'Mazzo di comando', + drawDesc: + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + revealDesc: + 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + locationsDesc: + 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + toolsDesc: + 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', + footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + }, + handout: { + versionLabel: 'Versione', + subtitle: 'Esplorazione esagono per esagono per Roll20', + footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + overview: { + heading: 'Panoramica', + body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + demo: 'Guarda una breve demo (dalla versione 1)', + }, + quickStart: { + heading: 'Avvio rapido', + steps: [ + 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', + "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", + 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + ], + }, + commands: { + heading: 'Comandi', + intro: + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + colCommand: 'Comando', + colDesc: 'Cosa fa', + }, + revealing: { + heading: 'Come funziona la rivelazione', + points: [ + 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', + 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', + "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", + 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + ], + }, + locations: { + heading: 'Esagoni e posizioni con nome', + points: [ + 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", + 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + ], + }, + settings: { + heading: 'Impostazioni', + intro: + 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + colKey: 'Chiave', + colName: 'Collocamento', + colDesc: 'Descrizione', + perPage: '(Può essere impostato per pagina.)', + }, + jumpgate: { + heading: 'Jumpgate e Legacy', + points: [ + "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", + "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + ], + }, + upgrading: { + heading: 'Aggiornamento dalla versione 1', + points: [ + 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', + 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', + 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + ], + colV1: 'Comando della versione 1', + colV2: 'Comando della versione 2', + }, + troubleshooting: { + heading: 'Risoluzione dei problemi', + points: [ + 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', + 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', + "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', + ], + }, + languages: { + heading: 'Lingue', + body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + }, + credits: { + heading: 'Crediti', + original: 'Mod originale di', + maintainer: 'Versione 2 mantenuta da', + marketplace: 'I pacchetti artistici di Ada sul Marketplace Roll20', + support: + "Se trovi un bug o hai un'idea, pubblica un post nel forum Roll20 Mod o apri un problema su GitHub e includi eventuali messaggi dal registro della console API.", + }, + }, + }; + + const TRANSLATION$9 = { + titles: { + ready: 'H探索の準備は完了です。', + settings: 'H探索設定', + languages: '言語を選択してください', + pageSettings: 'ページ設定: {page}', + status: 'H探索ステータス: {page}', + help: 'H探索コマンド', + confirm: 'ご確認ください', + }, + discovery: { + title: '場所が発見されました', + }, + menu: { + draw: '描く', + reveal: '表示と非表示', + locations: '所在地', + tools: 'ツール', + layerInUse: '新しいヘクスが {layer} に描画されています。', + pageSettingsHelp: + 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', + }, + buttons: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + undo: '塗りつぶしを元に戻す', + reveal: '明らかにする', + conceal: '隠す', + explore: '探検する', + revealPage: 'ページを公開', + resetPage: 'ページをリセット', + mark: '位置をマークする', + unmark: 'マークを外す', + name: '名前の 16 進数', + settings: '設定', + pageSettings: 'ページ設定', + status: '状態', + rescan: '再スキャン', + calibrate: '校正する', + calibrateReset: 'キャリブレーションをリセットする', + help: 'ヘルプ', + change: '変化', + menu: 'メニュー', + clearOverrides: 'オーバーライドのクリア', + confirmReset: 'はい、すべてのヘクスを削除します', + }, + prompts: { + name: '場所の名前 (クリアするには空白のままにします)', + }, + values: { + on: 'の上', + off: 'オフ', + none: 'なし', + hexLayer: { + auto: '自動 (利用可能な場合は前景)', + foreground: '前景レイヤー', + objects: 'トークン層', + }, + revealBy: { + players: 'プレイヤートークン', + characters: 'キャラクタートークン', + all: 'すべてのトークン', + }, + revealMode: { + clear: 'クリア', + glimpse: '垣間見る', + }, + announce: { + all: 'みんな', + gm: 'GMのみ', + off: 'オフ', + }, + orientation: { + vertical: 'ヘックス(V)', + horizontal: '六角(H)', + }, + fillKind: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + conceal: '隠す', + }, + }, + settings: { + language: { + label: '言語', + desc: 'メニュー、メッセージ、配布資料の言語。', + }, + hexLayer: { + label: 'ヘックスレイヤー', + desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + }, + fillColor: { + label: '塗りつぶしの色', + desc: '新しいヘクスの色。シースルー ヘクスには rgba() を使用します (例: rgba(0,0,0,0.8))。', + }, + strokeColor: { + label: '枠線の色', + desc: '新しいヘクスの輪郭の色。', + }, + labelColor: { + label: 'ラベルの色', + desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', + }, + glimpseColor: { + label: '垣間見える色', + desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + }, + strokeWidth: { + label: '枠線の幅', + desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', + }, + maxDistance: { + label: '16進数の表示距離', + desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', + }, + revealDistance: { + label: '視距離', + desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + }, + lineOfSight: { + label: '視線', + desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', + }, + revealPath: { + label: 'パスに沿って表示', + desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', + }, + revealBy: { + label: '明らかにするトークン', + desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + }, + revealMode: { + label: 'リビールモード', + desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + }, + announce: { + label: '発見の発表', + desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', + }, + pingDiscoveries: { + label: 'Ping の発見', + desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + }, + hideCoveredTokens: { + label: 'カバーされたトークンを非表示にする', + desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', + }, + }, + status: { + engine: 'ゲームエンジン', + grid: 'グリッド', + layer: 'ヘックスレイヤー', + hexes: 'ヘクス', + named: '名前付きヘクス', + icons: '位置トークン', + glimpsed: '垣間見えるヘクス', + pending: '埋まりを待っている場所', + calibrated: '校正済み', + overrides: 'ページの上書き', + undo: '元に戻すことが可能', + }, + messages: { + filled: + '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + revealed: '明らかになったヘクス: {count}。', + revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', + confirmReset: + '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + resetPage: 'ページから削除されたヘクス: {count}。', + undone: + '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', + named: '「{name}」という名前のヘクス: {count}。', + unnamed: '削除された名前: {count}。', + marked: + '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + unmarked: '場所ではなくなったトークン: {count}。', + settingChanged: '{setting} を {value} に設定します。', + rescanned: + '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + calibrated: + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + calibrationReset: + 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', + migrated: + 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + pruned: + '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', + readyHint: + 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + }, + warnings: { + foregroundUnavailable: + 'このゲームは前景レイヤーでの描画をサポートしていないため、ヘクスはトークン レイヤーに描画されました。', + someFailed: + '描画できなかったヘクス: {count}。詳細については API コンソールを確認してください。', + }, + errors: { + noPage: '作業するページが見つかりませんでした。', + notHex: 'このページでは 16 進グリッドは使用されていません。', + noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', + emptyArea: '選択した領域には六角中心が含まれていません。', + tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', + nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', + nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', + noTokens: '最初に 1 つ以上のトークンを選択します。', + noHexes: '最初に 1 つ以上のヘクス (またはヘクス上にあるトークン) を選択します。', + nothingToUndo: '元に戻す塗りつぶしはありません。', + unknownCommand: '不明なコマンド: {command}', + unknownSetting: '不明な設定: {key}', + unknownPageSetting: 'ページごとに設定できる設定: {keys}', + invalidValue: '「{value}」は、{key} の有効な値ではありません。', + calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateFailed: 'これらのトークンは調整には使用できません。', + unexpected: '問題が発生しました: {message}', + }, + hints: { + noPage: '作業したいページを開くか、ページ上で何かを選択します。', + notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + noPolygons: + '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', + emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', + tooMany: 'より小さい領域を塗りつぶすか、領域をいくつかの形状に分割します。', + noHexes: 'ヘクスは前景またはトークン層にあります。そのレイヤーに切り替えて選択します。', + unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', + unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', + calibrateNeedsTokens: + 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + calibrateFailed: + '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + unexpected: '詳細は API コンソールのログに記載されています。', + }, + help: { + menu: 'メニューを表示します。', + fill: '選択した描画形状を六角形で覆います。', + fillInverse: '選択した図形の内側を除いてページ全体を覆います。', + undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', + revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', + conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', + resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', + name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', + mark: '選択したトークンを非表示の場所に変更します。', + unmark: '選択したトークンが非表示の場所になるのを停止します。', + set: '設定を変更するか、すべての設定を表示します。', + pageSet: '現在のページでのみ公開設定をオーバーライドします。', + pageClear: '現在のページのオーバーライドを削除します。', + rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + calibrate: + '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + calibrateReset: '現在のページの調整を削除します。', + status: '現在のページについて Hexploration が知っていることを表示します。', + journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + help: 'このリストを表示します。', + handout: '完全な手順は配布資料「{name}」に記載されています。', + }, + deck: { + subtitle: 'コマンドデッキ', + drawDesc: + '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + revealDesc: + 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + locationsDesc: + 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + toolsDesc: + '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', + footer: '完全な手順については、配布資料「{help}」を参照してください。', + }, + handout: { + versionLabel: 'バージョン', + subtitle: 'Roll20 のヘックスごとの探索', + footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', + overview: { + heading: '概要', + body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + demo: '短いデモを見る (バージョン 1 から)', + }, + quickStart: { + heading: 'クイックスタート', + steps: [ + 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', + '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', + 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', + 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + ], + }, + commands: { + heading: 'コマンド', + intro: + 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', + colCommand: '指示', + colDesc: '何をするのか', + }, + revealing: { + heading: '暴露の仕組み', + points: [ + 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', + 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', + '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', + 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', + 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + ], + }, + locations: { + heading: '名前付きヘクスと場所', + points: [ + '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', + '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', + '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + ], + }, + settings: { + heading: '設定', + intro: + '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + colKey: '鍵', + colName: '設定', + colDesc: '説明', + perPage: '（ページごとに設定可能）', + }, + jumpgate: { + heading: 'ジャンプゲートとレガシー', + points: [ + 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', + 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', + 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', + ], + }, + upgrading: { + heading: 'バージョン1からのアップグレード', + points: [ + 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', + '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', + 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + ], + colV1: 'バージョン1のコマンド', + colV2: 'バージョン 2 コマンド', + }, + troubleshooting: { + heading: 'トラブルシューティング', + points: [ + 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', + 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', + 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', + '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', + ], + }, + languages: { + heading: '言語', + body: '!hexploration set language で言語を選択します。利用可能な言語:', + }, + credits: { + heading: 'クレジット', + original: 'オリジナルMODによる', + maintainer: 'バージョン 2 の保守者', + marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', + support: + 'バグを見つけた場合やアイデアがある場合は、Roll20 Mod フォーラムに投稿するか、GitHub で問題を開いて、API コンソール ログからのメッセージを含めてください。', + }, + }, + }; + + const TRANSLATION$8 = { + titles: { + ready: '탐색이 준비되었습니다.', + settings: '탐색 설정', + languages: '언어를 선택하세요', + pageSettings: '페이지 설정: {page}', + status: '탐색 상태: {page}', + help: '탐색 명령', + confirm: '확인해주세요', + }, + discovery: { + title: '발견된 위치', + }, + menu: { + draw: '그리다', + reveal: '공개 및 숨기기', + locations: '위치', + tools: '도구', + layerInUse: '{layer}에 새로운 헥스가 그려지고 있습니다.', + pageSettingsHelp: + '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', + }, + buttons: { + fill: '채우다', + fillInverse: '역 채우기', + undo: '채우기 실행 취소', + reveal: '드러내다', + conceal: '숨기다', + explore: '탐구하다', + revealPage: '페이지 공개', + resetPage: '페이지 재설정', + mark: '위치 표시', + unmark: '표시 해제', + name: '이름 헥스', + settings: '설정', + pageSettings: '페이지 설정', + status: '상태', + rescan: '다시 스캔', + calibrate: '교정', + calibrateReset: '교정 재설정', + help: '돕다', + change: '변화', + menu: '메뉴', + clearOverrides: '재정의 지우기', + confirmReset: '예, 모든 16진수를 제거합니다.', + }, + prompts: { + name: '위치 이름(지우려면 비워 두세요)', + }, + values: { + on: '~에', + off: '끄다', + none: '없음', + hexLayer: { + auto: '자동(사용 가능한 경우 전경)', + foreground: '전경 레이어', + objects: '토큰 레이어', + }, + revealBy: { + players: '플레이어 토큰', + characters: '캐릭터 토큰', + all: '모든 토큰', + }, + revealMode: { + clear: '분명한', + glimpse: '일견', + }, + announce: { + all: '모든 사람', + gm: 'GM 전용', + off: '끄다', + }, + orientation: { + vertical: '16진수(V)', + horizontal: '16진수(H)', + }, + fillKind: { + fill: '채우다', + fillInverse: '역 채우기', + conceal: '숨기다', + }, + }, + settings: { + language: { + label: '언어', + desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', + }, + hexLayer: { + label: '육각 레이어', + desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + }, + fillColor: { + label: '채우기 색상', + desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + }, + strokeColor: { + label: '테두리 색상', + desc: '새로운 육각형의 윤곽선 색상입니다.', + }, + labelColor: { + label: '라벨 색상', + desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + }, + glimpseColor: { + label: '미리보기 색상', + desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + }, + strokeWidth: { + label: '테두리 너비', + desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', + }, + maxDistance: { + label: '16진수 공개 거리', + desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', + }, + revealDistance: { + label: '시거리', + desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + }, + lineOfSight: { + label: '시선', + desc: '켜져 있으면 헥스와 토큰 사이에 가려진 헥스가 없는 경우에만 헥스가 드러납니다.', + }, + revealPath: { + label: '경로를 따라 표시', + desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', + }, + revealBy: { + label: '공개되는 토큰', + desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + }, + revealMode: { + label: '공개 모드', + desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + }, + announce: { + label: '발견 발표', + desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', + }, + pingDiscoveries: { + label: '핑 발견', + desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', + }, + hideCoveredTokens: { + label: '적용 토큰 숨기기', + desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + }, + }, + status: { + engine: '게임 엔진', + grid: '그리드', + layer: '육각층', + hexes: '헥스', + named: '명명된 헥스', + icons: '위치 토큰', + glimpsed: '살짝 엿본 육각형', + pending: '채우기를 기다리는 위치', + calibrated: '교정됨', + overrides: '페이지 재정의', + undo: '실행 취소 가능', + }, + messages: { + filled: + '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', + revealed: '공개된 헥스: {count}.', + revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + confirmReset: + '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거된 16진수: {count}.', + undone: + '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + named: '"{name}"이라는 헥스: {count}.', + unnamed: '지워진 이름: {count}.', + marked: + '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + unmarked: '더 이상 위치가 아닌 토큰: {count}.', + settingChanged: '{setting}이(가) {value}로 설정되었습니다.', + rescanned: + '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + calibrated: + '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + calibrationReset: + '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', + migrated: + 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + pruned: + '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', + readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + }, + warnings: { + foregroundUnavailable: + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', + someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + }, + errors: { + noPage: '작업할 페이지를 찾을 수 없습니다.', + notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', + emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', + nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', + nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + noTokens: '먼저 하나 이상의 토큰을 선택하세요.', + noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', + nothingToUndo: '실행 취소할 채우기가 없습니다.', + unknownCommand: '알 수 없는 명령: {command}', + unknownSetting: '알 수 없는 설정: {key}', + unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', + invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', + calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', + unexpected: '문제가 발생했습니다: {message}', + }, + hints: { + noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', + notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + noPolygons: + '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', + emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', + tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', + noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + calibrateNeedsTokens: + '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + calibrateFailed: + '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + unexpected: '세부정보는 API 콘솔 로그에 있습니다.', + }, + help: { + menu: '메뉴를 보여주세요.', + fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', + undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', + reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', + resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', + mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', + unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', + set: '설정을 변경하거나 모든 설정을 표시합니다.', + pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', + pageClear: '현재 페이지의 재정의를 제거합니다.', + rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', + calibrate: + '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + calibrateReset: '현재 페이지의 보정을 제거합니다.', + status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + help: '이 목록을 보여주세요.', + handout: '전체 지침은 "{name}" 유인물에 있습니다.', + }, + deck: { + subtitle: '커맨드 덱', + drawDesc: + '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + revealDesc: + '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + locationsDesc: + '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', + footer: '전체 지침은 "{help}" 유인물을 참조하세요.', + }, + handout: { + versionLabel: '버전', + subtitle: 'Roll20의 16진수 탐색', + footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', + overview: { + heading: '개요', + body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + demo: '짧은 데모 보기(버전 1부터)', + }, + quickStart: { + heading: '빠른 시작', + steps: [ + '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', + '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', + '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + ], + }, + commands: { + heading: '명령', + intro: + 'GM만이 이 명령을 사용할 수 있습니다. 대부분은 선택한 개체에 작용합니다. 나머지는 현재 보고 있는 페이지에서 수행됩니다.', + colCommand: '명령', + colDesc: '기능', + }, + revealing: { + heading: '공개 작동 방식', + points: [ + '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', + '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', + 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', + 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + ], + }, + locations: { + heading: '명명된 육각형 및 위치', + points: [ + 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', + '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', + 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', + '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + ], + }, + settings: { + heading: '설정', + intro: + '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + colKey: '열쇠', + colName: '환경', + colDesc: '설명', + perPage: '(페이지별로 설정 가능합니다.)', + }, + jumpgate: { + heading: '점프게이트와 레거시', + points: [ + 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', + 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', + 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', + ], + }, + upgrading: { + heading: '버전 1에서 업그레이드', + points: [ + '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', + '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', + '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + ], + colV1: '버전 1 명령', + colV2: '버전 2 명령', + }, + troubleshooting: { + heading: '문제 해결', + points: [ + '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', + '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', + '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', + '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', + ], + }, + languages: { + heading: '언어', + body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + }, + credits: { + heading: '크레딧', + original: '원본 모드 작성자:', + maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', + marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', + support: + '버그를 발견하거나 아이디어가 있는 경우 Roll20 Mod 포럼에 게시하거나 GitHub에서 문제를 열고 API 콘솔 로그의 메시지를 포함하세요.', + }, + }, + }; + + const TRANSLATION$7 = { + titles: { + ready: 'Heksploracja jest gotowa.', + settings: 'Ustawienia Heksploracji', + languages: 'Wybierz język', + pageSettings: 'Ustawienia strony: {page}', + status: 'Stan heksploracji: {page}', + help: 'Komendy Heksploracji', + confirm: 'Proszę potwierdzić', + }, + discovery: { + title: 'Lokalizacja odkryta', + }, + menu: { + draw: 'Rysować', + reveal: 'Odkryj i ukryj', + locations: 'Lokalizacje', + tools: 'Narzędzia', + layerInUse: 'Nowe heksy są rysowane na {layer}.', + pageSettingsHelp: + 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', + }, + buttons: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + undo: 'Cofnij wypełnienie', + reveal: 'Ujawnić', + conceal: 'Ukryć', + explore: 'Badać', + revealPage: 'Odkryj stronę', + resetPage: 'Zresetuj stronę', + mark: 'Zaznacz lokalizację', + unmark: 'Odznacz', + name: 'Imię Hex', + settings: 'Ustawienia', + pageSettings: 'Ustawienia strony', + status: 'Status', + rescan: 'Skanuj ponownie', + calibrate: 'Kalibrować', + calibrateReset: 'Zresetuj kalibrację', + help: 'Pomoc', + change: 'Zmiana', + menu: 'Menu', + clearOverrides: 'Wyczyść zastąpienia', + confirmReset: 'Tak, usuń wszystkie heksy', + }, + prompts: { + name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', + }, + values: { + on: 'NA', + off: 'Wyłączony', + none: 'Nic', + hexLayer: { + auto: 'Auto (pierwszy plan, jeśli jest dostępny)', + foreground: 'warstwa pierwszego planu', + objects: 'warstwa tokenów', + }, + revealBy: { + players: 'Żetony graczy', + characters: 'Żetony postaci', + all: 'Wszystkie tokeny', + }, + revealMode: { + clear: 'Jasne', + glimpse: 'Dojrzeć', + }, + announce: { + all: 'Wszyscy', + gm: "Tylko GM'a", + off: 'Wyłączony', + }, + orientation: { + vertical: 'Sześciokąt (V)', + horizontal: 'Sześciokąt (H)', + }, + fillKind: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + conceal: 'Ukryć', + }, + }, + settings: { + language: { + label: 'Język', + desc: 'Język menu, komunikatów i materiałów informacyjnych.', + }, + hexLayer: { + label: 'Warstwa szesnastkowa', + desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + }, + fillColor: { + label: 'Kolor wypełnienia', + desc: 'Kolor nowych heksów. Użyj rgba() dla przezroczystych heksów, na przykład rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kolor obramowania', + desc: 'Kolor konturu nowych heksów.', + }, + labelColor: { + label: 'Kolor etykiety', + desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + }, + glimpseColor: { + label: 'Kolor przebłysku', + desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + }, + strokeWidth: { + label: 'Szerokość obramowania', + desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', + }, + maxDistance: { + label: 'Odległość ujawnienia heksadecymalnego', + desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', + }, + revealDistance: { + label: 'Odległość wzroku', + desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', + }, + lineOfSight: { + label: 'Linia wzroku', + desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', + }, + revealPath: { + label: 'Odkryj wzdłuż ścieżki', + desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + }, + revealBy: { + label: 'Żetony, które ujawniają', + desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', + }, + revealMode: { + label: 'Tryb ujawnienia', + desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + }, + announce: { + label: 'Ogłoś odkrycia', + desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', + }, + pingDiscoveries: { + label: 'Odkrycia pingowe', + desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', + }, + hideCoveredTokens: { + label: 'Ukryj zakryte tokeny', + desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', + }, + }, + status: { + engine: 'Silnik gry', + grid: 'Siatka', + layer: 'Warstwa sześciokątna', + hexes: 'Heksy', + named: 'Nazwane heksy', + icons: 'Żetony lokalizacji', + glimpsed: 'Prześwietlone heksy', + pending: 'Lokalizacje oczekujące na zapełnienie', + calibrated: 'Kalibrowane', + overrides: 'Zastąpienia strony', + undo: 'Cofnij dostępne', + }, + messages: { + filled: + 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + revealed: 'Ujawnione heksy: {count}.', + revealedPage: 'Każdy odkryty heks na stronie ({count}).', + confirmReset: + 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', + resetPage: 'Heksy usunięte ze strony: {count}.', + undone: + 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + named: 'Heksy o nazwie „{name}”: {count}.', + unnamed: 'Nazwy zostały usunięte: {count}.', + marked: + 'Lokalizacje ukryte na istniejących heksach: {attached}. Czekam na następne wypełnienie, które je obejmuje: {pending}.', + unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', + settingChanged: '{setting} ustawiony na {value}.', + rescanned: + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + calibrated: + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + calibrationReset: + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', + migrated: + 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + pruned: + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', + readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + }, + warnings: { + foregroundUnavailable: + 'Ta gra nie obsługuje rysowania na warstwie pierwszego planu, więc heksy zostały narysowane na warstwie żetonów.', + someFailed: + 'Heksy, których nie można narysować: {count}. Aby uzyskać szczegółowe informacje, sprawdź konsolę API.', + }, + errors: { + noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', + notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', + emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', + nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', + nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', + noTokens: 'Najpierw wybierz jeden lub więcej tokenów.', + noHexes: 'Najpierw wybierz jeden lub więcej heksów (lub żetonów stojących na heksach).', + nothingToUndo: 'Nie ma wypełnienia, które można cofnąć.', + unknownCommand: 'Nieznane polecenie: {command}', + unknownSetting: 'Nieznane ustawienie: {key}', + unknownPageSetting: 'Ustawienia, które można ustawić na stronie: {keys}', + invalidValue: '„{value}” nie jest prawidłową wartością dla {key}.', + calibrateNeedsTokens: 'Wybierz jeden lub dwa żetony przyciągnięte do środków heksów.', + calibrateFailed: 'Tych tokenów nie można używać do kalibracji.', + unexpected: 'Coś poszło nie tak: {message}', + }, + hints: { + noPage: 'Otwórz stronę, nad którą chcesz pracować, lub wybierz coś na niej.', + notHex: 'Ustaw siatkę strony na Hex (V) lub Hex (H) w Ustawieniach strony.', + noPolygons: + 'Narysuj wielokąt, prostokąt, elipsę lub odręczny kształt wokół obszaru, zaznacz go i spróbuj ponownie.', + emptyArea: 'Narysuj większy kształt lub sprawdź ustawienia siatki strony.', + tooMany: 'Wypełnij mniejszy obszar lub podziel obszar na kilka kształtów.', + noHexes: + 'Heksy znajdują się na pierwszym planie lub w warstwie żetonów; przejdź do tej warstwy, aby je wybrać.', + unknownCommand: 'Wpisz !hexploration help, aby wyświetlić listę poleceń.', + unknownSetting: 'Wpisz !hexploration set, aby zobaczyć wszystkie ustawienia.', + calibrateNeedsTokens: + 'Przyciągnij żeton do środka heksa i wybierz go. Wybierz drugi żeton przyciągnięty do sąsiedniego heksu w tym samym rzędzie (Hex V) lub kolumnie (Hex H), aby również skorygować rozmiar heksa.', + calibrateFailed: + 'Dwa żetony muszą znajdować się w tym samym rzędzie (Hex V) lub w tej samej kolumnie (Hex H), w odległości co najmniej jednego heksa od siebie.', + unexpected: 'Szczegóły znajdują się w dzienniku konsoli API.', + }, + help: { + menu: 'Pokaż menu.', + fill: 'Zakryj wybrane narysowane kształty heksami.', + fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', + undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', + revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', + conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', + explore: 'Odsłoń wokół wybranych żetonów tak, jakby właśnie się tam przesunęły.', + resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', + name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', + mark: 'Zamień wybrane żetony w ukryte lokalizacje.', + unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', + pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', + pageClear: 'Usuń zastąpienia bieżącej strony.', + rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + calibrate: + 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', + calibrateReset: 'Usuń kalibrację bieżącej strony.', + status: 'Pokaż, co Heexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + help: 'Pokaż tę listę.', + handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', + }, + deck: { + subtitle: 'Pokład dowodzenia', + drawDesc: + 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', + revealDesc: + 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + locationsDesc: + 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', + toolsDesc: + 'Ustawienia, nadpisania stron, status, ponowne skanowanie skopiowanych stron i kalibracja siatki.', + footer: 'Pełne instrukcje znajdziesz w ulotce „{help}”.', + }, + handout: { + versionLabel: 'Wersja', + subtitle: 'Eksploracja heks po heksie dla Roll20', + footer: + 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + overview: { + heading: 'Przegląd', + body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (od wersji 1)', + }, + quickStart: { + heading: 'Szybki start', + steps: [ + 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', + 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', + 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', + 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + ], + }, + commands: { + heading: 'Polecenia', + intro: + 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', + colCommand: 'Rozkaz', + colDesc: 'Co to robi', + }, + revealing: { + heading: 'Jak działa odkrywanie', + points: [ + 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', + 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', + 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', + 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + ], + }, + locations: { + heading: 'Nazwane heksy i lokalizacje', + points: [ + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', + 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', + 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + ], + }, + settings: { + heading: 'Ustawienia', + intro: + 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', + colKey: 'Klawisz', + colName: 'Ustawienie', + colDesc: 'Opis', + perPage: '(Można ustawić na stronę.)', + }, + jumpgate: { + heading: 'Jumpgate i Dziedzictwo', + points: [ + 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', + 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + ], + }, + upgrading: { + heading: 'Aktualizacja z wersji 1', + points: [ + 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', + 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', + 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', + 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + ], + colV1: 'Polecenie wersji 1', + colV2: 'Polecenie wersji 2', + }, + troubleshooting: { + heading: 'Rozwiązywanie problemów', + points: [ + 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', + 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', + 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', + ], + }, + languages: { + heading: 'Języki', + body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + }, + credits: { + heading: 'Kredyty', + original: 'Oryginalny mod autorstwa', + maintainer: 'Wersja 2 obsługiwana przez', + marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', + support: + 'Jeśli znajdziesz błąd lub masz pomysł, opublikuj post na forum Roll20 Mod lub otwórz problem w GitHub i dołącz wszelkie komunikaty z dziennika konsoli API.', + }, + }, + }; + + const TRANSLATION$6 = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Definições da página: {page}', + status: 'Estado de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + pageSettingsHelp: + 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Estatuto', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixar em branco para limpar)', + }, + values: { + on: 'Em', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Relance', + }, + announce: { + all: 'Toda a gente', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Utilize rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do percurso', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Rede', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Fichas de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais a aguardar preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', + unmarked: 'Tokens que já não são locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + calibrated: + 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não utiliza uma grelha hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione primeiro um ou mais tokens.', + noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', + nothingToUndo: 'Não há enchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + unexpected: 'Algo correu mal: {message}', + }, + hints: { + noPage: 'Abra a página na qual pretende trabalhar ou selecione algo da mesma.', + notHex: 'Defina a grelha da página para Hex (V) ou Hex (H) nas Definições da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre à volta da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', + tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + unknownCommand: 'Introduza !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as definições.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log da consola da API.', + }, + help: { + menu: 'Mostre o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma definição ou mostre todas as definições.', + pageSet: 'Substituir uma configuração de revelação apenas na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + locationsDesc: + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + footer: 'Consulte o folheto "{help}" para obter as instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Utilize o folheto "{deck}" para controlos de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Apenas os GMs podem usar estes comandos. A maioria atua sobre os objetos selecionados; o resto atua na página que está a visualizar.', + colCommand: 'Comando', + colDesc: 'O que faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + colKey: 'Chave', + colName: 'Definição', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualização da versão 1', + points: [ + 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', + 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versão 2 mantida pela', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', + }, + }, + }; + + const TRANSLATION$5 = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Configurações da página: {page}', + status: 'Status de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Empate', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + pageSettingsHelp: + 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Status', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixe em branco para limpar)', + }, + values: { + on: 'Sobre', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Todos', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Linguagem', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Use rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do caminho', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras acima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm seu nome, barras e auras visíveis ao jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grade', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Tokens de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais aguardando preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos chamados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + unmarked: 'Tokens que não são mais locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + calibrated: + 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não usa uma grade hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione um ou mais tokens primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + nothingToUndo: 'Não há preenchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + unexpected: 'Algo deu errado: {message}', + }, + hints: { + noPage: 'Abra a página na qual deseja trabalhar ou selecione algo nela.', + notHex: 'Defina a grade da página como Hex (V) ou Hex (H) nas Configurações da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre ao redor da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', + tooMany: 'Preencha uma área menor ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + unknownCommand: 'Digite !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as configurações.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log do console da API.', + }, + help: { + menu: 'Mostre o cardápio.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma configuração ou mostre todas as configurações.', + pageSet: 'Substituir uma configuração de revelação somente na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + locationsDesc: + 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + footer: 'Consulte o folheto "{help}" para obter instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Use o folheto "{deck}" para controles de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Somente GMs podem usar esses comandos. A maioria atua nos objetos selecionados; o resto atua na página que você está visualizando.', + colCommand: 'Comando', + colDesc: 'O que isso faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + colKey: 'Chave', + colName: 'Contexto', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualizando da versão 1', + points: [ + 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', + 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original por', + maintainer: 'Versão 2 mantida por', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se você encontrar um bug ou tiver uma ideia, poste no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do log do console da API.', + }, + }, + }; + + const TRANSLATION$4 = { + titles: { + ready: 'Геразведка готова.', + settings: 'Настройки Hexploration', + languages: 'Выберите язык', + pageSettings: 'Настройки страницы: {page}', + status: 'Статус гексоразведки: {page}', + help: 'Команды гексоразведки', + confirm: 'Пожалуйста, подтвердите', + }, + discovery: { + title: 'Местоположение обнаружено', + }, + menu: { + draw: 'Рисовать', + reveal: 'Показать и скрыть', + locations: 'Локации', + tools: 'Инструменты', + layerInUse: 'Новые гексы рисуются на {layer}.', + pageSettingsHelp: + 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', + }, + buttons: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + undo: 'Отменить заливку', + reveal: 'Раскрывать', + conceal: 'Скрыть', + explore: 'Исследовать', + revealPage: 'Открыть страницу', + resetPage: 'Сбросить страницу', + mark: 'Отметить местоположение', + unmark: 'Снять отметку', + name: 'Шестнадцатеричное имя', + settings: 'Настройки', + pageSettings: 'Настройки страницы', + status: 'Статус', + rescan: 'Повторное сканирование', + calibrate: 'Калибровка', + calibrateReset: 'Сброс калибровки', + help: 'Помощь', + change: 'Изменять', + menu: 'Меню', + clearOverrides: 'Очистить переопределения', + confirmReset: 'Да, удалить все шестигранники', + }, + prompts: { + name: 'Название местоположения (оставьте пустым, чтобы очистить)', + }, + values: { + on: 'На', + off: 'Выключенный', + none: 'Никто', + hexLayer: { + auto: 'Авто (на переднем плане, если доступно)', + foreground: 'передний слой', + objects: 'слой токенов', + }, + revealBy: { + players: 'Жетоны игроков', + characters: 'Жетоны персонажей', + all: 'Все токены', + }, + revealMode: { + clear: 'Прозрачный', + glimpse: 'Случайно заметить', + }, + announce: { + all: 'Каждый', + gm: 'только ГМ', + off: 'Выключенный', + }, + orientation: { + vertical: 'Шестигранник (В)', + horizontal: 'Шестигранник (H)', + }, + fillKind: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + conceal: 'Скрыть', + }, + }, + settings: { + language: { + label: 'Язык', + desc: 'Язык меню, сообщений и раздаточных материалов.', + }, + hexLayer: { + label: 'Шестнадцатеричный слой', + desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + }, + fillColor: { + label: 'Цвет заливки', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Цвет границы', + desc: 'Цвет контура новых гексов.', + }, + labelColor: { + label: 'Цвет этикетки', + desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + }, + glimpseColor: { + label: 'Взгляд цвета', + desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + }, + strokeWidth: { + label: 'Ширина границы', + desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + }, + maxDistance: { + label: 'Расстояние раскрытия шестигранника', + desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', + }, + revealDistance: { + label: 'Расстояние обзора', + desc: 'Сколько гексов вокруг движущегося жетона обнаружено (от 0 до 20). 0 показывает только те гексы, через которые проходит фишка.', + }, + lineOfSight: { + label: 'Линия видимости', + desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', + }, + revealPath: { + label: 'Показать вдоль пути', + desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', + }, + revealBy: { + label: 'Жетоны, которые раскрывают', + desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', + }, + revealMode: { + label: 'Режим раскрытия', + desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + }, + announce: { + label: 'Объявлять об открытиях', + desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', + }, + pingDiscoveries: { + label: 'Пинг-открытия', + desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + }, + hideCoveredTokens: { + label: 'Скрыть покрытые токены', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + }, + }, + status: { + engine: 'Игровой движок', + grid: 'Сетка', + layer: 'Шестнадцатеричный слой', + hexes: 'шестиугольники', + named: 'Именованные шестигранники', + icons: 'Жетоны местоположения', + glimpsed: 'Замеченные гексы', + pending: 'Места, ожидающие заполнения', + calibrated: 'Калиброванный', + overrides: 'Переопределения страниц', + undo: 'Отмена доступна', + }, + messages: { + filled: + 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', + revealed: 'Обнаружены гексы: {count}.', + revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + confirmReset: + 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + resetPage: 'Со страницы удалены шестигранники: {count}.', + undone: + 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Шестигранники с именем "{name}": {count}.', + unnamed: 'Имена удалены: {count}.', + marked: + 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', + unmarked: 'Токены, которые больше не являются локациями: {count}.', + settingChanged: 'Для {setting} установлено значение {value}.', + rescanned: + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + calibrated: + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + calibrationReset: + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', + migrated: + 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + pruned: + 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + readyHint: + 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + }, + warnings: { + foregroundUnavailable: + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + someFailed: + 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', + }, + errors: { + noPage: 'Не удалось найти страницу для работы.', + notHex: 'На этой странице не используется шестигранная сетка.', + noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', + emptyArea: 'Выбранная область не содержит шестигранных центров.', + tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', + nothingToReveal: + 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + noTokens: 'Сначала выберите один или несколько жетонов.', + noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', + nothingToUndo: 'Нет заливки, которую можно было бы отменить.', + unknownCommand: 'Неизвестная команда: {command}', + unknownSetting: 'Неизвестная настройка: {key}.', + unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', + invalidValue: '«{value}» не является допустимым значением для {key}.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', + unexpected: 'Что-то пошло не так: {message}', + }, + hints: { + noPage: 'Откройте страницу, над которой хотите работать, или выберите что-нибудь на ней.', + notHex: 'Установите сетку страницы на Hex (V) или Hex (H) в настройках страницы.', + noPolygons: + 'Нарисуйте многоугольник, прямоугольник, эллипс или фигуру от руки вокруг области, выберите ее и повторите попытку.', + emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', + tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', + noHexes: + 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', + unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', + calibrateNeedsTokens: + 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + calibrateFailed: + 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + unexpected: 'Подробности в журнале консоли API.', + }, + help: { + menu: 'Покажите меню.', + fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', + undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', + revealPage: 'Раскройте каждый гекс на странице без объявлений.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', + explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', + mark: 'Превратите выбранные жетоны в скрытые локации.', + unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', + set: 'Измените настройку или отобразите все настройки.', + pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageClear: 'Удалить переопределения текущей страницы.', + rescan: + 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + calibrate: + 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + calibrateReset: 'Удалить калибровку текущей страницы.', + status: 'Покажите, что Hexploration знает о текущей странице.', + journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + help: 'Покажите этот список.', + handout: 'Полные инструкции приведены в раздаточном материале «{name}».', + }, + deck: { + subtitle: 'Командная колода', + drawDesc: + 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + revealDesc: + 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + locationsDesc: + 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', + toolsDesc: + 'Настройки, переопределение страниц, статус, повторное сканирование скопированных страниц и калибровка сетки.', + footer: 'Подробные инструкции см. в раздаточном материале «{help}».', + }, + handout: { + versionLabel: 'Версия', + subtitle: 'Шестнадцатеричное исследование для Roll20', + footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', + overview: { + heading: 'Обзор', + body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + demo: 'Посмотрите короткую демонстрацию (из версии 1)', + }, + quickStart: { + heading: 'Быстрый старт', + steps: [ + 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', + 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', + 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', + 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', + 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + ], + }, + commands: { + heading: 'Команды', + intro: + 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + colCommand: 'Команда', + colDesc: 'Что он делает', + }, + revealing: { + heading: 'Как работает выявление', + points: [ + 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', + 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', + 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', + 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', + 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + ], + }, + locations: { + heading: 'Именованные гексы и локации', + points: [ + 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', + 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', + 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', + 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + ], + }, + settings: { + heading: 'Настройки', + intro: + 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + colKey: 'Ключ', + colName: 'Параметр', + colDesc: 'Описание', + perPage: '(Можно установить для каждой страницы.)', + }, + jumpgate: { + heading: 'Джампгейт и Наследие', + points: [ + 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', + 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + ], + }, + upgrading: { + heading: 'Обновление с версии 1', + points: [ + 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', + 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', + 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + ], + colV1: 'Команда версии 1', + colV2: 'Команда версии 2', + }, + troubleshooting: { + heading: 'Поиск неисправностей', + points: [ + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', + 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', + 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', + 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', + ], + }, + languages: { + heading: 'Языки', + body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + }, + credits: { + heading: 'Кредиты', + original: 'Оригинальный мод от', + maintainer: 'Версия 2 поддерживается', + marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', + support: + 'Если вы обнаружили ошибку или у вас есть идея, напишите сообщение на форуме Roll20 Mod или откройте проблему на GitHub и включите все сообщения из журнала консоли API.', + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: 'La hexploración está lista.', + settings: 'Configuración de hexploración', + languages: 'Elige un idioma', + pageSettings: 'Configuración de página: {page}', + status: 'Estado de exploración: {page}', + help: 'Comandos de hexploración', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Ubicación descubierta', + }, + menu: { + draw: 'Dibujar', + reveal: 'Revelar y ocultar', + locations: 'Ubicaciones', + tools: 'Herramientas', + layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + pageSettingsHelp: + 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', + }, + buttons: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + undo: 'Deshacer relleno', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Restablecer página', + mark: 'Marcar ubicación', + unmark: 'Desmarcar', + name: 'Nombre hexadecimal', + settings: 'Ajustes', + pageSettings: 'Configuración de página', + status: 'Estado', + rescan: 'Volver a escanear', + calibrate: 'Calibrar', + calibrateReset: 'Restablecer calibración', + help: 'Ayuda', + change: 'Cambiar', + menu: 'Menú', + clearOverrides: 'Borrar anulaciones', + confirmReset: 'Sí, eliminar todos los hexágonos', + }, + prompts: { + name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', + }, + values: { + on: 'En', + off: 'Apagado', + none: 'Ninguno', + hexLayer: { + auto: 'Auto (primer plano si está disponible)', + foreground: 'capa de primer plano', + objects: 'capa de token', + }, + revealBy: { + players: 'fichas de jugador', + characters: 'Fichas de personaje', + all: 'Todas las fichas', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vistazo', + }, + announce: { + all: 'Todos', + gm: 'solo GM', + off: 'Apagado', + }, + orientation: { + vertical: 'Hexágono (V)', + horizontal: 'Hexagonal (H)', + }, + fillKind: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menús, mensajes y folletos.', + }, + hexLayer: { + label: 'Capa hexagonal', + desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', + }, + fillColor: { + label: 'Color de relleno', + desc: 'Color de nuevos hexágonos. Utilice rgba() para hexágonos transparentes, por ejemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color del borde', + desc: 'Color del contorno de nuevos hexágonos.', + }, + labelColor: { + label: 'Color de la etiqueta', + desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + }, + glimpseColor: { + label: 'Color de vislumbre', + desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + }, + strokeWidth: { + label: 'Ancho del borde', + desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', + }, + maxDistance: { + label: 'Distancia de revelación hexagonal', + desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', + }, + revealDistance: { + label: 'Distancia de visión', + desc: 'Cuántos hexágonos se revelan alrededor de una ficha en movimiento (0 a 20). 0 revela sólo los hexágonos por los que pasa la ficha.', + }, + lineOfSight: { + label: 'Línea de visión', + desc: 'Cuando está activado, un hexágono sólo se revela si no hay ningún hexágono cubierto entre él y la ficha.', + }, + revealPath: { + label: 'Revelar a lo largo del camino', + desc: 'Cuando está activado, se revela cada hexágono por el que pasa una ficha mientras es arrastrada (incluidos los puntos de ruta), no solo dónde se detiene.', + }, + revealBy: { + label: 'Fichas que revelan', + desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', + }, + revealMode: { + label: 'Modo revelar', + desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + }, + announce: { + label: 'Anunciar descubrimientos', + desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', + }, + pingDiscoveries: { + label: 'Descubrimientos de ping', + desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cubiertos', + desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + }, + }, + status: { + engine: 'motor de juego', + grid: 'Red', + layer: 'capa hexagonal', + hexes: 'Hexágonos', + named: 'Hexágonos con nombre', + icons: 'Fichas de ubicación', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Ubicaciones esperando ser llenadas', + calibrated: 'Calibrado', + overrides: 'Anulaciones de página', + undo: 'Deshacer disponible', + }, + messages: { + filled: + 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + revealed: 'Hexágonos revelados: {count}.', + revealedPage: 'Cada hexágono en la página revelado ({count}).', + confirmReset: + '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', + resetPage: 'Hexes eliminados de la página: {count}.', + undone: + 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nombres borrados: {count}.', + marked: + 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', + unmarked: 'Tokens que ya no son ubicaciones: {count}.', + settingChanged: '{setting} establecido en {value}.', + rescanned: + 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + calibrated: + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + calibrationReset: + 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', + migrated: + 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + pruned: + 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', + readyHint: + 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este juego no admite dibujar en la capa de primer plano, por lo que los hexágonos se dibujaron en la capa de fichas.', + someFailed: + 'Hexágonos que no se pudieron dibujar: {count}. Consulte la consola API para obtener más detalles.', + }, + errors: { + noPage: 'No se pudo encontrar la página para trabajar.', + notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', + emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', + nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', + nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', + noTokens: 'Seleccione uno o más tokens primero.', + noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', + nothingToUndo: 'No hay ningún relleno que deshacer.', + unknownCommand: 'Comando desconocido: {command}', + unknownSetting: 'Configuración desconocida: {key}', + unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', + invalidValue: '"{value}" no es un valor válido para {key}.', + calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', + unexpected: 'Algo salió mal: {message}', + }, + hints: { + noPage: 'Abra la página en la que desea trabajar o seleccione algo en ella.', + notHex: + 'Establezca la cuadrícula de la página en Hex (V) o Hex (H) en Configuración de página.', + noPolygons: + 'Dibuja un polígono, un rectángulo, una elipse o una forma a mano alzada alrededor del área, selecciónala y vuelve a intentarlo.', + emptyArea: + 'Dibuja una forma más grande o verifica la configuración de la cuadrícula de la página.', + tooMany: 'Rellene un área más pequeña o divida el área en varias formas.', + noHexes: + 'Los hexágonos están en primer plano o en la capa de fichas; cambie a esa capa para seleccionarlas.', + unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', + unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', + calibrateNeedsTokens: + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + calibrateFailed: + 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + unexpected: 'Los detalles se encuentran en el registro de la consola API.', + }, + help: { + menu: 'Mostrar el menú.', + fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', + fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', + undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + reveal: + 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', + revealPage: 'Revela cada hexágono de la página sin anuncios.', + conceal: + 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', + explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', + name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', + mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', + unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + set: 'Cambie una configuración o muestre todas las configuraciones.', + pageSet: 'Anula una configuración de revelación solo en la página actual.', + pageClear: 'Elimine las anulaciones de la página actual.', + rescan: + 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + calibrate: + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + calibrateReset: 'Elimina la calibración de la página actual.', + status: 'Muestra lo que Hexploration sabe sobre la página actual.', + journal: 'Reconstruya los folletos de Ayuda y Comando.', + help: 'Muestra esta lista.', + handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', + }, + deck: { + subtitle: 'Cubierta de mando', + drawDesc: + 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + revealDesc: + 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + locationsDesc: + 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', + toolsDesc: + 'Configuraciones, anulaciones de páginas, estado, volver a escanear páginas copiadas y calibrar la cuadrícula.', + footer: 'Consulte el folleto "{help}" para obtener instrucciones completas.', + }, + handout: { + versionLabel: 'Versión', + subtitle: 'Exploración hexágono por hexágono para Roll20', + footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', + overview: { + heading: 'Descripción general', + body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + demo: 'Vea una breve demostración (de la versión 1)', + }, + quickStart: { + heading: 'Inicio rápido', + steps: [ + 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', + 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', + 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Dominio', + colDesc: 'que hace', + }, + revealing: { + heading: 'Cómo funciona la revelación', + points: [ + 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', + 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + ], + }, + locations: { + heading: 'Hexágonos y ubicaciones con nombre', + points: [ + 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', + 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + ], + }, + settings: { + heading: 'Ajustes', + intro: + 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + colKey: 'Llave', + colName: 'Configuración', + colDesc: 'Descripción', + perPage: '(Se puede configurar por página).', + }, + jumpgate: { + heading: 'Jumpgate y legado', + points: [ + 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', + 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + ], + }, + upgrading: { + heading: 'Actualización desde la versión 1', + points: [ + 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', + 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', + 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + ], + colV1: 'Comando versión 1', + colV2: 'Comando versión 2', + }, + troubleshooting: { + heading: 'Solución de problemas', + points: [ + 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', + 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', + 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versión 2 mantenida por', + marketplace: 'Paquetes de arte de Ada en Roll20 Marketplace', + support: + 'Si encuentra un error o tiene una idea, publíquelo en el foro Roll20 Mod o abra un problema en GitHub e incluya cualquier mensaje del registro de la consola API.', + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'Hexploration är redo.', + settings: 'Heexploration Inställningar', + languages: 'Välj ett språk', + pageSettings: 'Sidinställningar: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandon', + confirm: 'Vänligen bekräfta', + }, + discovery: { + title: 'Plats upptäckt', + }, + menu: { + draw: 'Dra', + reveal: 'Avslöja och göm', + locations: 'Platser', + tools: 'Verktyg', + layerInUse: 'Nya sexkanter ritas på {layer}.', + pageSettingsHelp: + 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', + }, + buttons: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + undo: 'Ångra Fyll', + reveal: 'Avslöja', + conceal: 'Dölja', + explore: 'Utforska', + revealPage: 'Avslöja sidan', + resetPage: 'Återställ sida', + mark: 'Markera plats', + unmark: 'Avmarkera', + name: 'Namn Hex', + settings: 'Inställningar', + pageSettings: 'Sidinställningar', + status: 'Status', + rescan: 'Skanna igen', + calibrate: 'Kalibrera', + calibrateReset: 'Återställ kalibrering', + help: 'Hjälp', + change: 'Ändra', + menu: 'Meny', + clearOverrides: 'Rensa åsidosättningar', + confirmReset: 'Ja, ta bort alla hexar', + }, + prompts: { + name: 'Platsnamn (låt vara tomt för att rensa)', + }, + values: { + on: 'På', + off: 'Av', + none: 'Ingen', + hexLayer: { + auto: 'Auto (förgrund om tillgängligt)', + foreground: 'förgrundsskikt', + objects: 'symbollager', + }, + revealBy: { + players: 'Spelarpoletter', + characters: 'Karaktärspoletter', + all: 'Alla tokens', + }, + revealMode: { + clear: 'Rensa', + glimpse: 'Glimt', + }, + announce: { + all: 'Alla', + gm: 'Endast GM', + off: 'Av', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + conceal: 'Dölja', + }, + }, + settings: { + language: { + label: 'Språk', + desc: 'Språk för menyer, meddelanden och åhörarkopior.', + }, + hexLayer: { + label: 'Hexlager', + desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + }, + fillColor: { + label: 'Fyllningsfärg', + desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfärg', + desc: 'Färg på konturerna av nya sexkanter.', + }, + labelColor: { + label: 'Etikettfärg', + desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + }, + glimpseColor: { + label: 'Glimt färg', + desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + }, + strokeWidth: { + label: 'Kantbredd', + desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + }, + maxDistance: { + label: 'Hexavslöjande avstånd', + desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', + }, + revealDistance: { + label: 'Siktavstånd', + desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', + }, + lineOfSight: { + label: 'Synlinje', + desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', + }, + revealPath: { + label: 'Avslöja längs vägen', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + }, + revealBy: { + label: 'Tokens som avslöjar', + desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + }, + revealMode: { + label: 'Avslöjande läge', + desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + }, + announce: { + label: 'Tillkännage upptäckter', + desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', + }, + pingDiscoveries: { + label: 'Ping upptäckter', + desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', + }, + hideCoveredTokens: { + label: 'Dölj täckta polletter', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + }, + }, + status: { + engine: 'Spelmotor', + grid: 'Rutnät', + layer: 'Hexskikt', + hexes: 'Hex', + named: 'Namngivna hexar', + icons: 'Platsskyltar', + glimpsed: 'Glimmade hexar', + pending: 'Platser som väntar på fyllning', + calibrated: 'Kalibrerad', + overrides: 'Sida åsidosätter', + undo: 'Ångra tillgängligt', + }, + messages: { + filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', + revealed: 'Hexen avslöjade: {count}.', + revealedPage: 'Varje hex på sidan avslöjas ({count}).', + confirmReset: + 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexen har tagits bort från sidan: {count}.', + undone: + 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + named: 'Hex med namnet "{name}": {count}.', + unnamed: 'Namn raderade: {count}.', + marked: + 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + unmarked: 'Tokens som inte längre är platser: {count}.', + settingChanged: '{setting} inställd på {value}.', + rescanned: + 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + calibrated: + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + calibrationReset: + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + journalRebuilt: '"{help}" och "{deck}" har byggts om.', + migrated: + 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + pruned: + 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + readyHint: + 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', + someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + }, + errors: { + noPage: 'Kunde inte hitta sidan att arbeta på.', + notHex: 'Den här sidan använder inte ett hex-rutnät.', + noPolygons: 'Välj en eller flera ritade former att fylla.', + emptyArea: 'Det valda området innehåller inga hexa-center.', + tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', + nothingToConceal: 'Välj ritade former eller tokens att dölja.', + nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + noTokens: 'Välj först en eller flera tokens.', + noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + nothingToUndo: 'Det finns ingen fyllning att ångra.', + unknownCommand: 'Okänt kommando: {command}', + unknownSetting: 'Okänd inställning: {key}', + unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', + invalidValue: '"{value}" är inte ett giltigt värde för {key}.', + calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', + unexpected: 'Något gick fel: {message}', + }, + hints: { + noPage: 'Öppna sidan du vill arbeta på eller välj något på den.', + notHex: 'Ställ in sidrutnätet på Hex (V) eller Hex (H) i Sidinställningar.', + noPolygons: + 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', + emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', + tooMany: 'Fyll ett mindre område, eller dela området i flera former.', + noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + unknownCommand: 'Skriv !hexploration help för att lista kommandona.', + unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', + calibrateNeedsTokens: + 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', + calibrateFailed: + 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + unexpected: 'Detaljer finns i API-konsolloggen.', + }, + help: { + menu: 'Visa menyn.', + fill: 'Täck de utvalda ritade formerna med hex.', + fillInverse: 'Täck hela sidan utom inuti de valda formerna.', + undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', + reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', + revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', + resetPage: 'Ta bort varje hex på sidan (frågar först).', + name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + mark: 'Förvandla de valda tokens till dolda platser.', + unmark: 'Stoppa de valda tokens från att vara dolda platser.', + set: 'Ändra en inställning eller visa alla inställningar.', + pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', + pageClear: 'Ta bort den aktuella sidans åsidosättningar.', + rescan: + 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', + calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrateReset: 'Ta bort den aktuella sidans kalibrering.', + status: 'Visa vad Hexploration vet om den aktuella sidan.', + journal: 'Bygg om hjälp- och kommandodäcken.', + help: 'Visa den här listan.', + handout: 'Fullständiga instruktioner finns i "{name}" handout.', + }, + deck: { + subtitle: 'Kommandodäck', + drawDesc: + 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + revealDesc: + 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + locationsDesc: + 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + toolsDesc: + 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', + footer: 'Se "{help}"-handouten för fullständiga instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-utforskning för Roll20', + footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', + overview: { + heading: 'Översikt', + body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + demo: 'Se en kort demo (från version 1)', + }, + quickStart: { + heading: 'Snabbstart', + steps: [ + 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', + 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', + 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + ], + }, + commands: { + heading: 'Kommandon', + intro: + 'Endast GM:er kan använda dessa kommandon. De flesta agerar på de valda objekten; resten agerar på sidan du tittar på.', + colCommand: 'Kommando', + colDesc: 'Vad den gör', + }, + revealing: { + heading: 'Hur avslöjande fungerar', + points: [ + 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', + 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', + 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', + 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + ], + }, + locations: { + heading: 'Namngivna Hex och platser', + points: [ + 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', + 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', + 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', + 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + ], + }, + settings: { + heading: 'Inställningar', + intro: + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + colKey: 'Nyckel', + colName: 'Miljö', + colDesc: 'Beskrivning', + perPage: '(Kan ställas in per sida.)', + }, + jumpgate: { + heading: 'Jumpgate och Legacy', + points: [ + 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', + 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', + 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + ], + }, + upgrading: { + heading: 'Uppgraderar från version 1', + points: [ + 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', + 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', + 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + ], + colV1: 'Kommandot version 1', + colV2: 'Kommandot version 2', + }, + troubleshooting: { + heading: 'Felsökning', + points: [ + 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', + 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', + ], + }, + languages: { + heading: 'Språk', + body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + }, + credits: { + heading: 'Krediter', + original: 'Originalmod av', + maintainer: 'Version 2 underhålls av', + marketplace: 'Adas konstpaket på Roll20 Marketplace', + support: + 'Om du hittar en bugg eller har en idé, posta i Roll20 Mod-forumet eller öppna ett problem på GitHub och inkludera eventuella meddelanden från API-konsolloggen.', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Keşif hazır.', + settings: 'Keşif Ayarları', + languages: 'Bir Dil Seçin', + pageSettings: 'Sayfa Ayarları: {page}', + status: 'Keşif Durumu: {page}', + help: 'Keşif Komutları', + confirm: 'Lütfen Onaylayın', + }, + discovery: { + title: 'Konum Keşfedildi', + }, + menu: { + draw: 'Çizmek', + reveal: 'Göster ve Gizle', + locations: 'Konumlar', + tools: 'Aletler', + layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + pageSettingsHelp: + 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', + }, + buttons: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + undo: 'Doldurmayı Geri Al', + reveal: 'Ortaya çıkarmak', + conceal: 'Gizle', + explore: 'Keşfetmek', + revealPage: 'Sayfayı Göster', + resetPage: 'Sayfayı Sıfırla', + mark: 'Konumu İşaretle', + unmark: 'İşareti kaldır', + name: 'Ad Hex', + settings: 'Ayarlar', + pageSettings: 'Sayfa Ayarları', + status: 'Durum', + rescan: 'Yeniden tara', + calibrate: 'Kalibre et', + calibrateReset: 'Kalibrasyonu Sıfırla', + help: 'Yardım', + change: 'Değiştirmek', + menu: 'Menü', + clearOverrides: 'Geçersiz Kılmaları Temizle', + confirmReset: 'Evet, Tüm Altıgenleri Kaldır', + }, + prompts: { + name: 'Konum adı (temizlemek için boş bırakın)', + }, + values: { + on: 'Açık', + off: 'Kapalı', + none: 'Hiçbiri', + hexLayer: { + auto: 'Otomatik (varsa ön planda)', + foreground: 'ön plan katmanı', + objects: 'belirteç katmanı', + }, + revealBy: { + players: 'Oyuncu jetonları', + characters: 'Karakter belirteçleri', + all: 'Tüm jetonlar', + }, + revealMode: { + clear: 'Temizlemek', + glimpse: 'Kısa bakış', + }, + announce: { + all: 'Herkes', + gm: 'Yalnızca GM', + off: 'Kapalı', + }, + orientation: { + vertical: 'Altıgen (V)', + horizontal: 'Altıgen (H)', + }, + fillKind: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + conceal: 'Gizle', + }, + }, + settings: { + language: { + label: 'Dil', + desc: 'Menüler, mesajlar ve bildiriler için dil.', + }, + hexLayer: { + label: 'Altıgen Katman', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + }, + fillColor: { + label: 'Dolgu Rengi', + desc: 'Yeni altıgenlerin rengi. Şeffaf altıgenler için rgba() kullanın; örneğin rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kenarlık Rengi', + desc: 'Yeni altıgenlerin ana hatlarının rengi.', + }, + labelColor: { + label: 'Etiket Rengi', + desc: 'Adlandırılmış altıgenlerdeki yalnızca GM ad etiketlerinin rengi.', + }, + glimpseColor: { + label: 'Bakış Rengi', + desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + }, + strokeWidth: { + label: 'Kenar Genişliği', + desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', + }, + maxDistance: { + label: 'Hex Ortaya Çıkma Mesafesi', + desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', + }, + revealDistance: { + label: 'Görüş Mesafesi', + desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + }, + lineOfSight: { + label: 'Görüş Hattı', + desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', + }, + revealPath: { + label: 'Yol Boyunca Ortaya Çıkar', + desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + }, + revealBy: { + label: 'Ortaya Çıkan Tokenlar', + desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', + }, + revealMode: { + label: 'Ortaya Çıkarma Modu', + desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + }, + announce: { + label: 'Keşifleri Duyurun', + desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', + }, + pingDiscoveries: { + label: 'Ping Keşifleri', + desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + }, + hideCoveredTokens: { + label: 'Kapalı Jetonları Gizle', + desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + }, + }, + status: { + engine: 'Oyun motoru', + grid: 'Izgara', + layer: 'Altıgen katman', + hexes: 'Altıgenler', + named: 'Adlandırılmış altıgenler', + icons: 'Konum belirteçleri', + glimpsed: 'Kısa bir bakış altıgenler', + pending: 'Doldurulmayı bekleyen yerler', + calibrated: 'Kalibre edildi', + overrides: 'Sayfa geçersiz kılmaları', + undo: 'Geri alma seçeneği mevcut', + }, + messages: { + filled: + 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', + revealed: 'Büyüler ortaya çıktı: {count}.', + revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', + confirmReset: + '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + undone: + 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', + named: '"{name}" adlı altıgenler: {count}.', + unnamed: 'İsimler temizlendi: {count}.', + marked: + 'Mevcut altıgenlerde gizli konumlar: {attached}. Bunları kapsayan bir sonraki dolgu bekleniyor: {pending}.', + unmarked: 'Artık konum olmayan jetonlar: {count}.', + settingChanged: '{setting}, {value} olarak ayarlandı.', + rescanned: + 'Yeniden tarama tamamlandı. Tutulan: {kept}. Kabul edildi: {adopted}. Yeniden dosyalandı: {moved}. Eksik ve unutulmuş: {dropped}. Etiketler yeniden bağlandı: {labels}. Konum jetonları yeniden bağlandı: {icons}.', + calibrated: + 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + calibrationReset: + 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + migrated: + 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + pruned: + "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", + readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + }, + warnings: { + foregroundUnavailable: + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', + }, + errors: { + noPage: 'Üzerinde çalışılacak sayfa bulunamadı.', + notHex: 'Bu sayfada altıgen ızgara kullanılmamaktadır.', + noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', + emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', + tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', + noTokens: 'Önce bir veya daha fazla jeton seçin.', + noHexes: + 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', + nothingToUndo: 'Geri alınacak bir dolgu yok.', + unknownCommand: 'Bilinmeyen komut: {command}', + unknownSetting: 'Bilinmeyen ayar: {key}', + unknownPageSetting: 'Sayfa başına ayarlanabilen ayarlar: {keys}', + invalidValue: '"{value}", {key} için geçerli bir değer değil.', + calibrateNeedsTokens: 'Altıgen merkezlere tutturulmuş bir veya iki jeton seçin.', + calibrateFailed: 'Bu jetonlar kalibrasyon için kullanılamaz.', + unexpected: 'Bir şeyler ters gitti: {message}', + }, + hints: { + noPage: 'Üzerinde çalışmak istediğiniz sayfayı açın veya üzerinde bir şey seçin.', + notHex: "Sayfa Ayarları'nda sayfa ızgarasını Hex (V) veya Hex (H) olarak ayarlayın.", + noPolygons: + 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', + emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', + tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', + noHexes: + 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + unknownCommand: 'Komutları listelemek için !hexploration help yazın.', + unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', + calibrateNeedsTokens: + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + calibrateFailed: + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + unexpected: 'Ayrıntılar API konsolu günlüğündedir.', + }, + help: { + menu: 'Menüyü göster.', + fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', + fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', + undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + reveal: + 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', + conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', + explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', + resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', + name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + mark: 'Seçilen jetonları gizli konumlara dönüştürün.', + unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', + pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', + rescan: + 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + calibrate: + 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', + calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', + status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + help: 'Bu listeyi göster.', + handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', + }, + deck: { + subtitle: 'Komut Güvertesi', + drawDesc: + 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + revealDesc: + 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + locationsDesc: + 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + toolsDesc: + 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', + footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', + }, + handout: { + versionLabel: 'Sürüm', + subtitle: 'Roll20 için hex-hex keşif', + footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', + overview: { + heading: 'Genel Bakış', + body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + demo: "Kısa bir demo izleyin (versiyon 1'den)", + }, + quickStart: { + heading: 'Hızlı Başlangıç', + steps: [ + 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', + 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', + "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", + 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', + ], + }, + commands: { + heading: 'Komutlar', + intro: + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", + colCommand: 'Emretmek', + colDesc: 'Ne işe yarar', + }, + revealing: { + heading: 'Açığa Çıkarma Nasıl Çalışır?', + points: [ + 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', + 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', + 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + ], + }, + locations: { + heading: 'Adlandırılmış Altıgenler ve Konumlar', + points: [ + 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', + "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", + 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", + "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + ], + }, + settings: { + heading: 'Ayarlar', + intro: + '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + colKey: 'Anahtar', + colName: 'Ayar', + colDesc: 'Tanım', + perPage: '(Sayfa başına ayarlanabilir.)', + }, + jumpgate: { + heading: 'Jumpgate ve Eski', + points: [ + 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', + 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', + "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + ], + }, + upgrading: { + heading: "Sürüm 1'den yükseltme", + points: [ + "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", + 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', + 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + ], + colV1: 'Sürüm 1 komutu', + colV2: 'Sürüm 2 komutu', + }, + troubleshooting: { + heading: 'Sorun giderme', + points: [ + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', + "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", + 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', + ], + }, + languages: { + heading: 'Diller', + body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + }, + credits: { + heading: 'Kredi', + original: 'Orijinal mod', + maintainer: 'Versiyon 2 tarafından sürdürülen', + marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", + support: + "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration готовий.', + settings: 'Налаштування Hexploration', + languages: 'Виберіть мову', + pageSettings: 'Параметри сторінки: {page}', + status: 'Статус дослідження: {page}', + help: 'Команди Hexploration', + confirm: 'Будь ласка, підтвердьте', + }, + discovery: { + title: 'Розташування виявлено', + }, + menu: { + draw: 'малювати', + reveal: 'Відкрити і приховати', + locations: 'Розташування', + tools: 'Інструменти', + layerInUse: 'Нові гекси малюються на {layer}.', + pageSettingsHelp: + 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', + }, + buttons: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + undo: 'Скасувати заповнення', + reveal: 'Розкрити', + conceal: 'Приховати', + explore: 'Досліджуйте', + revealPage: 'Відкрити сторінку', + resetPage: 'Скинути сторінку', + mark: 'Позначте розташування', + unmark: 'Зняти позначку', + name: "Ім'я Hex", + settings: 'Налаштування', + pageSettings: 'Параметри сторінки', + status: 'Статус', + rescan: 'Повторне сканування', + calibrate: 'Відкалібрувати', + calibrateReset: 'Скинути калібрування', + help: 'Довідка', + change: 'Зміна', + menu: 'Меню', + clearOverrides: 'Очистити перевизначення', + confirmReset: 'Так, видалити всі гекси', + }, + prompts: { + name: 'Назва місця (залиште порожнім, щоб очистити)', + }, + values: { + on: 'Увімкнено', + off: 'Вимкнено', + none: 'Жодного', + hexLayer: { + auto: 'Автоматично (на передньому плані, якщо доступно)', + foreground: 'шар переднього плану', + objects: 'маркерний шар', + }, + revealBy: { + players: 'Жетони гравців', + characters: 'Символьні маркери', + all: 'Усі жетони', + }, + revealMode: { + clear: 'ясно', + glimpse: 'Поблиск', + }, + announce: { + all: 'Всі', + gm: 'Тільки GM', + off: 'Вимкнено', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + conceal: 'Приховати', + }, + }, + settings: { + language: { + label: 'Мова', + desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', + }, + hexLayer: { + label: 'Шістнадцятковий шар', + desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + }, + fillColor: { + label: 'Колір заливки', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Колір рамки', + desc: 'Колір контуру нових гексів.', + }, + labelColor: { + label: 'Колір етикетки', + desc: 'Колір написів імен лише для GM на іменованих гексах.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + }, + strokeWidth: { + label: 'Ширина кордону', + desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', + }, + maxDistance: { + label: 'Шестигранна відстань розкриття', + desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', + }, + revealDistance: { + label: 'Дистанція огляду', + desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', + }, + lineOfSight: { + label: 'Пряма видимість', + desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', + }, + revealPath: { + label: 'Показати уздовж шляху', + desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', + }, + revealBy: { + label: 'Жетони, які розкривають', + desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', + }, + revealMode: { + label: 'Режим виявлення', + desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + }, + announce: { + label: 'Оголосити відкриття', + desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + }, + pingDiscoveries: { + label: 'Ping відкриття', + desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + }, + hideCoveredTokens: { + label: 'Приховати закриті токени', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + }, + }, + status: { + engine: 'Ігровий двигун', + grid: 'Сітка', + layer: 'Шестигранний шар', + hexes: 'Гекси', + named: 'Іменовані гекси', + icons: 'Жетони розташування', + glimpsed: 'Помітені прокляття', + pending: 'Локації очікують на заповнення', + calibrated: 'Відкалібрований', + overrides: 'Перевизначення сторінок', + undo: 'Доступне скасування', + }, + messages: { + filled: + 'Заповнення завершено. Намальовані гекси: {created}. Рестайлінг: {restyled}. Приховані місця: {icons}.', + revealed: 'Розкрито гекси: {count}.', + revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', + confirmReset: + 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + resetPage: 'Зі сторінки видалено шестигранники: {count}.', + undone: + 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', + named: 'Гекси з назвою "{name}": {count}.', + unnamed: 'Імена видалено: {count}.', + marked: + 'Місця, приховані в існуючих гексах: {attached}. Очікування наступного заповнення, яке охопить їх: {pending}.', + unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', + settingChanged: '{setting} встановлено на {value}.', + rescanned: + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + calibrated: + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + calibrationReset: + 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', + migrated: + 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + pruned: + 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + readyHint: + 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + }, + warnings: { + foregroundUnavailable: + 'Ця гра не підтримує малювання на передньому шарі, тому гекси були намальовані на шарі жетонів.', + someFailed: + 'Гекси, які не вдалося намалювати: {count}. Перевірте консоль API для отримання деталей.', + }, + errors: { + noPage: 'Не вдалося знайти сторінку для роботи.', + notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', + emptyArea: 'Вибрана область не містить шестигранних центрів.', + tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', + nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', + nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + noTokens: 'Спочатку виберіть один або кілька токенів.', + noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', + nothingToUndo: 'Немає заповнення, яке можна скасувати.', + unknownCommand: 'Невідома команда: {command}', + unknownSetting: 'Невідоме налаштування: {key}', + unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', + invalidValue: '"{value}" не є дійсним значенням для {key}.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', + unexpected: 'Щось пішло не так: {message}', + }, + hints: { + noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', + notHex: + 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + noPolygons: + 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', + emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', + tooMany: 'Заповніть меншу область або розділіть її на кілька фігур.', + noHexes: + 'Гекси знаходяться на передньому плані або шарі жетонів; перейдіть на цей шар, щоб вибрати їх.', + unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', + unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', + calibrateNeedsTokens: + 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + calibrateFailed: + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + unexpected: 'Подробиці в журналі консолі API.', + }, + help: { + menu: 'Показати меню.', + fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', + undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', + reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', + revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', + resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', + name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', + mark: 'Перетворіть вибрані жетони на приховані місця.', + unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + set: 'Змінити налаштування або показати всі налаштування.', + pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageClear: 'Видаліть перевизначення поточної сторінки.', + rescan: + 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + calibrate: + 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + calibrateReset: 'Видалити калібрування поточної сторінки.', + status: 'Покажіть, що Hexploration знає про поточну сторінку.', + journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + help: 'Покажіть цей список.', + handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', + }, + deck: { + subtitle: 'Командна колода', + drawDesc: + 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + revealDesc: + 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + locationsDesc: + 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', + toolsDesc: + 'Налаштування, перевизначення сторінок, статус, повторне сканування скопійованих сторінок і калібрування сітки.', + footer: 'Перегляньте роздатковий матеріал "{help}", щоб отримати повні інструкції.', + }, + handout: { + versionLabel: 'Версія', + subtitle: 'Шістнадцяткове дослідження для Roll20', + footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', + overview: { + heading: 'Огляд', + body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + demo: 'Перегляньте коротку демонстрацію (з версії 1)', + }, + quickStart: { + heading: 'Швидкий старт', + steps: [ + 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', + 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', + 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', + 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', + 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + ], + }, + commands: { + heading: 'Команди', + intro: + "Тільки GM можуть використовувати ці команди. Більшість діють на обрані об'єкти; решта діють на сторінці, яку ви переглядаєте.", + colCommand: 'Команда', + colDesc: 'Що воно робить', + }, + revealing: { + heading: 'Як працює розкриття', + points: [ + 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', + 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', + 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', + 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', + 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + ], + }, + locations: { + heading: 'Іменовані гекси та локації', + points: [ + 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', + 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', + 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', + 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + ], + }, + settings: { + heading: 'Налаштування', + intro: + 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + colKey: 'ключ', + colName: 'Налаштування', + colDesc: 'опис', + perPage: '(Можна встановити на сторінку.)', + }, + jumpgate: { + heading: 'Jumpgate і Legacy', + points: [ + 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', + 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', + 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + ], + }, + upgrading: { + heading: 'Оновлення з версії 1', + points: [ + 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', + 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', + 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + ], + colV1: 'Команда версії 1', + colV2: 'Команда версії 2', + }, + troubleshooting: { + heading: 'Усунення несправностей', + points: [ + 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', + 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', + 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', + 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', + ], + }, + languages: { + heading: 'Мови', + body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + }, + credits: { + heading: 'Кредити', + original: 'Оригінальний мод від', + maintainer: 'Версія 2 підтримується', + marketplace: 'Художні набори Ади на Roll20 Marketplace', + support: + 'Якщо ви знайшли помилку або маєте ідею, опублікуйте на форумі Roll20 Mod або відкрийте проблему на GitHub і додайте будь-які повідомлення з журналу консолі API.', + }, + }, + }; const DEFAULT_LOCALE = 'en-US'; @@ -3573,30 +10286,30 @@ const HexplorationMod = (() => { SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); const TRANSLATIONS = { - af: TRANSLATION$4, - ca: TRANSLATION$3, - 'zh-TW': TRANSLATION$2, - cs: TRANSLATION$1, - da: TRANSLATION, - nl: localeNl, + af: TRANSLATION$m, + ca: TRANSLATION$l, + 'zh-TW': TRANSLATION$k, + cs: TRANSLATION$j, + da: TRANSLATION$i, + nl: TRANSLATION$h, 'en-US': localeEnUS, - fi: localeFi, - fr: localeFr, - de: localeDe, - el: localeEl, - he: localeHe, - hu: localeHu, - it: localeIt, - ja: localeJa, - ko: localeKo, - pl: localePl, - 'pt-PT': localePtPT, - 'pt-BR': localePtBR, - ru: localeRu, - es: localeEs, - sv: localeSv, - tr: localeTr, - uk: localeUk, + fi: TRANSLATION$g, + fr: TRANSLATION$f, + de: TRANSLATION$e, + el: TRANSLATION$d, + he: TRANSLATION$c, + hu: TRANSLATION$b, + it: TRANSLATION$a, + ja: TRANSLATION$9, + ko: TRANSLATION$8, + pl: TRANSLATION$7, + 'pt-PT': TRANSLATION$6, + 'pt-BR': TRANSLATION$5, + ru: TRANSLATION$4, + es: TRANSLATION$3, + sv: TRANSLATION$2, + tr: TRANSLATION$1, + uk: TRANSLATION, }; /** diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index 87a8b34aff..684e4bf2a0 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T02:20:55.900Z + * Built: 2026-10-29T08:23:06.249Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T02:20:55.900Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T08:23:06.249Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1102,7 +1102,7 @@ const HexplorationMod = (() => { return calibration; } - const TRANSLATION$4 = { + const TRANSLATION$m = { titles: { ready: 'Heeksplorasie is gereed.', settings: 'Heksplorasie-instellings', @@ -1245,6 +1245,10 @@ const HexplorationMod = (() => { label: 'Ping Ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, + hideCoveredTokens: { + label: 'Versteek bedekte tekens', + desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + }, }, status: { engine: 'Spel enjin', @@ -1261,31 +1265,31 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.', - revealed: '{count} hekkies geopenbaar.', - revealedPage: 'Alle {count} hekse op die bladsy is geopenbaar.', + 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Hekse geopenbaar: {count}.', + revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', confirmReset: - 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: '{count} hekse van die bladsy verwyder.', + 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Hekse verwyder van die bladsy: {count}.', undone: - 'Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.', - named: '{count} heksies genaamd "{name}".', - unnamed: 'Naam verwyder van {count} hekse.', + 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', + named: 'Hekse genaamd "{name}": {count}.', + unnamed: 'Name skoongemaak: {count}.', marked: - '{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.', - unmarked: '{count} tekens is nie meer liggings nie.', + 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', + unmarked: 'Tekens wat nie meer liggings is nie: {count}.', settingChanged: '{setting} gestel na {value}.', rescanned: - "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', calibrated: - 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', calibrationReset: - 'Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.', + 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", pruned: - '{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', readyHint: 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, @@ -1293,14 +1297,14 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', someFailed: - '{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.', + 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', }, errors: { noPage: 'Kon nie die bladsy vind om aan te werk nie.', notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", noPolygons: 'Kies een of meer getekende vorms om te vul.', emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', - tooMany: 'Dit sal {count} hexes skep, wat te veel in een slag is.', + tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', noTokens: 'Kies eers een of meer tekens.', @@ -1405,6 +1409,7 @@ const HexplorationMod = (() => { "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { @@ -1471,7 +1476,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$3 = { + const TRANSLATION$l = { titles: { ready: "L'exploració està a punt.", settings: "Configuració d'exploració", @@ -1614,6 +1619,10 @@ const HexplorationMod = (() => { label: 'Ping Descobriments', desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', }, + hideCoveredTokens: { + label: 'Amaga les fitxes cobertes', + desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + }, }, status: { engine: 'Motor de joc', @@ -1630,31 +1639,31 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.', - revealed: '{count} hexadecimals revelats.', - revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + revealed: 'Hexagones revelats: {count}.', + revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", confirmReset: - 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: '{count} hexadecimals eliminats de la pàgina.', + 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', undone: - 'Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.', - named: '{count} hexadecimals anomenats "{name}".', - unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + named: 'Hexadecimals anomenats "{name}": {count}.', + unnamed: 'Noms esborrats: {count}.', marked: - "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", - unmarked: 'Les fitxes {count} ja no són ubicacions.', + 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", calibrated: - 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.', + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", pruned: - "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", readyHint: 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', }, @@ -1662,14 +1671,14 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', someFailed: - "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", + tooMany: "Això crearia massa hexagones d'una vegada ({count}).", nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', noTokens: 'Seleccioneu primer un o més fitxes.', @@ -1776,6 +1785,7 @@ const HexplorationMod = (() => { "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { @@ -1842,7 +1852,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$2 = { + const TRANSLATION$k = { titles: { ready: 'H探索已準備就緒。', settings: 'H探索設置', @@ -1901,7 +1911,7 @@ const HexplorationMod = (() => { }, revealBy: { players: '玩家代幣', - characters: 'Character tokens', + characters: '字元標記', all: '所有代幣', }, revealMode: { @@ -1984,6 +1994,10 @@ const HexplorationMod = (() => { label: '平發現', desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', }, + hideCoveredTokens: { + label: '隱藏覆蓋的令牌', + desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + }, }, status: { engine: '遊戲引擎', @@ -1999,40 +2013,40 @@ const HexplorationMod = (() => { undo: '可以撤銷', }, messages: { - filled: '填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。', - revealed: '{count} 十六進位顯示。', - revealedPage: '顯示頁面上的所有 {count} 十六進位。', + filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', + revealed: '六角形顯示：{count}。', + revealedPage: '顯示頁面上的每個十六進位 ({count})。', confirmReset: - '從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。', - resetPage: '從頁面中刪除了 {count} 十六進位。', - undone: '上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。', - named: '{count} 名為「{name}」的十六進位。', - unnamed: '從 {count} 十六進位清除名稱。', - marked: '{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。', - unmarked: '{count} 標記不再是位置。', + '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', + resetPage: '從頁面中刪除的十六進位：{count}。', + undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', + named: '名為「{name}」的六角形：{count}。', + unnamed: '已清除的名稱：{count}。', + marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', + unmarked: '不再是位置的標記：{count}。', settingChanged: '{setting} 設定為 {value}。', rescanned: - '重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_', + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', calibrated: - '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', - calibrationReset: '校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。', - journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', pruned: - '{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', + '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', }, warnings: { foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', - someFailed: '無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。', + someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', }, errors: { noPage: '找不到要處理的頁面。', notHex: '此頁面不使用六角網格。', noPolygons: '選擇一個或多個要填滿的繪製形狀。', emptyArea: '所選區域不包含任何六角形中心。', - tooMany: '這會建立 {count} 六角形，一次性就太多了。', + tooMany: '這會一次建立太多的六角形 ({count})。', nothingToConceal: '選擇要隱藏的繪製形狀或標記。', nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', noTokens: '首先選擇一個或多個令牌。', @@ -2064,7 +2078,7 @@ const HexplorationMod = (() => { menu: '顯示選單。', fill: '用六角形覆蓋選定的繪製形狀。', fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', - undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', revealPage: '顯示頁面上的每個十六進制，無需公告。', conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', @@ -2128,6 +2142,7 @@ const HexplorationMod = (() => { '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', ], }, locations: { @@ -2175,8 +2190,8 @@ const HexplorationMod = (() => { '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', - 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', - 'For anything else, check the API console log and include its messages when asking for help.', + 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { @@ -2194,7 +2209,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION$1 = { + const TRANSLATION$j = { titles: { ready: 'Heexploration je připraven.', settings: 'Nastavení Heexploration', @@ -2337,6 +2352,10 @@ const HexplorationMod = (() => { label: 'Ping Discovery', desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', }, + hideCoveredTokens: { + label: 'Skryjte kryté žetony', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + }, }, status: { engine: 'Herní engine', @@ -2353,45 +2372,46 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.', - revealed: '{count} odhalených hexů.', - revealedPage: 'Všechny {count} hexy na stránce odhaleny.', + 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + revealed: 'Odhalené hexy: {count}.', + revealedPage: 'Každé odhalené hex na stránce ({count}).', confirmReset: - 'Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', - resetPage: '{count} hexy odstraněny ze stránky.', + 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - 'Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.', - named: '{count} hexy s názvem „{name}“.', - unnamed: 'Název byl vymazán z {count} hexů.', + 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + named: 'Hexusy s názvem „{name}“: {count}.', + unnamed: 'Jména vymazána: {count}.', marked: - '{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.', - unmarked: '{count} tokeny již nejsou umístění.', + 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', + unmarked: 'Tokeny, které již nejsou umístěními: {count}.', settingChanged: '{setting} nastaveno na {value}.', rescanned: - 'Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.', + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', calibrationReset: - 'Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.', + 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', pruned: - '{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', readyHint: 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', }, warnings: { foregroundUnavailable: 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', - someFailed: '{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.', + someFailed: + 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', - tooMany: 'To by vytvořilo {count} hexů, což je příliš mnoho najednou.', + tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', noTokens: 'Nejprve vyberte jeden nebo více žetonů.', @@ -2493,6 +2513,7 @@ const HexplorationMod = (() => { 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', ], }, locations: { @@ -2559,7 +2580,7 @@ const HexplorationMod = (() => { }, }; - const TRANSLATION = { + const TRANSLATION$i = { titles: { ready: 'Hexploration er klar.', settings: 'Indstillinger for Hexploration', @@ -2671,7 +2692,7 @@ const HexplorationMod = (() => { desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: 'Hex Reveal Distance', + label: 'Hex afsløre afstand', desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { @@ -2691,7 +2712,7 @@ const HexplorationMod = (() => { desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { - label: 'Reveal Mode', + label: 'Afsløringstilstand', desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', }, announce: { @@ -2702,6 +2723,10 @@ const HexplorationMod = (() => { label: 'Ping opdagelser', desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', }, + hideCoveredTokens: { + label: 'Skjul dækkede tokens', + desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + }, }, status: { engine: 'Spil motor', @@ -2718,45 +2743,45 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.', - revealed: '{count} hexes afsløret.', - revealedPage: 'Alle {count} hexes på siden afsløret.', + 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexer afsløret: {count}.', + revealedPage: 'Hver hex på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: '{count} sekskanter fjernet fra siden.', + 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexer fjernet fra siden: {count}.', undone: - 'Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.', - named: '{count} hexes med navnet "{name}".', - unnamed: 'Navnet er ryddet fra {count} hexes.', + 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', + named: 'Hexer med navnet "{name}": {count}.', + unnamed: 'Navne ryddet: {count}.', marked: - '{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.', - unmarked: '{count} tokens er ikke længere placeringer.', + 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + unmarked: 'Tokens, der ikke længere er placeringer: {count}.', settingChanged: '{setting} indstillet til {value}.', rescanned: - 'Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.', + 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.', + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', calibrationReset: - 'Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', pruned: - '{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', readyHint: 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', }, warnings: { foregroundUnavailable: 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', - someFailed: '{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.', + someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { noPage: 'Kunne ikke finde siden at arbejde på.', notHex: 'Denne side bruger ikke et hex-gitter.', noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', emptyArea: 'Det valgte område indeholder ingen hex-centre.', - tooMany: 'Det ville skabe {count} hexes, hvilket er for mange på én gang.', + tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', noTokens: 'Vælg først et eller flere tokens.', @@ -2859,6 +2884,7 @@ const HexplorationMod = (() => { 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", ], }, locations: { @@ -2915,7 +2941,7 @@ const HexplorationMod = (() => { body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', }, credits: { - heading: 'Credits', + heading: 'Kreditter', original: 'Original mod af', maintainer: 'Version 2 vedligeholdes af', marketplace: 'Adas kunstpakker på Roll20 Marketplace', @@ -2925,7 +2951,380 @@ const HexplorationMod = (() => { }, }; - var localeNl = {}; + const TRANSLATION$h = { + titles: { + ready: 'Hexploratie is klaar.', + settings: 'Hexploratie-instellingen', + languages: 'Kies een taal', + pageSettings: 'Pagina-instellingen: {page}', + status: 'Hverkenningsstatus: {page}', + help: 'Hexploratie-opdrachten', + confirm: 'Bevestig alstublieft', + }, + discovery: { + title: 'Locatie ontdekt', + }, + menu: { + draw: 'Tekenen', + reveal: 'Onthullen en verbergen', + locations: 'Locaties', + tools: 'Hulpmiddelen', + layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + pageSettingsHelp: + 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', + }, + buttons: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + undo: 'Vulling ongedaan maken', + reveal: 'Onthullen', + conceal: 'Maskeren', + explore: 'Ontdekken', + revealPage: 'Pagina onthullen', + resetPage: 'Pagina opnieuw instellen', + mark: 'Markeer locatie', + unmark: 'Markering opheffen', + name: 'Naam Hex', + settings: 'Instellingen', + pageSettings: 'Pagina-instellingen', + status: 'Status', + rescan: 'Opnieuw scannen', + calibrate: 'Kalibreren', + calibrateReset: 'Kalibratie opnieuw instellen', + help: 'Hulp', + change: 'Wijziging', + menu: 'Menu', + clearOverrides: 'Wis overschrijvingen', + confirmReset: 'Ja, verwijder alle vakjes', + }, + prompts: { + name: 'Locatienaam (leeg laten om te wissen)', + }, + values: { + on: 'Op', + off: 'Uit', + none: 'Geen', + hexLayer: { + auto: 'Automatisch (voorgrond indien beschikbaar)', + foreground: 'voorgrond laag', + objects: 'token laag', + }, + revealBy: { + players: 'Spelerfiches', + characters: 'Karakterfiches', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Duidelijk', + glimpse: 'Glimp', + }, + announce: { + all: 'Iedereen', + gm: 'Alleen GM', + off: 'Uit', + }, + orientation: { + vertical: 'Zeskant (V)', + horizontal: 'Zeskant (H)', + }, + fillKind: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + conceal: 'Maskeren', + }, + }, + settings: { + language: { + label: 'Taal', + desc: "Taal voor menu's, berichten en hand-outs.", + }, + hexLayer: { + label: 'Hex-laag', + desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van de omtrek van nieuwe vakjes.', + }, + labelColor: { + label: 'Etiketkleur', + desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + }, + glimpseColor: { + label: 'Glimp kleur', + desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + }, + strokeWidth: { + label: 'Randbreedte', + desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Hex onthullen afstand', + desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', + }, + revealDistance: { + label: 'Zicht afstand', + desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + }, + lineOfSight: { + label: 'Zichtlijn', + desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', + }, + revealPath: { + label: 'Onthul langs het pad', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + }, + revealBy: { + label: 'Tokens die onthullen', + desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + }, + revealMode: { + label: 'Onthullingsmodus', + desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + }, + announce: { + label: 'Ontdekkingen aankondigen', + desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + }, + pingDiscoveries: { + label: 'Ping-ontdekkingen', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + }, + hideCoveredTokens: { + label: 'Verberg afgedekte tokens', + desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + }, + }, + status: { + engine: 'Game-engine', + grid: 'Rooster', + layer: 'Hex-laag', + hexes: 'Hexen', + named: 'Genoemde hexen', + icons: 'Locatiefiches', + glimpsed: 'Glimp van hexen', + pending: 'Locaties die wachten op vulling', + calibrated: 'Gekalibreerd', + overrides: 'Pagina-overschrijvingen', + undo: 'Ongedaan maken beschikbaar', + }, + messages: { + filled: + 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Hexen onthuld: {count}.', + revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + confirmReset: + 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Hexes verwijderd van de pagina: {count}.', + undone: + 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', + named: 'Hexen met de naam "{name}": {count}.', + unnamed: 'Namen gewist: {count}.', + marked: + 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + unmarked: 'Tokens die niet langer locaties zijn: {count}.', + settingChanged: '{setting} ingesteld op {value}.', + rescanned: + 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + calibrated: + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + calibrationReset: + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', + migrated: + 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + pruned: + 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + readyHint: + 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + someFailed: + 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + }, + errors: { + noPage: 'Kon de pagina niet vinden om aan te werken.', + notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', + noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', + emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', + tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', + nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + noTokens: 'Selecteer eerst een of meer tokens.', + noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', + unknownCommand: 'Onbekend commando: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellingen die per pagina kunnen worden ingesteld: {keys}', + invalidValue: '"{value}" is geen geldige waarde voor {key}.', + calibrateNeedsTokens: + 'Selecteer een of twee tokens die op de middelpunten van de zeshoeken zijn vastgemaakt.', + calibrateFailed: 'Deze tokens kunnen niet worden gebruikt om te kalibreren.', + unexpected: 'Er is iets misgegaan: {message}', + }, + hints: { + noPage: 'Open de pagina waaraan u wilt werken of selecteer er iets op.', + notHex: 'Stel het paginaraster in op Hex (V) of Hex (H) in Pagina-instellingen.', + noPolygons: + 'Teken een veelhoek, rechthoek, ellips of vorm uit de vrije hand rond het gebied, selecteer het en probeer het opnieuw.', + emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', + tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', + noHexes: + 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', + unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', + calibrateNeedsTokens: + 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + calibrateFailed: + 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', + unexpected: 'Details staan ​​in het API-consolelogboek.', + }, + help: { + menu: 'Laat de menukaart zien.', + fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', + undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + reveal: + 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', + revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', + explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', + resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', + name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + mark: 'Verander de geselecteerde tokens in verborgen locaties.', + unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', + set: 'Wijzig een instelling of toon alle instellingen.', + pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', + pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', + rescan: + 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + calibrate: + 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', + status: 'Laat zien wat Hexploration weet over de huidige pagina.', + journal: 'Herbouw de Help- en Command Deck-hand-outs.', + help: 'Laat deze lijst zien.', + handout: 'Volledige instructies vindt u in de hand-out "{name}".', + }, + deck: { + subtitle: 'Commandodek', + drawDesc: + 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + revealDesc: + 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + locationsDesc: + 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + toolsDesc: + "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", + footer: 'Zie de hand-out "{help}" voor volledige instructies.', + }, + handout: { + versionLabel: 'Versie', + subtitle: 'Hex-voor-hex verkenning voor Roll20', + footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', + overview: { + heading: 'Overzicht', + body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + demo: 'Bekijk een korte demo (vanaf versie 1)', + }, + quickStart: { + heading: 'Snel beginnen', + steps: [ + 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', + 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', + 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + ], + }, + commands: { + heading: "Commando's", + intro: + "Alleen GM's kunnen deze commando's gebruiken. De meeste werken op de geselecteerde objecten; de rest handelt op de pagina die u bekijkt.", + colCommand: 'Commando', + colDesc: 'Wat het doet', + }, + revealing: { + heading: 'Hoe onthullen werkt', + points: [ + 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", + 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', + 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', + 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + ], + }, + locations: { + heading: 'Genoemde velden en locaties', + points: [ + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', + 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', + 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + ], + }, + settings: { + heading: 'Instellingen', + intro: + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beschrijving', + perPage: '(Kan per pagina worden ingesteld.)', + }, + jumpgate: { + heading: 'Jumpgate en erfenis', + points: [ + 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', + 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', + "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + ], + }, + upgrading: { + heading: 'Upgraden vanaf versie 1', + points: [ + 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', + 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', + 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + ], + colV1: 'Versie 1-opdracht', + colV2: 'Versie 2-opdracht', + }, + troubleshooting: { + heading: 'Problemen oplossen', + points: [ + 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', + 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', + 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', + 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', + ], + }, + languages: { + heading: 'Talen', + body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + }, + credits: { + heading: 'Kredieten', + original: 'Originele mod door', + maintainer: 'Versie 2 onderhouden door', + marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", + support: + 'Als je een bug vindt of een idee hebt, plaats dan een bericht op het Roll20 Mod-forum of open een probleem op GitHub, en voeg eventuele berichten uit het API-consolelogboek toe.', + }, + }, + }; var localeEnUS = { titles: { @@ -3294,39 +3693,6353 @@ const HexplorationMod = (() => { }, }; - var localeFi = {}; - - var localeFr = {}; - - var localeDe = {}; - - var localeEl = {}; - - var localeHe = {}; - - var localeHu = {}; - - var localeIt = {}; - - var localeJa = {}; - - var localeKo = {}; - - var localePl = {}; - - var localePtPT = {}; - - var localePtBR = {}; - - var localeRu = {}; - - var localeEs = {}; - - var localeSv = {}; - - var localeTr = {}; - - var localeUk = {}; + const TRANSLATION$g = { + titles: { + ready: 'Hexploration on valmis.', + settings: 'Tutkimusasetukset', + languages: 'Valitse kieli', + pageSettings: 'Sivuasetukset: {page}', + status: 'Tutkimuksen tila: {page}', + help: 'Hexploration komennot', + confirm: 'Ole hyvä ja vahvista', + }, + discovery: { + title: 'Sijainti löydetty', + }, + menu: { + draw: 'Piirrä', + reveal: 'Paljasta ja piilota', + locations: 'Sijainnit', + tools: 'Työkalut', + layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + pageSettingsHelp: + 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', + }, + buttons: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + undo: 'Kumoa täyttö', + reveal: 'Paljastaa', + conceal: 'Salata', + explore: 'Tutkia', + revealPage: 'Paljasta sivu', + resetPage: 'Nollaa sivu', + mark: 'Merkitse sijainti', + unmark: 'Poista merkintä', + name: 'Nimi Hex', + settings: 'Asetukset', + pageSettings: 'Sivun asetukset', + status: 'Status', + rescan: 'Skannaa uudelleen', + calibrate: 'Kalibroida', + calibrateReset: 'Nollaa kalibrointi', + help: 'Auttaa', + change: 'Muuttaa', + menu: 'Valikko', + clearOverrides: 'Tyhjennä ohitukset', + confirmReset: 'Kyllä, poista kaikki heksit', + }, + prompts: { + name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', + }, + values: { + on: 'Päällä', + off: 'Pois', + none: 'Ei mitään', + hexLayer: { + auto: 'Automaattinen (etualalla, jos saatavilla)', + foreground: 'etualan kerros', + objects: 'merkkikerros', + }, + revealBy: { + players: 'Pelaajan merkit', + characters: 'Hahmomerkit', + all: 'Kaikki merkit', + }, + revealMode: { + clear: 'Selkeä', + glimpse: 'Vilkkaus', + }, + announce: { + all: 'Kaikki', + gm: 'Vain GM', + off: 'Pois', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + conceal: 'Salata', + }, + }, + settings: { + language: { + label: 'Kieli', + desc: 'Valikkojen, viestien ja monisteiden kieli.', + }, + hexLayer: { + label: 'Hex kerros', + desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + }, + fillColor: { + label: 'Täyttöväri', + desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Reunuksen väri', + desc: 'Uusien kuusioiden ääriviivan väri.', + }, + labelColor: { + label: 'Etiketin väri', + desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + }, + strokeWidth: { + label: 'Reunan leveys', + desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', + }, + maxDistance: { + label: 'Hex paljastaa etäisyyttä', + desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', + }, + revealDistance: { + label: 'Näköetäisyys', + desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', + }, + lineOfSight: { + label: 'Näkökenttä', + desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', + }, + revealPath: { + label: 'Paljasta polun varrella', + desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + }, + revealBy: { + label: 'Tokenit jotka paljastavat', + desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + }, + revealMode: { + label: 'Paljastustila', + desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + }, + announce: { + label: 'Ilmoita löydökset', + desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', + }, + pingDiscoveries: { + label: 'Ping löydöt', + desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', + }, + hideCoveredTokens: { + label: 'Piilota peitetyt rahakkeet', + desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + }, + }, + status: { + engine: 'Pelin moottori', + grid: 'Ruudukko', + layer: 'Hex kerros', + hexes: 'Hexes', + named: 'Nimetyt heksat', + icons: 'Sijaintitunnukset', + glimpsed: 'Näytetyt kuusiot', + pending: 'Täyttöä odottavat paikat', + calibrated: 'Kalibroitu', + overrides: 'Sivun ohitukset', + undo: 'Kumoa käytettävissä', + }, + messages: { + filled: + 'Täyttö valmis. Heksat piirretty: {created}. Uudelleen muotoiltu: {restyled}. Piilotetut sijainnit: {icons}.', + revealed: 'Heksat paljastettiin: {count}.', + revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', + confirmReset: + 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Heksit poistettu sivulta: {count}.', + undone: + 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksaalit nimeltä "{name}": {count}.', + unnamed: 'Poistetut nimet: {count}.', + marked: + 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + settingChanged: '{setting} asetettu arvoon {value}.', + rescanned: + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + calibrated: + 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + calibrationReset: + 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', + migrated: + 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + pruned: + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', + readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + }, + warnings: { + foregroundUnavailable: + 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', + }, + errors: { + noPage: 'Työstettävää sivua ei löytynyt.', + notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', + emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', + tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', + nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + noTokens: 'Valitse ensin yksi tai useampi merkki.', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + nothingToUndo: 'Kumoavaa täyttöä ei ole.', + unknownCommand: 'Tuntematon komento: {command}', + unknownSetting: 'Tuntematon asetus: {key}', + unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', + invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', + calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', + calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + unexpected: 'Jotain meni pieleen: {message}', + }, + hints: { + noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', + notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + noPolygons: + 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', + emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', + tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', + noHexes: + 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', + unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', + calibrateNeedsTokens: + 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + calibrateFailed: + 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', + }, + help: { + menu: 'Näytä valikko.', + fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', + reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + explore: + 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', + resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', + mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', + unmark: 'Estä valittujen merkkien piilottaminen.', + set: 'Muuta asetusta tai näytä kaikki asetukset.', + pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', + pageClear: 'Poista nykyisen sivun ohitukset.', + rescan: + 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + calibrate: + 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + calibrateReset: 'Poista nykyisen sivun kalibrointi.', + status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', + journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + help: 'Näytä tämä luettelo.', + handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', + }, + deck: { + subtitle: 'Komentolevy', + drawDesc: + 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + revealDesc: + 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + locationsDesc: + 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + toolsDesc: + 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', + footer: 'Katso täydelliset ohjeet monisteesta "{help}".', + }, + handout: { + versionLabel: 'Versio', + subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', + overview: { + heading: 'Yleiskatsaus', + body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + demo: 'Katso lyhyt esittely (versiosta 1)', + }, + quickStart: { + heading: 'Pika-aloitus', + steps: [ + 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', + 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', + 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + ], + }, + commands: { + heading: 'komennot', + intro: + 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', + colCommand: 'Komento', + colDesc: 'Mitä se tekee', + }, + revealing: { + heading: 'Kuinka paljastaminen toimii', + points: [ + 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', + 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', + 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', + 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + ], + }, + locations: { + heading: 'Nimetty Heksit ja sijainnit', + points: [ + 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', + 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + ], + }, + settings: { + heading: 'Asetukset', + intro: + 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + colKey: 'Avain', + colName: 'Asetus', + colDesc: 'Kuvaus', + perPage: '(Voidaan asettaa sivukohtaisesti.)', + }, + jumpgate: { + heading: 'Jumpgate ja Legacy', + points: [ + 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', + 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', + 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + ], + }, + upgrading: { + heading: 'Päivitys versiosta 1', + points: [ + 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', + 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', + 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + ], + colV1: 'Version 1 komento', + colV2: 'Version 2 komento', + }, + troubleshooting: { + heading: 'Vianetsintä', + points: [ + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', + 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', + 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', + 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', + ], + }, + languages: { + heading: 'Kielet', + body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + }, + credits: { + heading: 'Krediitit', + original: 'Alkuperäinen mod', + maintainer: 'Versio 2 ylläpitäjä', + marketplace: 'Adan taidepaketit Roll20 Marketplacessa', + support: + 'Jos löydät virheen tai sinulla on idea, kirjoita viesti Roll20 Mod -foorumille tai avaa ongelma GitHubissa ja sisällytä kaikki viestit API-konsolin lokista.', + }, + }, + }; + + const TRANSLATION$f = { + titles: { + ready: "L'exploration est prête.", + settings: "Paramètres d'exploration", + languages: 'Choisissez une langue', + pageSettings: 'Paramètres de la page : {page}', + status: "Statut d'exploration : {page}", + help: "Commandes d'exploration", + confirm: 'Veuillez confirmer', + }, + discovery: { + title: 'Emplacement découvert', + }, + menu: { + draw: 'Dessiner', + reveal: 'Révéler et masquer', + locations: 'Emplacements', + tools: 'Outils', + layerInUse: 'De nouveaux hexagones sont dessinés sur le {layer}.', + pageSettingsHelp: + "Ces paramètres s'appliquent uniquement à cette page. Les paramètres marqués ★ remplacent les paramètres globaux.", + }, + buttons: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + undo: 'Annuler le remplissage', + reveal: 'Révéler', + conceal: 'Cacher', + explore: 'Explorer', + revealPage: 'Révéler la page', + resetPage: 'Page de réinitialisation', + mark: "Marquer l'emplacement", + unmark: 'Décocher', + name: 'Nom Hex', + settings: 'Paramètres', + pageSettings: 'Paramètres des pages', + status: 'Statut', + rescan: 'Nouvelle analyse', + calibrate: 'Étalonner', + calibrateReset: "Réinitialiser l'étalonnage", + help: 'Aide', + change: 'Changement', + menu: 'Menu', + clearOverrides: 'Effacer les remplacements', + confirmReset: 'Oui, supprimer tous les hexagones', + }, + prompts: { + name: 'Nom du lieu (laissez vide pour effacer)', + }, + values: { + on: 'Sur', + off: 'Désactivé', + none: 'Aucun', + hexLayer: { + auto: 'Auto (premier plan si disponible)', + foreground: 'calque de premier plan', + objects: 'couche de jetons', + }, + revealBy: { + players: 'Jetons de joueur', + characters: 'Jetons de personnage', + all: 'Tous les jetons', + }, + revealMode: { + clear: 'Clair', + glimpse: 'Aperçu', + }, + announce: { + all: 'Tout le monde', + gm: 'GM uniquement', + off: 'Désactivé', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + conceal: 'Cacher', + }, + }, + settings: { + language: { + label: 'Langue', + desc: 'Langue des menus, des messages et des documents.', + }, + hexLayer: { + label: 'Couche hexagonale', + desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', + }, + fillColor: { + label: 'Couleur de remplissage', + desc: 'Couleur des nouveaux hexagones. Utilisez rgba() pour les hexagones transparents, par exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Couleur de la bordure', + desc: 'Couleur du contour des nouveaux hexagones.', + }, + labelColor: { + label: "Couleur de l'étiquette", + desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + }, + glimpseColor: { + label: 'Aperçu de la couleur', + desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + }, + strokeWidth: { + label: 'Largeur de la bordure', + desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + }, + maxDistance: { + label: 'Distance de révélation hexagonale', + desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", + }, + revealDistance: { + label: 'Distance de vue', + desc: "Combien d'hexagones autour d'un jeton en mouvement sont révélés (0 à 20). 0 révèle uniquement les hexagones traversés par le jeton.", + }, + lineOfSight: { + label: 'Ligne de vue', + desc: "Lorsque cette option est activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre lui et le jeton.", + }, + revealPath: { + label: 'Révéler le long du chemin', + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + }, + revealBy: { + label: 'Des jetons qui révèlent', + desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", + }, + revealMode: { + label: 'Mode Révéler', + desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + }, + announce: { + label: 'Annoncer des découvertes', + desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", + }, + pingDiscoveries: { + label: 'Découvertes Ping', + desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", + }, + hideCoveredTokens: { + label: 'Masquer les jetons couverts', + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + }, + }, + status: { + engine: 'Moteur de jeu', + grid: 'Grille', + layer: 'Couche hexagonale', + hexes: 'Hexagones', + named: 'Hexs nommés', + icons: 'Jetons de localisation', + glimpsed: 'Hexs aperçus', + pending: "Emplacements en attente d'un remplissage", + calibrated: 'Calibré', + overrides: 'Remplacements de page', + undo: 'Annuler disponible', + }, + messages: { + filled: + 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + revealed: 'Hexs révélés : {count}.', + revealedPage: 'Chaque hexagone de la page révélé ({count}).', + confirmReset: + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', + resetPage: 'Hexs supprimés de la page : {count}.', + undone: + 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', + named: 'Hexs nommés "{name}" : {count}.', + unnamed: 'Noms effacés : {count}.', + marked: + 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', + settingChanged: '{setting} défini sur {value}.', + rescanned: + 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + calibrated: + 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + calibrationReset: + 'Calibrage supprimé. Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + journalRebuilt: 'Les documents « {help} » et « {deck} » ont été reconstruits.', + migrated: + "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", + pruned: + "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + readyHint: + 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + }, + warnings: { + foregroundUnavailable: + 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', + someFailed: + "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + }, + errors: { + noPage: 'Impossible de trouver la page sur laquelle travailler.', + notHex: "Cette page n'utilise pas de grille hexadécimale.", + noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', + emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", + tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", + nothingToConceal: 'Sélectionnez des formes dessinées ou des jetons à masquer.', + nothingToReveal: 'Sélectionnez des hexagones, des formes dessinées ou des jetons à révéler.', + noTokens: "Sélectionnez d'abord un ou plusieurs jetons.", + noHexes: + "Sélectionnez d'abord un ou plusieurs hexagones (ou des jetons placés sur des hexagones).", + nothingToUndo: "Il n'y a aucun remplissage à défaire.", + unknownCommand: 'Commande inconnue : {command}', + unknownSetting: 'Paramètre inconnu : {key}', + unknownPageSetting: 'Paramètres pouvant être définis par page : {keys}', + invalidValue: '"{value}" n\'est pas une valeur valide pour {key}.', + calibrateNeedsTokens: 'Sélectionnez un ou deux jetons accrochés aux centres des hexagones.', + calibrateFailed: 'Ces jetons ne peuvent pas être utilisés pour calibrer.', + unexpected: "Un problème s'est produit : {message}", + }, + hints: { + noPage: + 'Ouvrez la page sur laquelle vous souhaitez travailler ou sélectionnez quelque chose dessus.', + notHex: 'Définissez la grille de la page sur Hex (V) ou Hex (H) dans Paramètres de page.', + noPolygons: + 'Dessinez un polygone, un rectangle, une ellipse ou une forme à main levée autour de la zone, sélectionnez-le, puis réessayez.', + emptyArea: + 'Dessinez une forme plus grande ou vérifiez les paramètres de la grille de la page.', + tooMany: 'Remplissez une zone plus petite ou divisez la zone en plusieurs formes.', + noHexes: + 'Les hexagones sont au premier plan ou sur la couche de jetons ; passez à ce calque pour les sélectionner.', + unknownCommand: 'Tapez !hexploration help pour lister les commandes.', + unknownSetting: 'Tapez !hexploration set pour voir tous les paramètres.', + calibrateNeedsTokens: + "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + calibrateFailed: + "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + unexpected: 'Les détails se trouvent dans le journal de la console API.', + }, + help: { + menu: 'Afficher le menu.', + fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', + fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", + undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + reveal: + 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', + revealPage: 'Révélez chaque hexagone de la page sans annonce.', + conceal: + 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', + explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", + mark: 'Transformez les jetons sélectionnés en emplacements cachés.', + unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", + set: 'Modifiez un paramètre ou affichez tous les paramètres.', + pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', + pageClear: 'Supprimez les remplacements de la page actuelle.', + rescan: + 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + calibrate: + 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', + calibrateReset: 'Supprimez le calibrage de la page actuelle.', + status: 'Montre ce que Hexploration sait de la page actuelle.', + journal: "Reconstruisez les documents d'aide et de commande.", + help: 'Montrez cette liste.', + handout: 'Les instructions complètes se trouvent dans le document « {name} ».', + }, + deck: { + subtitle: 'Pont de commandement', + drawDesc: + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + revealDesc: + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + locationsDesc: + "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", + toolsDesc: + 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Exploration hex par hex pour Roll20', + footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', + overview: { + heading: 'Aperçu', + body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + demo: 'Regardez une courte démo (à partir de la version 1)', + }, + quickStart: { + heading: 'Démarrage rapide', + steps: [ + 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', + 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', + 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", + "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + ], + }, + commands: { + heading: 'Commandes', + intro: + 'Seuls les MJ peuvent utiliser ces commandes. La plupart agissent sur les objets sélectionnés ; le reste agit sur la page que vous consultez.', + colCommand: 'Commande', + colDesc: 'Ce que ça fait', + }, + revealing: { + heading: 'Comment fonctionne la révélation', + points: [ + 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', + "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + ], + }, + locations: { + heading: 'Hexs et emplacements nommés', + points: [ + 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', + "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", + "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + ], + }, + settings: { + heading: 'Paramètres', + intro: + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + colKey: 'Clé', + colName: 'Paramètre', + colDesc: 'Description', + perPage: '(Peut être défini par page.)', + }, + jumpgate: { + heading: 'Jumpgate et héritage', + points: [ + "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", + "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", + ], + }, + upgrading: { + heading: 'Mise à niveau à partir de la version 1', + points: [ + "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", + 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', + 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', + "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + ], + colV1: 'Commande version 1', + colV2: 'Commande version 2', + }, + troubleshooting: { + heading: 'Dépannage', + points: [ + "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', + "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", + ], + }, + languages: { + heading: 'Langues', + body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + }, + credits: { + heading: 'Crédits', + original: 'Mod original par', + maintainer: 'Version 2 maintenue par', + marketplace: "Les packs artistiques d'Ada sur le Marketplace Roll20", + support: + 'Si vous trouvez un bug ou avez une idée, publiez-le sur le forum Roll20 Mod ou ouvrez un problème sur GitHub et incluez tous les messages du journal de la console API.', + }, + }, + }; + + const TRANSLATION$e = { + titles: { + ready: 'Hexploration ist fertig.', + settings: 'Erkundungseinstellungen', + languages: 'Wählen Sie eine Sprache', + pageSettings: 'Seiteneinstellungen: {page}', + status: 'Erkundungsstatus: {page}', + help: 'Erkundungsbefehle', + confirm: 'Bitte bestätigen', + }, + discovery: { + title: 'Standort entdeckt', + }, + menu: { + draw: 'Ziehen', + reveal: 'Enthüllen und Verstecken', + locations: 'Standorte', + tools: 'Werkzeuge', + layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + pageSettingsHelp: + 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', + }, + buttons: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + undo: 'Füllung rückgängig machen', + reveal: 'Aufdecken', + conceal: 'Verbergen', + explore: 'Erkunden', + revealPage: 'Seite enthüllen', + resetPage: 'Seite zurücksetzen', + mark: 'Standort markieren', + unmark: 'Markierung aufheben', + name: 'Name Hex', + settings: 'Einstellungen', + pageSettings: 'Seiteneinstellungen', + status: 'Status', + rescan: 'Erneut scannen', + calibrate: 'Kalibrieren', + calibrateReset: 'Kalibrierung zurücksetzen', + help: 'Helfen', + change: 'Ändern', + menu: 'Speisekarte', + clearOverrides: 'Überschreibungen löschen', + confirmReset: 'Ja, alle Verhexungen entfernen', + }, + prompts: { + name: 'Standortname (zum Löschen leer lassen)', + }, + values: { + on: 'An', + off: 'Aus', + none: 'Keiner', + hexLayer: { + auto: 'Auto (Vordergrund, falls verfügbar)', + foreground: 'Vordergrundebene', + objects: 'Token-Schicht', + }, + revealBy: { + players: 'Spielertoken', + characters: 'Charaktertoken', + all: 'Alle Token', + }, + revealMode: { + clear: 'Klar', + glimpse: 'Blick', + }, + announce: { + all: 'Alle', + gm: 'Nur GM', + off: 'Aus', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Sechskant (H)', + }, + fillKind: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Sprache', + desc: 'Sprache für Menüs, Nachrichten und Handouts.', + }, + hexLayer: { + label: 'Hex-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + }, + fillColor: { + label: 'Füllfarbe', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randfarbe', + desc: 'Farbe der Umrisse neuer Hexfelder.', + }, + labelColor: { + label: 'Etikettenfarbe', + desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', + }, + glimpseColor: { + label: 'Einblick in die Farbe', + desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + }, + strokeWidth: { + label: 'Randbreite', + desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', + }, + maxDistance: { + label: 'Hex-Enthüllungsabstand', + desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', + }, + revealDistance: { + label: 'Sichtweite', + desc: 'Wie viele Hexfelder um einen beweglichen Spielstein herum angezeigt werden (0 bis 20). 0 zeigt nur die Hexfelder an, die der Token durchquert.', + }, + lineOfSight: { + label: 'Sichtlinie', + desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', + }, + revealPath: { + label: 'Auf dem Weg enthüllen', + desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', + }, + revealBy: { + label: 'Zeichen, die offenbaren', + desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + }, + revealMode: { + label: 'Reveal-Modus', + desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + }, + announce: { + label: 'Kündigen Sie Entdeckungen an', + desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', + }, + pingDiscoveries: { + label: 'Ping-Entdeckungen', + desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', + }, + hideCoveredTokens: { + label: 'Verdeckte Token ausblenden', + desc: 'Roll20 zeichnet Namen, Balken und Auren über Hexfeldern. Wenn diese Option aktiviert ist, werden der für den Spieler sichtbare Name, die Balken und die Auren von Spielsteinen unter einem abgedeckten Hexfeld ausgeschaltet und wieder eingeschaltet, wenn sie aufgedeckt werden.', + }, + }, + status: { + engine: 'Spiel-Engine', + grid: 'Netz', + layer: 'Hex-Schicht', + hexes: 'Verhexungen', + named: 'Benannte Verhexungen', + icons: 'Standorttoken', + glimpsed: 'Gesehene Verhexungen', + pending: 'Orte, die auf eine Besetzung warten', + calibrated: 'Kalibriert', + overrides: 'Seitenüberschreibungen', + undo: 'Rückgängig machen verfügbar', + }, + messages: { + filled: + 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', + revealed: 'Aufgedeckte Verhexungen: {count}.', + revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + confirmReset: + 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + undone: + 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexen mit dem Namen „{name}“: {count}.', + unnamed: 'Gelöschte Namen: {count}.', + marked: + 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', + unmarked: 'Token, die keine Standorte mehr sind: {count}.', + settingChanged: '{setting} wird auf {value} gesetzt.', + rescanned: + 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + calibrated: + 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + calibrationReset: + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', + migrated: + 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + pruned: + 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + readyHint: + 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + }, + warnings: { + foregroundUnavailable: + 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', + someFailed: + 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + }, + errors: { + noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', + notHex: 'Diese Seite verwendet kein Hex-Raster.', + noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', + emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', + tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + nothingToConceal: + 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + nothingToReveal: + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', + noHexes: + 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', + nothingToUndo: 'Es gibt keine Füllung, die rückgängig gemacht werden könnte.', + unknownCommand: 'Unbekannter Befehl: {command}', + unknownSetting: 'Unbekannte Einstellung: {key}', + unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', + invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', + calibrateNeedsTokens: + 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', + unexpected: 'Es ist ein Fehler aufgetreten: {message}', + }, + hints: { + noPage: + 'Öffnen Sie die Seite, an der Sie arbeiten möchten, oder wählen Sie etwas darauf aus.', + notHex: + 'Stellen Sie das Seitenraster in den Seiteneinstellungen auf Hex (V) oder Hex (H) ein.', + noPolygons: + 'Zeichnen Sie ein Polygon, ein Rechteck, eine Ellipse oder eine Freihandform um den Bereich, wählen Sie es aus und versuchen Sie es erneut.', + emptyArea: + 'Zeichnen Sie eine größere Form oder überprüfen Sie die Seitenrastereinstellungen.', + tooMany: + 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', + noHexes: + 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', + unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', + calibrateNeedsTokens: + 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', + calibrateFailed: + 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + unexpected: 'Details finden Sie im API-Konsolenprotokoll.', + }, + help: { + menu: 'Zeigen Sie das Menü an.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', + undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + reveal: + 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', + revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + conceal: + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + explore: + 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', + set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', + pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', + rescan: + 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + calibrate: + 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', + status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', + journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + help: 'Diese Liste anzeigen.', + handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', + }, + deck: { + subtitle: 'Kommandodeck', + drawDesc: + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + revealDesc: + 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + locationsDesc: + 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + toolsDesc: + 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', + footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-für-Hex-Erkundung für Roll20', + footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', + overview: { + heading: 'Überblick', + body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', + }, + quickStart: { + heading: 'Schnellstart', + steps: [ + 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', + 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', + 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', + 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + ], + }, + commands: { + heading: 'Befehle', + intro: + 'Nur GMs können diese Befehle verwenden. Die meisten wirken auf die ausgewählten Objekte; Der Rest wirkt auf der Seite, die Sie gerade betrachten.', + colCommand: 'Befehl', + colDesc: 'Was es bewirkt', + }, + revealing: { + heading: 'Wie Offenlegung funktioniert', + points: [ + 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', + 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', + 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + ], + }, + locations: { + heading: 'Benannte Hexfelder und Orte', + points: [ + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', + 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', + 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + ], + }, + settings: { + heading: 'Einstellungen', + intro: + 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + colKey: 'Schlüssel', + colName: 'Einstellung', + colDesc: 'Beschreibung', + perPage: '(Kann pro Seite eingestellt werden.)', + }, + jumpgate: { + heading: 'Jumpgate und Legacy', + points: [ + 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', + 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + ], + }, + upgrading: { + heading: 'Upgrade von Version 1', + points: [ + 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', + 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', + 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + ], + colV1: 'Befehl der Version 1', + colV2: 'Befehl der Version 2', + }, + troubleshooting: { + heading: 'Fehlerbehebung', + points: [ + 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', + 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', + 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', + ], + }, + languages: { + heading: 'Sprachen', + body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + }, + credits: { + heading: 'Credits', + original: 'Original-Mod von', + maintainer: 'Version 2 verwaltet von', + marketplace: 'Adas Kunstpakete auf dem Roll20-Marktplatz', + support: + 'Wenn Sie einen Fehler finden oder eine Idee haben, posten Sie im Roll20 Mod-Forum oder öffnen Sie ein Problem auf GitHub und fügen Sie alle Meldungen aus dem API-Konsolenprotokoll hinzu.', + }, + }, + }; + + const TRANSLATION$d = { + titles: { + ready: 'Η εξερεύνηση είναι έτοιμη.', + settings: 'Ρυθμίσεις εξερεύνησης', + languages: 'Επιλέξτε μια γλώσσα', + pageSettings: 'Ρυθμίσεις σελίδας: {page}', + status: 'Κατάσταση εξερεύνησης: {page}', + help: 'Εντολές Εξερεύνησης', + confirm: 'Επιβεβαιώστε', + }, + discovery: { + title: 'Ανακαλύφθηκε τοποθεσία', + }, + menu: { + draw: 'Ισοπαλία', + reveal: 'Αποκάλυψη και απόκρυψη', + locations: 'Τοποθεσίες', + tools: 'Εργαλεία', + layerInUse: 'Νέα εξάγωνα σχεδιάζονται στο {layer}.', + pageSettingsHelp: + 'Αυτές οι ρυθμίσεις ισχύουν μόνο για αυτήν τη σελίδα. Οι ρυθμίσεις με την ένδειξη ★ αντικαθιστούν τις καθολικές ρυθμίσεις.', + }, + buttons: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + undo: 'Αναίρεση συμπλήρωσης', + reveal: 'Αποκαλύπτω', + conceal: 'Απόκρυψη', + explore: 'Εξερευνώ', + revealPage: 'Αποκάλυψη σελίδας', + resetPage: 'Επαναφορά σελίδας', + mark: 'Επισήμανση τοποθεσίας', + unmark: 'Κατάργηση επισήμανσης', + name: 'Όνομα Hex', + settings: 'Ρυθμίσεις', + pageSettings: 'Ρυθμίσεις σελίδας', + status: 'Κατάσταση', + rescan: 'Εκ νέου σάρωση', + calibrate: 'Μετρώ την διάμετρο', + calibrateReset: 'Επαναφορά βαθμονόμησης', + help: 'Βοήθεια', + change: 'Αλλαγή', + menu: 'Μενού', + clearOverrides: 'Εκκαθάριση παρακάμψεων', + confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + }, + prompts: { + name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', + }, + values: { + on: 'Επί', + off: 'Μακριά από', + none: 'Κανένας', + hexLayer: { + auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', + foreground: 'στρώμα πρώτου πλάνου', + objects: 'συμβολικό στρώμα', + }, + revealBy: { + players: 'Μαρκάρια παίκτη', + characters: 'Μαρκάρια χαρακτήρων', + all: 'Όλες οι μάρκες', + }, + revealMode: { + clear: 'Σαφής', + glimpse: 'Ματιά', + }, + announce: { + all: 'Καθένας', + gm: 'Μόνο GM', + off: 'Μακριά από', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + conceal: 'Απόκρυψη', + }, + }, + settings: { + language: { + label: 'Γλώσσα', + desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', + }, + hexLayer: { + label: 'Εξάγωνο στρώμα', + desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + }, + fillColor: { + label: 'Χρώμα πλήρωσης', + desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Χρώμα περιγράμματος', + desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + }, + labelColor: { + label: 'Χρώμα ετικέτας', + desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', + }, + glimpseColor: { + label: 'Χρώμα Glimpse', + desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + }, + strokeWidth: { + label: 'Πλάτος περιγράμματος', + desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + }, + maxDistance: { + label: 'Εξάγωνο αποκαλύπτουν απόσταση', + desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', + }, + revealDistance: { + label: 'Απόσταση όρασης', + desc: 'Πόσα εξάγωνα γύρω από ένα κινούμενο διακριτικό αποκαλύπτονται (0 έως 20). Το 0 αποκαλύπτει μόνο τα εξάγωνα από τα οποία διέρχεται το διακριτικό.', + }, + lineOfSight: { + label: 'Γραμμή όρασης', + desc: 'Όταν είναι ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο μεταξύ αυτού και του διακριτικού.', + }, + revealPath: { + label: 'Αποκάλυψη κατά μήκος της διαδρομής', + desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', + }, + revealBy: { + label: 'Tokens που αποκαλύπτουν', + desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + }, + revealMode: { + label: 'Λειτουργία αποκάλυψης', + desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + }, + announce: { + label: 'Ανακοινώστε Ανακαλύψεις', + desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', + }, + pingDiscoveries: { + label: 'Ping ανακαλύψεις', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + }, + hideCoveredTokens: { + label: 'Απόκρυψη καλυμμένων κουπονιών', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + }, + }, + status: { + engine: 'Μηχανή παιχνιδιού', + grid: 'Πλέγμα', + layer: 'Εξάγωνο στρώμα', + hexes: 'Εξάγωνα', + named: 'Ονομασμένα εξάγωνα', + icons: 'Διακριτικά τοποθεσίας', + glimpsed: 'Καθαρά εξάγωνα', + pending: 'Τοποθεσίες που περιμένουν γέμισμα', + calibrated: 'Βαθμονομημένο', + overrides: 'Σελίδα παρακάμπτει', + undo: 'Αναίρεση διαθέσιμη', + }, + messages: { + filled: + 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', + revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + confirmReset: + 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', + resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', + undone: + 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', + named: 'Hexes με όνομα "{name}": {count}.', + unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', + marked: + 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', + settingChanged: 'Το {setting} ορίστηκε σε {value}.', + rescanned: + 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + calibrated: + 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + calibrationReset: + 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', + migrated: + 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + pruned: + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + readyHint: + 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + someFailed: + 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + }, + errors: { + noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', + notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', + unknownCommand: 'Άγνωστη εντολή: {command}', + unknownSetting: 'Άγνωστη ρύθμιση: {key}', + unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', + invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', + unexpected: 'Κάτι πήγε στραβά: {message}', + }, + hints: { + noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', + notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + noPolygons: + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', + noHexes: + 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', + unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', + calibrateNeedsTokens: + 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + calibrateFailed: + 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', + }, + help: { + menu: 'Εμφάνιση του μενού.', + fill: 'Καλύψτε τα επιλεγμένα σχεδιασμένα σχήματα με εξάγωνα.', + fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', + undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', + reveal: + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', + conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', + name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', + mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', + unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', + pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', + pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', + rescan: + 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + calibrate: + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', + status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', + journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + help: 'Εμφάνιση αυτής της λίστας.', + handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', + }, + deck: { + subtitle: 'Κατάστρωμα εντολών', + drawDesc: + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + revealDesc: + 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + locationsDesc: + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + toolsDesc: + 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', + footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', + }, + handout: { + versionLabel: 'Εκδοχή', + subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', + overview: { + heading: 'Επισκόπηση', + body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', + }, + quickStart: { + heading: 'Γρήγορη εκκίνηση', + steps: [ + 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', + 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + ], + }, + commands: { + heading: 'Εντολές', + intro: + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + colCommand: 'Εντολή', + colDesc: 'Τι κάνει', + }, + revealing: { + heading: 'Πώς λειτουργεί η αποκάλυψη', + points: [ + 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', + 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', + 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', + 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + ], + }, + locations: { + heading: 'Με όνομα Hexes and Locations', + points: [ + 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + ], + }, + settings: { + heading: 'Ρυθμίσεις', + intro: + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + colKey: 'Κλειδί', + colName: 'Σύνθεση', + colDesc: 'Περιγραφή', + perPage: '(Μπορεί να οριστεί ανά σελίδα.)', + }, + jumpgate: { + heading: 'Jumpgate και Legacy', + points: [ + 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', + 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + ], + }, + upgrading: { + heading: 'Αναβάθμιση από την έκδοση 1', + points: [ + 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', + 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', + 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + ], + colV1: 'Εντολή έκδοσης 1', + colV2: 'Εντολή έκδοσης 2', + }, + troubleshooting: { + heading: 'Αντιμετώπιση προβλημάτων', + points: [ + 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', + 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', + 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', + 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', + ], + }, + languages: { + heading: 'Γλώσσες', + body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + }, + credits: { + heading: 'Πιστώσεις', + original: 'Πρωτότυπο mod από', + maintainer: 'Έκδοση 2 που διατηρείται από', + marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', + support: + 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', + }, + }, + }; + + const TRANSLATION$c = { + titles: { + ready: 'החקירה מוכנה.', + settings: 'הגדרות החקירה', + languages: 'בחר שפה', + pageSettings: 'הגדרות דף: {page}', + status: 'סטטוס החקירה: {page}', + help: 'פקודות החקירה', + confirm: 'אנא אשר', + }, + discovery: { + title: 'מיקום התגלה', + }, + menu: { + draw: 'לִמְשׁוֹך', + reveal: 'לגלות ולהסתיר', + locations: 'מיקומים', + tools: 'כְּלֵי עֲבוֹדָה', + layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + pageSettingsHelp: + 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', + }, + buttons: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + undo: 'בטל מילוי', + reveal: 'לְגַלוֹת', + conceal: 'לְהַסתִיר', + explore: 'לַחקוֹר', + revealPage: 'גלה עמוד', + resetPage: 'אפס דף', + mark: 'סמן מיקום', + unmark: 'בטל את הסימון', + name: 'שם הקס', + settings: 'הגדרות', + pageSettings: 'הגדרות עמוד', + status: 'סטָטוּס', + rescan: 'סרוק מחדש', + calibrate: 'לְדַרֵג', + calibrateReset: 'אפס כיול', + help: 'עֶזרָה', + change: 'לְשַׁנוֹת', + menu: 'תַפרִיט', + clearOverrides: 'נקה עקיפות', + confirmReset: 'כן, הסר את כל המשושים', + }, + prompts: { + name: 'שם המיקום (השאירו ריק כדי לנקות)', + }, + values: { + on: 'עַל', + off: 'כבוי', + none: 'אַף לֹא אֶחָד', + hexLayer: { + auto: 'אוטומטי (בחזית אם זמין)', + foreground: 'שכבת חזית', + objects: 'שכבת אסימונים', + }, + revealBy: { + players: 'אסימוני שחקן', + characters: 'אסימוני תווים', + all: 'כל האסימונים', + }, + revealMode: { + clear: 'בָּרוּר', + glimpse: 'הֲצָצָה', + }, + announce: { + all: 'כֹּל אֶחָד', + gm: 'GM בלבד', + off: 'כבוי', + }, + orientation: { + vertical: 'משושה (V)', + horizontal: 'משושה (H)', + }, + fillKind: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + conceal: 'לְהַסתִיר', + }, + }, + settings: { + language: { + label: 'שָׂפָה', + desc: 'שפה לתפריטים, הודעות ודפי מידע.', + }, + hexLayer: { + label: 'שכבת משושה', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + }, + fillColor: { + label: 'צבע מילוי', + desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'צבע גבול', + desc: 'צבע קווי המתאר של משושות חדשות.', + }, + labelColor: { + label: 'צבע התווית', + desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + }, + glimpseColor: { + label: 'צבע הצצה', + desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + }, + strokeWidth: { + label: 'רוחב גבול', + desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', + }, + maxDistance: { + label: 'מרחק חשיפת משושה', + desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', + }, + revealDistance: { + label: 'מרחק ראייה', + desc: 'כמה משושים סביב אסימון נע נחשפים (0 עד 20). 0 חושף רק את המשושים שהאסימון עובר דרכם.', + }, + lineOfSight: { + label: 'קו ראייה', + desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', + }, + revealPath: { + label: 'גלה לאורך הנתיב', + desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', + }, + revealBy: { + label: 'אסימונים שחושפים', + desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', + }, + revealMode: { + label: 'מצב חשיפה', + desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + }, + announce: { + label: 'הכריזו על תגליות', + desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", + }, + pingDiscoveries: { + label: 'פינג תגליות', + desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', + }, + hideCoveredTokens: { + label: 'הסתר אסימונים מכוסים', + desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + }, + }, + status: { + engine: 'מנוע משחק', + grid: 'רֶשֶׁת', + layer: 'שכבת משושה', + hexes: 'משושים', + named: 'ששים בשם', + icons: 'אסימוני מיקום', + glimpsed: 'משושים נוצצים', + pending: 'מיקומים ממתינים למילוי', + calibrated: 'מְכוּיָל', + overrides: 'עקיפת עמוד', + undo: 'בטל זמין', + }, + messages: { + filled: + 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', + revealed: 'נחשפו משושים: {count}.', + revealedPage: 'כל hex בדף נחשף ({count}).', + confirmReset: + 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', + resetPage: 'הקסים הוסרו מהדף: {count}.', + undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', + named: 'hexes בשם "{name}": {count}.', + unnamed: 'שמות נוקו: {count}.', + marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', + settingChanged: '{setting} מוגדר ל-{value}.', + rescanned: + 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + calibrated: + 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + calibrationReset: + 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', + migrated: + 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + pruned: + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + readyHint: + 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', + someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + }, + errors: { + noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', + notHex: 'דף זה אינו משתמש ברשת משושה.', + noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', + tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', + nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', + noTokens: 'תחילה בחר אסימון אחד או יותר.', + noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + nothingToUndo: 'אין מילוי לבטל.', + unknownCommand: 'פקודה לא ידועה: {command}', + unknownSetting: 'הגדרה לא ידועה: {key}', + unknownPageSetting: 'הגדרות שניתן להגדיר לכל עמוד: {keys}', + invalidValue: '"{value}" אינו ערך חוקי עבור {key}.', + calibrateNeedsTokens: 'בחר אסימון אחד או שניים שהוצמדו למרכזי משושה.', + calibrateFailed: 'לא ניתן להשתמש באסימונים האלה לכיול.', + unexpected: 'משהו השתבש: {message}', + }, + hints: { + noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', + notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + noPolygons: + 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', + noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', + unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', + unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', + calibrateNeedsTokens: + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + calibrateFailed: + 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', + }, + help: { + menu: 'הצג את התפריט.', + fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', + undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', + revealPage: 'חשוף כל קסם בדף ללא הודעות.', + conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', + resetPage: 'הסר כל hex בדף (שואל תחילה).', + name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', + unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + set: 'שנה הגדרה או הצג את כל ההגדרות.', + pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', + pageClear: 'הסר את העקיפות של הדף הנוכחי.', + rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', + calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + calibrateReset: 'הסר את הכיול של הדף הנוכחי.', + status: 'הצג מה Hexploration יודע על הדף הנוכחי.', + journal: 'בנה מחדש את דפי העזרה והפקודה.', + help: 'הצג רשימה זו.', + handout: 'ההנחיות המלאות נמצאות בדף "{name}".', + }, + deck: { + subtitle: 'סיפון פיקוד', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + revealDesc: + 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + locationsDesc: + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', + footer: 'עיין בדף "{help}" להנחיות מלאות.', + }, + handout: { + versionLabel: 'גִרְסָה', + subtitle: 'חקירה משושה אחר קסם עבור Roll20', + footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', + overview: { + heading: 'סקירה כללית', + body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + demo: 'צפו בהדגמה קצרה (מגרסה 1)', + }, + quickStart: { + heading: 'התחלה מהירה', + steps: [ + 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', + 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + ], + }, + commands: { + heading: 'פקודות', + intro: + 'רק GMs יכולים להשתמש בפקודות אלה. רובם פועלים על האובייקטים שנבחרו; השאר פועלים בדף שבו אתה צופה.', + colCommand: 'פְּקוּדָה', + colDesc: 'מה זה עושה', + }, + revealing: { + heading: 'איך עובד גילוי', + points: [ + 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', + 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + ], + }, + locations: { + heading: 'בשם משושים ומיקומים', + points: [ + 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', + 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', + 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + ], + }, + settings: { + heading: 'הגדרות', + intro: + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + colKey: 'מַפְתֵחַ', + colName: 'סְבִיבָה', + colDesc: 'תֵאוּר', + perPage: '(ניתן להגדיר לכל עמוד.)', + }, + jumpgate: { + heading: 'Jumpgate ומורשת', + points: [ + 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', + 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', + 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', + ], + }, + upgrading: { + heading: 'משדרג מגרסה 1', + points: [ + 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', + 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', + 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + ], + colV1: 'פקודה גרסה 1', + colV2: 'פקודה גרסה 2', + }, + troubleshooting: { + heading: 'פתרון בעיות', + points: [ + 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', + 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', + 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', + ], + }, + languages: { + heading: 'שפות', + body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + }, + credits: { + heading: 'קרדיטים', + original: 'מוד מקורי מאת', + maintainer: 'גרסה 2 מתוחזקת על ידי', + marketplace: 'חבילות האמנות של עדה ב-Roll20 Marketplace', + support: + 'אם אתה מוצא באג או יש לך רעיון, פרסם בפורום Roll20 Mod או פתח בעיה ב-GitHub, וכלול הודעות כלשהן מיומן מסוף ה-API.', + }, + }, + }; + + const TRANSLATION$b = { + titles: { + ready: 'A hexploration készen áll.', + settings: 'Hexexploration beállítások', + languages: 'Válasszon nyelvet', + pageSettings: 'Oldalbeállítások: {page}', + status: 'Heti feltárás állapota: {page}', + help: 'Hexploration parancsok', + confirm: 'Kérjük, erősítse meg', + }, + discovery: { + title: 'Hely felfedezve', + }, + menu: { + draw: 'Rajzolj', + reveal: 'Felfedni és elrejteni', + locations: 'Helyszínek', + tools: 'Eszközök', + layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + pageSettingsHelp: + 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', + }, + buttons: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + undo: 'Kitöltés visszavonása', + reveal: 'Felfedni', + conceal: 'Elrejteni', + explore: 'Fedezze fel', + revealPage: 'Oldal feltárása', + resetPage: 'Oldal visszaállítása', + mark: 'Hely megjelölése', + unmark: 'Törölje a jelölést', + name: 'Név Hex', + settings: 'Beállítások elemre', + pageSettings: 'Oldalbeállítások', + status: 'Állapot', + rescan: 'Újraszkennelés', + calibrate: 'Kalibrálni', + calibrateReset: 'Kalibrálás visszaállítása', + help: 'Segítség', + change: 'Változás', + menu: 'Menü', + clearOverrides: 'Felülbírálások törlése', + confirmReset: 'Igen, távolítsa el az összes hexát', + }, + prompts: { + name: 'Helynév (a törléshez hagyja üresen)', + }, + values: { + on: 'On', + off: 'Le', + none: 'Egyik sem', + hexLayer: { + auto: 'Automatikus (előtérben, ha elérhető)', + foreground: 'előtér réteg', + objects: 'token réteg', + }, + revealBy: { + players: 'Játékos tokenek', + characters: 'Karakter tokenek', + all: 'Minden token', + }, + revealMode: { + clear: 'Világos', + glimpse: 'Bepillantás', + }, + announce: { + all: 'Mindenki', + gm: 'Csak GM', + off: 'Le', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + conceal: 'Elrejteni', + }, + }, + settings: { + language: { + label: 'Nyelv', + desc: 'A menük, üzenetek és tájékoztatók nyelve.', + }, + hexLayer: { + label: 'Hatlapos réteg', + desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + }, + fillColor: { + label: 'Kitöltés színe', + desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Szegély színe', + desc: 'Az új hatszögek körvonalának színe.', + }, + labelColor: { + label: 'Címke színe', + desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + }, + strokeWidth: { + label: 'Határ szélessége', + desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', + }, + maxDistance: { + label: 'Hex Reveal távolság', + desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', + }, + revealDistance: { + label: 'Látótávolság', + desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + }, + lineOfSight: { + label: 'Látóvonal', + desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', + }, + revealPath: { + label: 'Fedezd fel az ösvényen', + desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + }, + revealBy: { + label: 'Tokenek, amelyek felfedik', + desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + }, + revealMode: { + label: 'Felfedezési mód', + desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + }, + announce: { + label: 'Hirdesse a felfedezéseket', + desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', + }, + pingDiscoveries: { + label: 'Ping felfedezések', + desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', + }, + hideCoveredTokens: { + label: 'Fedett tokenek elrejtése', + desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + }, + }, + status: { + engine: 'Játék motor', + grid: 'Rács', + layer: 'Hatlapos réteg', + hexes: 'Hexák', + named: 'Elnevezett hexák', + icons: 'Helyjelzők', + glimpsed: 'Megpillantott hatszögek', + pending: 'Betöltésre váró helyek', + calibrated: 'Kalibrálva', + overrides: 'Oldal felülbírálása', + undo: 'Visszavonás elérhető', + }, + messages: { + filled: + 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', + revealed: 'Felfedezett hatszögek: {count}.', + revealedPage: 'Az oldalon minden hex látható ({count}).', + confirmReset: + 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + resetPage: 'Az oldalról eltávolított hatszögek: {count}.', + undone: + 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', + named: '"{name}" nevű hatszögek: {count}.', + unnamed: 'Törölt nevek: {count}.', + marked: + 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + unmarked: 'Tokenek, amelyek már nem helyek: {count}.', + settingChanged: '{setting} értéke {value}.', + rescanned: + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + calibrated: + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + calibrationReset: + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', + journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + migrated: + 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + pruned: + 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + readyHint: + 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + }, + warnings: { + foregroundUnavailable: + 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', + }, + errors: { + noPage: 'Nem található az oldal, amelyen dolgozni kellene.', + notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', + emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', + nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + nothingToReveal: + 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + noTokens: 'Először válasszon ki egy vagy több tokent.', + noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + nothingToUndo: 'Nincs visszavonható kitöltés.', + unknownCommand: 'Ismeretlen parancs: {command}', + unknownSetting: 'Ismeretlen beállítás: {key}', + unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', + invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', + calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', + unexpected: 'Hiba történt: {message}', + }, + hints: { + noPage: 'Nyissa meg azt az oldalt, amelyen dolgozni szeretne, vagy válasszon rajta valamit.', + notHex: 'Állítsa az oldalrácsot Hex (V) vagy Hex (H) értékre az Oldalbeállításokban.', + noPolygons: + 'Rajzoljon sokszöget, téglalapot, ellipszist vagy szabadkézi alakzatot a terület köré, jelölje ki, majd próbálkozzon újra.', + emptyArea: 'Rajzoljon nagyobb alakzatot, vagy ellenőrizze az oldalrács beállításait.', + tooMany: 'Töltsön ki egy kisebb területet, vagy ossza fel több formára.', + noHexes: + 'A hatszögek az előtérben vagy a token rétegben vannak; váltson át arra a rétegre a kijelölésükhöz.', + unknownCommand: 'Írja be a !hexploration help parancsot a parancsok listázásához.', + unknownSetting: 'Minden beállítás megtekintéséhez írja be a !hexploration set parancsot.', + calibrateNeedsTokens: + 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', + calibrateFailed: + 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + unexpected: 'A részletek az API-konzol naplójában találhatók.', + }, + help: { + menu: 'Mutasd a menüt.', + fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', + undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', + reveal: + 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', + revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + conceal: + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', + name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', + unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', + set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', + pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', + pageClear: 'Távolítsa el az aktuális oldal felülírásait.', + rescan: + 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + calibrate: + 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', + status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', + journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + help: 'Mutasd ezt a listát.', + handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', + }, + deck: { + subtitle: 'Parancsnoki pakli', + drawDesc: + 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', + revealDesc: + 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + locationsDesc: + 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + toolsDesc: + 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', + footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', + }, + handout: { + versionLabel: 'Változat', + subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', + overview: { + heading: 'Áttekintés', + body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + }, + quickStart: { + heading: 'Gyors kezdés', + steps: [ + 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', + 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', + 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', + ], + }, + commands: { + heading: 'Parancsok', + intro: + 'Csak a GM-ek használhatják ezeket a parancsokat. A legtöbb a kiválasztott objektumokra hat; a többi az éppen megtekintett oldalon működik.', + colCommand: 'Parancs', + colDesc: 'Mit csinál', + }, + revealing: { + heading: 'Hogyan működik a feltárás', + points: [ + 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', + 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', + 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', + 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + ], + }, + locations: { + heading: 'Hexák és helyek neve', + points: [ + 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', + 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + ], + }, + settings: { + heading: 'Beállítások elemre', + intro: + 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + colKey: 'Kulcsfontosságú', + colName: 'Beállítás', + colDesc: 'Leírás', + perPage: '(Oldalonként beállítható.)', + }, + jumpgate: { + heading: 'Jumpgate és Legacy', + points: [ + 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', + 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + ], + }, + upgrading: { + heading: 'Frissítés az 1-es verzióról', + points: [ + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', + 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + ], + colV1: '1-es verzió parancs', + colV2: '2-es verzió parancs', + }, + troubleshooting: { + heading: 'Hibaelhárítás', + points: [ + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', + 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', + 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + ], + }, + languages: { + heading: 'Nyelvek', + body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + }, + credits: { + heading: 'Kredit', + original: 'Eredeti mod által', + maintainer: 'A 2-es verziót karbantartja', + marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', + support: + 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + }, + }, + }; + + const TRANSLATION$a = { + titles: { + ready: "L'esplorazione è pronta.", + settings: 'Impostazioni di esplorazione', + languages: 'Scegli una lingua', + pageSettings: 'Impostazioni pagina: {page}', + status: 'Stato esplorazione: {page}', + help: 'Comandi di esplorazione', + confirm: 'Per favore conferma', + }, + discovery: { + title: 'Posizione scoperta', + }, + menu: { + draw: 'Disegno', + reveal: 'Rivelare e nascondere', + locations: 'Posizioni', + tools: 'Utensili', + layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + pageSettingsHelp: + 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', + }, + buttons: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + undo: 'Annulla riempimento', + reveal: 'Svelare', + conceal: 'Nascondere', + explore: 'Esplorare', + revealPage: 'Rivela pagina', + resetPage: 'Reimposta pagina', + mark: 'Segna posizione', + unmark: 'Deseleziona', + name: 'Nome esadecimale', + settings: 'Impostazioni', + pageSettings: 'Impostazioni della pagina', + status: 'Stato', + rescan: 'Nuova scansione', + calibrate: 'Calibrare', + calibrateReset: 'Ripristina calibrazione', + help: 'Aiuto', + change: 'Modifica', + menu: 'Menu', + clearOverrides: 'Cancella sostituzioni', + confirmReset: 'Sì, rimuovi tutti gli esagoni', + }, + prompts: { + name: 'Nome della posizione (lascia vuoto per cancellare)', + }, + values: { + on: 'SU', + off: 'Spento', + none: 'Nessuno', + hexLayer: { + auto: 'Automatico (in primo piano se disponibile)', + foreground: 'strato di primo piano', + objects: 'strato di token', + }, + revealBy: { + players: 'Gettoni del giocatore', + characters: 'Segnalini personaggio', + all: 'Tutti i gettoni', + }, + revealMode: { + clear: 'Chiaro', + glimpse: 'Occhiata', + }, + announce: { + all: 'Tutti', + gm: 'Solo GM', + off: 'Spento', + }, + orientation: { + vertical: 'Esadecimale (V)', + horizontal: 'Esadecimale (H)', + }, + fillKind: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + conceal: 'Nascondere', + }, + }, + settings: { + language: { + label: 'Lingua', + desc: 'Lingua per menu, messaggi e dispense.', + }, + hexLayer: { + label: 'Strato esagonale', + desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + }, + fillColor: { + label: 'Colore riempimento', + desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Colore del bordo', + desc: 'Colore del contorno dei nuovi esagoni.', + }, + labelColor: { + label: "Colore dell'etichetta", + desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', + }, + glimpseColor: { + label: 'Colore scorcio', + desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + }, + strokeWidth: { + label: 'Larghezza del bordo', + desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', + }, + maxDistance: { + label: 'Distanza di rivelazione esadecimale', + desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', + }, + revealDistance: { + label: 'Distanza visiva', + desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', + }, + lineOfSight: { + label: 'Linea di vista', + desc: 'Quando è attivo, un esagono viene rivelato solo se non si trova alcun esagono coperto tra esso e il segnalino.', + }, + revealPath: { + label: 'Rivela lungo il percorso', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + }, + revealBy: { + label: 'Segnalini che rivelano', + desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + }, + revealMode: { + label: 'Modalità Rivela', + desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + }, + announce: { + label: 'Annunciare le scoperte', + desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', + }, + pingDiscoveries: { + label: 'Scoperte del ping', + desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + }, + hideCoveredTokens: { + label: 'Nascondi i token coperti', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + }, + }, + status: { + engine: 'Motore di gioco', + grid: 'Griglia', + layer: 'Strato esagonale', + hexes: 'Esagoni', + named: 'Esagoni con nome', + icons: 'Gettoni di posizione', + glimpsed: 'Esagoni intravisti', + pending: 'Posizioni in attesa di riempimento', + calibrated: 'Calibrato', + overrides: "La pagina esegue l'override", + undo: 'Annulla disponibile', + }, + messages: { + filled: + 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + revealed: 'Esagoni rivelati: {count}.', + revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + confirmReset: + 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + resetPage: 'Esagoni rimossi dalla pagina: {count}.', + undone: + 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', + named: 'Esagoni denominati "{name}": {count}.', + unnamed: 'Nomi cancellati: {count}.', + marked: + 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', + unmarked: 'Token che non rappresentano più posizioni: {count}.', + settingChanged: '{setting} impostato su {value}.', + rescanned: + 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + calibrated: + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + calibrationReset: + 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', + migrated: + 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + pruned: + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + readyHint: + 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + }, + warnings: { + foregroundUnavailable: + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + someFailed: + 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', + }, + errors: { + noPage: 'Impossibile trovare la pagina su cui lavorare.', + notHex: 'Questa pagina non utilizza una griglia esadecimale.', + noPolygons: 'Seleziona una o più forme disegnate da riempire.', + emptyArea: "L'area selezionata non contiene centri esadecimali.", + tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', + nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', + noTokens: 'Seleziona prima uno o più token.', + noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToUndo: "Non c'è nessun riempimento da annullare.", + unknownCommand: 'Comando sconosciuto: {command}', + unknownSetting: 'Impostazione sconosciuta: {key}', + unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', + invalidValue: '"{value}" non è un valore valido per {key}.', + calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', + calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + unexpected: 'Qualcosa è andato storto: {message}', + }, + hints: { + noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', + notHex: + 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + noPolygons: + "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", + emptyArea: + 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', + tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", + noHexes: + 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + unknownCommand: 'Digita !hexploration help per elencare i comandi.', + unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', + calibrateNeedsTokens: + 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + calibrateFailed: + 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + unexpected: 'I dettagli si trovano nel registro della console API.', + }, + help: { + menu: 'Mostra il menù.', + fill: 'Copri le forme disegnate selezionate con esagoni.', + fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", + undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + reveal: + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', + conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", + explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', + unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + set: "Modifica un'impostazione o mostra tutte le impostazioni.", + pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageClear: 'Rimuovi le sostituzioni della pagina corrente.', + rescan: + "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + calibrate: + 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', + status: 'Mostra cosa sa Hexploration sulla pagina corrente.', + journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + help: 'Mostra questo elenco.', + handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + }, + deck: { + subtitle: 'Mazzo di comando', + drawDesc: + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + revealDesc: + 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + locationsDesc: + 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + toolsDesc: + 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', + footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + }, + handout: { + versionLabel: 'Versione', + subtitle: 'Esplorazione esagono per esagono per Roll20', + footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + overview: { + heading: 'Panoramica', + body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + demo: 'Guarda una breve demo (dalla versione 1)', + }, + quickStart: { + heading: 'Avvio rapido', + steps: [ + 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', + "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", + 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + ], + }, + commands: { + heading: 'Comandi', + intro: + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + colCommand: 'Comando', + colDesc: 'Cosa fa', + }, + revealing: { + heading: 'Come funziona la rivelazione', + points: [ + 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', + 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', + "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", + 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + ], + }, + locations: { + heading: 'Esagoni e posizioni con nome', + points: [ + 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", + 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + ], + }, + settings: { + heading: 'Impostazioni', + intro: + 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + colKey: 'Chiave', + colName: 'Collocamento', + colDesc: 'Descrizione', + perPage: '(Può essere impostato per pagina.)', + }, + jumpgate: { + heading: 'Jumpgate e Legacy', + points: [ + "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", + "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + ], + }, + upgrading: { + heading: 'Aggiornamento dalla versione 1', + points: [ + 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', + 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', + 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + ], + colV1: 'Comando della versione 1', + colV2: 'Comando della versione 2', + }, + troubleshooting: { + heading: 'Risoluzione dei problemi', + points: [ + 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', + 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', + "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', + ], + }, + languages: { + heading: 'Lingue', + body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + }, + credits: { + heading: 'Crediti', + original: 'Mod originale di', + maintainer: 'Versione 2 mantenuta da', + marketplace: 'I pacchetti artistici di Ada sul Marketplace Roll20', + support: + "Se trovi un bug o hai un'idea, pubblica un post nel forum Roll20 Mod o apri un problema su GitHub e includi eventuali messaggi dal registro della console API.", + }, + }, + }; + + const TRANSLATION$9 = { + titles: { + ready: 'H探索の準備は完了です。', + settings: 'H探索設定', + languages: '言語を選択してください', + pageSettings: 'ページ設定: {page}', + status: 'H探索ステータス: {page}', + help: 'H探索コマンド', + confirm: 'ご確認ください', + }, + discovery: { + title: '場所が発見されました', + }, + menu: { + draw: '描く', + reveal: '表示と非表示', + locations: '所在地', + tools: 'ツール', + layerInUse: '新しいヘクスが {layer} に描画されています。', + pageSettingsHelp: + 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', + }, + buttons: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + undo: '塗りつぶしを元に戻す', + reveal: '明らかにする', + conceal: '隠す', + explore: '探検する', + revealPage: 'ページを公開', + resetPage: 'ページをリセット', + mark: '位置をマークする', + unmark: 'マークを外す', + name: '名前の 16 進数', + settings: '設定', + pageSettings: 'ページ設定', + status: '状態', + rescan: '再スキャン', + calibrate: '校正する', + calibrateReset: 'キャリブレーションをリセットする', + help: 'ヘルプ', + change: '変化', + menu: 'メニュー', + clearOverrides: 'オーバーライドのクリア', + confirmReset: 'はい、すべてのヘクスを削除します', + }, + prompts: { + name: '場所の名前 (クリアするには空白のままにします)', + }, + values: { + on: 'の上', + off: 'オフ', + none: 'なし', + hexLayer: { + auto: '自動 (利用可能な場合は前景)', + foreground: '前景レイヤー', + objects: 'トークン層', + }, + revealBy: { + players: 'プレイヤートークン', + characters: 'キャラクタートークン', + all: 'すべてのトークン', + }, + revealMode: { + clear: 'クリア', + glimpse: '垣間見る', + }, + announce: { + all: 'みんな', + gm: 'GMのみ', + off: 'オフ', + }, + orientation: { + vertical: 'ヘックス(V)', + horizontal: '六角(H)', + }, + fillKind: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + conceal: '隠す', + }, + }, + settings: { + language: { + label: '言語', + desc: 'メニュー、メッセージ、配布資料の言語。', + }, + hexLayer: { + label: 'ヘックスレイヤー', + desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + }, + fillColor: { + label: '塗りつぶしの色', + desc: '新しいヘクスの色。シースルー ヘクスには rgba() を使用します (例: rgba(0,0,0,0.8))。', + }, + strokeColor: { + label: '枠線の色', + desc: '新しいヘクスの輪郭の色。', + }, + labelColor: { + label: 'ラベルの色', + desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', + }, + glimpseColor: { + label: '垣間見える色', + desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + }, + strokeWidth: { + label: '枠線の幅', + desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', + }, + maxDistance: { + label: '16進数の表示距離', + desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', + }, + revealDistance: { + label: '視距離', + desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + }, + lineOfSight: { + label: '視線', + desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', + }, + revealPath: { + label: 'パスに沿って表示', + desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', + }, + revealBy: { + label: '明らかにするトークン', + desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + }, + revealMode: { + label: 'リビールモード', + desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + }, + announce: { + label: '発見の発表', + desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', + }, + pingDiscoveries: { + label: 'Ping の発見', + desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + }, + hideCoveredTokens: { + label: 'カバーされたトークンを非表示にする', + desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', + }, + }, + status: { + engine: 'ゲームエンジン', + grid: 'グリッド', + layer: 'ヘックスレイヤー', + hexes: 'ヘクス', + named: '名前付きヘクス', + icons: '位置トークン', + glimpsed: '垣間見えるヘクス', + pending: '埋まりを待っている場所', + calibrated: '校正済み', + overrides: 'ページの上書き', + undo: '元に戻すことが可能', + }, + messages: { + filled: + '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + revealed: '明らかになったヘクス: {count}。', + revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', + confirmReset: + '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + resetPage: 'ページから削除されたヘクス: {count}。', + undone: + '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', + named: '「{name}」という名前のヘクス: {count}。', + unnamed: '削除された名前: {count}。', + marked: + '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + unmarked: '場所ではなくなったトークン: {count}。', + settingChanged: '{setting} を {value} に設定します。', + rescanned: + '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + calibrated: + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + calibrationReset: + 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', + migrated: + 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + pruned: + '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', + readyHint: + 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + }, + warnings: { + foregroundUnavailable: + 'このゲームは前景レイヤーでの描画をサポートしていないため、ヘクスはトークン レイヤーに描画されました。', + someFailed: + '描画できなかったヘクス: {count}。詳細については API コンソールを確認してください。', + }, + errors: { + noPage: '作業するページが見つかりませんでした。', + notHex: 'このページでは 16 進グリッドは使用されていません。', + noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', + emptyArea: '選択した領域には六角中心が含まれていません。', + tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', + nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', + nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', + noTokens: '最初に 1 つ以上のトークンを選択します。', + noHexes: '最初に 1 つ以上のヘクス (またはヘクス上にあるトークン) を選択します。', + nothingToUndo: '元に戻す塗りつぶしはありません。', + unknownCommand: '不明なコマンド: {command}', + unknownSetting: '不明な設定: {key}', + unknownPageSetting: 'ページごとに設定できる設定: {keys}', + invalidValue: '「{value}」は、{key} の有効な値ではありません。', + calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateFailed: 'これらのトークンは調整には使用できません。', + unexpected: '問題が発生しました: {message}', + }, + hints: { + noPage: '作業したいページを開くか、ページ上で何かを選択します。', + notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + noPolygons: + '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', + emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', + tooMany: 'より小さい領域を塗りつぶすか、領域をいくつかの形状に分割します。', + noHexes: 'ヘクスは前景またはトークン層にあります。そのレイヤーに切り替えて選択します。', + unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', + unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', + calibrateNeedsTokens: + 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + calibrateFailed: + '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + unexpected: '詳細は API コンソールのログに記載されています。', + }, + help: { + menu: 'メニューを表示します。', + fill: '選択した描画形状を六角形で覆います。', + fillInverse: '選択した図形の内側を除いてページ全体を覆います。', + undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', + revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', + conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', + resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', + name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', + mark: '選択したトークンを非表示の場所に変更します。', + unmark: '選択したトークンが非表示の場所になるのを停止します。', + set: '設定を変更するか、すべての設定を表示します。', + pageSet: '現在のページでのみ公開設定をオーバーライドします。', + pageClear: '現在のページのオーバーライドを削除します。', + rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + calibrate: + '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + calibrateReset: '現在のページの調整を削除します。', + status: '現在のページについて Hexploration が知っていることを表示します。', + journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + help: 'このリストを表示します。', + handout: '完全な手順は配布資料「{name}」に記載されています。', + }, + deck: { + subtitle: 'コマンドデッキ', + drawDesc: + '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + revealDesc: + 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + locationsDesc: + 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + toolsDesc: + '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', + footer: '完全な手順については、配布資料「{help}」を参照してください。', + }, + handout: { + versionLabel: 'バージョン', + subtitle: 'Roll20 のヘックスごとの探索', + footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', + overview: { + heading: '概要', + body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + demo: '短いデモを見る (バージョン 1 から)', + }, + quickStart: { + heading: 'クイックスタート', + steps: [ + 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', + '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', + 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', + 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + ], + }, + commands: { + heading: 'コマンド', + intro: + 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', + colCommand: '指示', + colDesc: '何をするのか', + }, + revealing: { + heading: '暴露の仕組み', + points: [ + 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', + 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', + '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', + 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', + 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + ], + }, + locations: { + heading: '名前付きヘクスと場所', + points: [ + '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', + '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', + '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + ], + }, + settings: { + heading: '設定', + intro: + '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + colKey: '鍵', + colName: '設定', + colDesc: '説明', + perPage: '（ページごとに設定可能）', + }, + jumpgate: { + heading: 'ジャンプゲートとレガシー', + points: [ + 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', + 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', + 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', + ], + }, + upgrading: { + heading: 'バージョン1からのアップグレード', + points: [ + 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', + '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', + 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + ], + colV1: 'バージョン1のコマンド', + colV2: 'バージョン 2 コマンド', + }, + troubleshooting: { + heading: 'トラブルシューティング', + points: [ + 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', + 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', + 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', + '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', + ], + }, + languages: { + heading: '言語', + body: '!hexploration set language で言語を選択します。利用可能な言語:', + }, + credits: { + heading: 'クレジット', + original: 'オリジナルMODによる', + maintainer: 'バージョン 2 の保守者', + marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', + support: + 'バグを見つけた場合やアイデアがある場合は、Roll20 Mod フォーラムに投稿するか、GitHub で問題を開いて、API コンソール ログからのメッセージを含めてください。', + }, + }, + }; + + const TRANSLATION$8 = { + titles: { + ready: '탐색이 준비되었습니다.', + settings: '탐색 설정', + languages: '언어를 선택하세요', + pageSettings: '페이지 설정: {page}', + status: '탐색 상태: {page}', + help: '탐색 명령', + confirm: '확인해주세요', + }, + discovery: { + title: '발견된 위치', + }, + menu: { + draw: '그리다', + reveal: '공개 및 숨기기', + locations: '위치', + tools: '도구', + layerInUse: '{layer}에 새로운 헥스가 그려지고 있습니다.', + pageSettingsHelp: + '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', + }, + buttons: { + fill: '채우다', + fillInverse: '역 채우기', + undo: '채우기 실행 취소', + reveal: '드러내다', + conceal: '숨기다', + explore: '탐구하다', + revealPage: '페이지 공개', + resetPage: '페이지 재설정', + mark: '위치 표시', + unmark: '표시 해제', + name: '이름 헥스', + settings: '설정', + pageSettings: '페이지 설정', + status: '상태', + rescan: '다시 스캔', + calibrate: '교정', + calibrateReset: '교정 재설정', + help: '돕다', + change: '변화', + menu: '메뉴', + clearOverrides: '재정의 지우기', + confirmReset: '예, 모든 16진수를 제거합니다.', + }, + prompts: { + name: '위치 이름(지우려면 비워 두세요)', + }, + values: { + on: '~에', + off: '끄다', + none: '없음', + hexLayer: { + auto: '자동(사용 가능한 경우 전경)', + foreground: '전경 레이어', + objects: '토큰 레이어', + }, + revealBy: { + players: '플레이어 토큰', + characters: '캐릭터 토큰', + all: '모든 토큰', + }, + revealMode: { + clear: '분명한', + glimpse: '일견', + }, + announce: { + all: '모든 사람', + gm: 'GM 전용', + off: '끄다', + }, + orientation: { + vertical: '16진수(V)', + horizontal: '16진수(H)', + }, + fillKind: { + fill: '채우다', + fillInverse: '역 채우기', + conceal: '숨기다', + }, + }, + settings: { + language: { + label: '언어', + desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', + }, + hexLayer: { + label: '육각 레이어', + desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + }, + fillColor: { + label: '채우기 색상', + desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + }, + strokeColor: { + label: '테두리 색상', + desc: '새로운 육각형의 윤곽선 색상입니다.', + }, + labelColor: { + label: '라벨 색상', + desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + }, + glimpseColor: { + label: '미리보기 색상', + desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + }, + strokeWidth: { + label: '테두리 너비', + desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', + }, + maxDistance: { + label: '16진수 공개 거리', + desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', + }, + revealDistance: { + label: '시거리', + desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + }, + lineOfSight: { + label: '시선', + desc: '켜져 있으면 헥스와 토큰 사이에 가려진 헥스가 없는 경우에만 헥스가 드러납니다.', + }, + revealPath: { + label: '경로를 따라 표시', + desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', + }, + revealBy: { + label: '공개되는 토큰', + desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + }, + revealMode: { + label: '공개 모드', + desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + }, + announce: { + label: '발견 발표', + desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', + }, + pingDiscoveries: { + label: '핑 발견', + desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', + }, + hideCoveredTokens: { + label: '적용 토큰 숨기기', + desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + }, + }, + status: { + engine: '게임 엔진', + grid: '그리드', + layer: '육각층', + hexes: '헥스', + named: '명명된 헥스', + icons: '위치 토큰', + glimpsed: '살짝 엿본 육각형', + pending: '채우기를 기다리는 위치', + calibrated: '교정됨', + overrides: '페이지 재정의', + undo: '실행 취소 가능', + }, + messages: { + filled: + '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', + revealed: '공개된 헥스: {count}.', + revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + confirmReset: + '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거된 16진수: {count}.', + undone: + '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + named: '"{name}"이라는 헥스: {count}.', + unnamed: '지워진 이름: {count}.', + marked: + '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + unmarked: '더 이상 위치가 아닌 토큰: {count}.', + settingChanged: '{setting}이(가) {value}로 설정되었습니다.', + rescanned: + '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + calibrated: + '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + calibrationReset: + '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', + migrated: + 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + pruned: + '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', + readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + }, + warnings: { + foregroundUnavailable: + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', + someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + }, + errors: { + noPage: '작업할 페이지를 찾을 수 없습니다.', + notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', + emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', + nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', + nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + noTokens: '먼저 하나 이상의 토큰을 선택하세요.', + noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', + nothingToUndo: '실행 취소할 채우기가 없습니다.', + unknownCommand: '알 수 없는 명령: {command}', + unknownSetting: '알 수 없는 설정: {key}', + unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', + invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', + calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', + unexpected: '문제가 발생했습니다: {message}', + }, + hints: { + noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', + notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + noPolygons: + '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', + emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', + tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', + noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + calibrateNeedsTokens: + '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + calibrateFailed: + '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + unexpected: '세부정보는 API 콘솔 로그에 있습니다.', + }, + help: { + menu: '메뉴를 보여주세요.', + fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', + undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', + reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', + resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', + mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', + unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', + set: '설정을 변경하거나 모든 설정을 표시합니다.', + pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', + pageClear: '현재 페이지의 재정의를 제거합니다.', + rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', + calibrate: + '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + calibrateReset: '현재 페이지의 보정을 제거합니다.', + status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + help: '이 목록을 보여주세요.', + handout: '전체 지침은 "{name}" 유인물에 있습니다.', + }, + deck: { + subtitle: '커맨드 덱', + drawDesc: + '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + revealDesc: + '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + locationsDesc: + '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', + footer: '전체 지침은 "{help}" 유인물을 참조하세요.', + }, + handout: { + versionLabel: '버전', + subtitle: 'Roll20의 16진수 탐색', + footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', + overview: { + heading: '개요', + body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + demo: '짧은 데모 보기(버전 1부터)', + }, + quickStart: { + heading: '빠른 시작', + steps: [ + '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', + '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', + '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + ], + }, + commands: { + heading: '명령', + intro: + 'GM만이 이 명령을 사용할 수 있습니다. 대부분은 선택한 개체에 작용합니다. 나머지는 현재 보고 있는 페이지에서 수행됩니다.', + colCommand: '명령', + colDesc: '기능', + }, + revealing: { + heading: '공개 작동 방식', + points: [ + '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', + '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', + 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', + 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + ], + }, + locations: { + heading: '명명된 육각형 및 위치', + points: [ + 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', + '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', + 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', + '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + ], + }, + settings: { + heading: '설정', + intro: + '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + colKey: '열쇠', + colName: '환경', + colDesc: '설명', + perPage: '(페이지별로 설정 가능합니다.)', + }, + jumpgate: { + heading: '점프게이트와 레거시', + points: [ + 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', + 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', + 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', + ], + }, + upgrading: { + heading: '버전 1에서 업그레이드', + points: [ + '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', + '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', + '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + ], + colV1: '버전 1 명령', + colV2: '버전 2 명령', + }, + troubleshooting: { + heading: '문제 해결', + points: [ + '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', + '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', + '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', + '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', + ], + }, + languages: { + heading: '언어', + body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + }, + credits: { + heading: '크레딧', + original: '원본 모드 작성자:', + maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', + marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', + support: + '버그를 발견하거나 아이디어가 있는 경우 Roll20 Mod 포럼에 게시하거나 GitHub에서 문제를 열고 API 콘솔 로그의 메시지를 포함하세요.', + }, + }, + }; + + const TRANSLATION$7 = { + titles: { + ready: 'Heksploracja jest gotowa.', + settings: 'Ustawienia Heksploracji', + languages: 'Wybierz język', + pageSettings: 'Ustawienia strony: {page}', + status: 'Stan heksploracji: {page}', + help: 'Komendy Heksploracji', + confirm: 'Proszę potwierdzić', + }, + discovery: { + title: 'Lokalizacja odkryta', + }, + menu: { + draw: 'Rysować', + reveal: 'Odkryj i ukryj', + locations: 'Lokalizacje', + tools: 'Narzędzia', + layerInUse: 'Nowe heksy są rysowane na {layer}.', + pageSettingsHelp: + 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', + }, + buttons: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + undo: 'Cofnij wypełnienie', + reveal: 'Ujawnić', + conceal: 'Ukryć', + explore: 'Badać', + revealPage: 'Odkryj stronę', + resetPage: 'Zresetuj stronę', + mark: 'Zaznacz lokalizację', + unmark: 'Odznacz', + name: 'Imię Hex', + settings: 'Ustawienia', + pageSettings: 'Ustawienia strony', + status: 'Status', + rescan: 'Skanuj ponownie', + calibrate: 'Kalibrować', + calibrateReset: 'Zresetuj kalibrację', + help: 'Pomoc', + change: 'Zmiana', + menu: 'Menu', + clearOverrides: 'Wyczyść zastąpienia', + confirmReset: 'Tak, usuń wszystkie heksy', + }, + prompts: { + name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', + }, + values: { + on: 'NA', + off: 'Wyłączony', + none: 'Nic', + hexLayer: { + auto: 'Auto (pierwszy plan, jeśli jest dostępny)', + foreground: 'warstwa pierwszego planu', + objects: 'warstwa tokenów', + }, + revealBy: { + players: 'Żetony graczy', + characters: 'Żetony postaci', + all: 'Wszystkie tokeny', + }, + revealMode: { + clear: 'Jasne', + glimpse: 'Dojrzeć', + }, + announce: { + all: 'Wszyscy', + gm: "Tylko GM'a", + off: 'Wyłączony', + }, + orientation: { + vertical: 'Sześciokąt (V)', + horizontal: 'Sześciokąt (H)', + }, + fillKind: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + conceal: 'Ukryć', + }, + }, + settings: { + language: { + label: 'Język', + desc: 'Język menu, komunikatów i materiałów informacyjnych.', + }, + hexLayer: { + label: 'Warstwa szesnastkowa', + desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + }, + fillColor: { + label: 'Kolor wypełnienia', + desc: 'Kolor nowych heksów. Użyj rgba() dla przezroczystych heksów, na przykład rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kolor obramowania', + desc: 'Kolor konturu nowych heksów.', + }, + labelColor: { + label: 'Kolor etykiety', + desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + }, + glimpseColor: { + label: 'Kolor przebłysku', + desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + }, + strokeWidth: { + label: 'Szerokość obramowania', + desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', + }, + maxDistance: { + label: 'Odległość ujawnienia heksadecymalnego', + desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', + }, + revealDistance: { + label: 'Odległość wzroku', + desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', + }, + lineOfSight: { + label: 'Linia wzroku', + desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', + }, + revealPath: { + label: 'Odkryj wzdłuż ścieżki', + desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + }, + revealBy: { + label: 'Żetony, które ujawniają', + desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', + }, + revealMode: { + label: 'Tryb ujawnienia', + desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + }, + announce: { + label: 'Ogłoś odkrycia', + desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', + }, + pingDiscoveries: { + label: 'Odkrycia pingowe', + desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', + }, + hideCoveredTokens: { + label: 'Ukryj zakryte tokeny', + desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', + }, + }, + status: { + engine: 'Silnik gry', + grid: 'Siatka', + layer: 'Warstwa sześciokątna', + hexes: 'Heksy', + named: 'Nazwane heksy', + icons: 'Żetony lokalizacji', + glimpsed: 'Prześwietlone heksy', + pending: 'Lokalizacje oczekujące na zapełnienie', + calibrated: 'Kalibrowane', + overrides: 'Zastąpienia strony', + undo: 'Cofnij dostępne', + }, + messages: { + filled: + 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + revealed: 'Ujawnione heksy: {count}.', + revealedPage: 'Każdy odkryty heks na stronie ({count}).', + confirmReset: + 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', + resetPage: 'Heksy usunięte ze strony: {count}.', + undone: + 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + named: 'Heksy o nazwie „{name}”: {count}.', + unnamed: 'Nazwy zostały usunięte: {count}.', + marked: + 'Lokalizacje ukryte na istniejących heksach: {attached}. Czekam na następne wypełnienie, które je obejmuje: {pending}.', + unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', + settingChanged: '{setting} ustawiony na {value}.', + rescanned: + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + calibrated: + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + calibrationReset: + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', + migrated: + 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + pruned: + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', + readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + }, + warnings: { + foregroundUnavailable: + 'Ta gra nie obsługuje rysowania na warstwie pierwszego planu, więc heksy zostały narysowane na warstwie żetonów.', + someFailed: + 'Heksy, których nie można narysować: {count}. Aby uzyskać szczegółowe informacje, sprawdź konsolę API.', + }, + errors: { + noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', + notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', + emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', + nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', + nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', + noTokens: 'Najpierw wybierz jeden lub więcej tokenów.', + noHexes: 'Najpierw wybierz jeden lub więcej heksów (lub żetonów stojących na heksach).', + nothingToUndo: 'Nie ma wypełnienia, które można cofnąć.', + unknownCommand: 'Nieznane polecenie: {command}', + unknownSetting: 'Nieznane ustawienie: {key}', + unknownPageSetting: 'Ustawienia, które można ustawić na stronie: {keys}', + invalidValue: '„{value}” nie jest prawidłową wartością dla {key}.', + calibrateNeedsTokens: 'Wybierz jeden lub dwa żetony przyciągnięte do środków heksów.', + calibrateFailed: 'Tych tokenów nie można używać do kalibracji.', + unexpected: 'Coś poszło nie tak: {message}', + }, + hints: { + noPage: 'Otwórz stronę, nad którą chcesz pracować, lub wybierz coś na niej.', + notHex: 'Ustaw siatkę strony na Hex (V) lub Hex (H) w Ustawieniach strony.', + noPolygons: + 'Narysuj wielokąt, prostokąt, elipsę lub odręczny kształt wokół obszaru, zaznacz go i spróbuj ponownie.', + emptyArea: 'Narysuj większy kształt lub sprawdź ustawienia siatki strony.', + tooMany: 'Wypełnij mniejszy obszar lub podziel obszar na kilka kształtów.', + noHexes: + 'Heksy znajdują się na pierwszym planie lub w warstwie żetonów; przejdź do tej warstwy, aby je wybrać.', + unknownCommand: 'Wpisz !hexploration help, aby wyświetlić listę poleceń.', + unknownSetting: 'Wpisz !hexploration set, aby zobaczyć wszystkie ustawienia.', + calibrateNeedsTokens: + 'Przyciągnij żeton do środka heksa i wybierz go. Wybierz drugi żeton przyciągnięty do sąsiedniego heksu w tym samym rzędzie (Hex V) lub kolumnie (Hex H), aby również skorygować rozmiar heksa.', + calibrateFailed: + 'Dwa żetony muszą znajdować się w tym samym rzędzie (Hex V) lub w tej samej kolumnie (Hex H), w odległości co najmniej jednego heksa od siebie.', + unexpected: 'Szczegóły znajdują się w dzienniku konsoli API.', + }, + help: { + menu: 'Pokaż menu.', + fill: 'Zakryj wybrane narysowane kształty heksami.', + fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', + undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', + revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', + conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', + explore: 'Odsłoń wokół wybranych żetonów tak, jakby właśnie się tam przesunęły.', + resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', + name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', + mark: 'Zamień wybrane żetony w ukryte lokalizacje.', + unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', + pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', + pageClear: 'Usuń zastąpienia bieżącej strony.', + rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + calibrate: + 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', + calibrateReset: 'Usuń kalibrację bieżącej strony.', + status: 'Pokaż, co Heexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + help: 'Pokaż tę listę.', + handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', + }, + deck: { + subtitle: 'Pokład dowodzenia', + drawDesc: + 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', + revealDesc: + 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + locationsDesc: + 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', + toolsDesc: + 'Ustawienia, nadpisania stron, status, ponowne skanowanie skopiowanych stron i kalibracja siatki.', + footer: 'Pełne instrukcje znajdziesz w ulotce „{help}”.', + }, + handout: { + versionLabel: 'Wersja', + subtitle: 'Eksploracja heks po heksie dla Roll20', + footer: + 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + overview: { + heading: 'Przegląd', + body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (od wersji 1)', + }, + quickStart: { + heading: 'Szybki start', + steps: [ + 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', + 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', + 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', + 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + ], + }, + commands: { + heading: 'Polecenia', + intro: + 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', + colCommand: 'Rozkaz', + colDesc: 'Co to robi', + }, + revealing: { + heading: 'Jak działa odkrywanie', + points: [ + 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', + 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', + 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', + 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + ], + }, + locations: { + heading: 'Nazwane heksy i lokalizacje', + points: [ + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', + 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', + 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + ], + }, + settings: { + heading: 'Ustawienia', + intro: + 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', + colKey: 'Klawisz', + colName: 'Ustawienie', + colDesc: 'Opis', + perPage: '(Można ustawić na stronę.)', + }, + jumpgate: { + heading: 'Jumpgate i Dziedzictwo', + points: [ + 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', + 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + ], + }, + upgrading: { + heading: 'Aktualizacja z wersji 1', + points: [ + 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', + 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', + 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', + 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + ], + colV1: 'Polecenie wersji 1', + colV2: 'Polecenie wersji 2', + }, + troubleshooting: { + heading: 'Rozwiązywanie problemów', + points: [ + 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', + 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', + 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', + ], + }, + languages: { + heading: 'Języki', + body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + }, + credits: { + heading: 'Kredyty', + original: 'Oryginalny mod autorstwa', + maintainer: 'Wersja 2 obsługiwana przez', + marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', + support: + 'Jeśli znajdziesz błąd lub masz pomysł, opublikuj post na forum Roll20 Mod lub otwórz problem w GitHub i dołącz wszelkie komunikaty z dziennika konsoli API.', + }, + }, + }; + + const TRANSLATION$6 = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Definições da página: {page}', + status: 'Estado de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + pageSettingsHelp: + 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Estatuto', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixar em branco para limpar)', + }, + values: { + on: 'Em', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Relance', + }, + announce: { + all: 'Toda a gente', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Utilize rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do percurso', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Rede', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Fichas de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais a aguardar preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', + unmarked: 'Tokens que já não são locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + calibrated: + 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não utiliza uma grelha hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione primeiro um ou mais tokens.', + noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', + nothingToUndo: 'Não há enchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + unexpected: 'Algo correu mal: {message}', + }, + hints: { + noPage: 'Abra a página na qual pretende trabalhar ou selecione algo da mesma.', + notHex: 'Defina a grelha da página para Hex (V) ou Hex (H) nas Definições da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre à volta da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', + tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + unknownCommand: 'Introduza !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as definições.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log da consola da API.', + }, + help: { + menu: 'Mostre o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma definição ou mostre todas as definições.', + pageSet: 'Substituir uma configuração de revelação apenas na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + locationsDesc: + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + footer: 'Consulte o folheto "{help}" para obter as instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Utilize o folheto "{deck}" para controlos de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Apenas os GMs podem usar estes comandos. A maioria atua sobre os objetos selecionados; o resto atua na página que está a visualizar.', + colCommand: 'Comando', + colDesc: 'O que faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + colKey: 'Chave', + colName: 'Definição', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualização da versão 1', + points: [ + 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', + 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versão 2 mantida pela', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', + }, + }, + }; + + const TRANSLATION$5 = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Configurações da página: {page}', + status: 'Status de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Empate', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + pageSettingsHelp: + 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Status', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixe em branco para limpar)', + }, + values: { + on: 'Sobre', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Todos', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Linguagem', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Use rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do caminho', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras acima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm seu nome, barras e auras visíveis ao jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grade', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Tokens de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais aguardando preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos chamados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + unmarked: 'Tokens que não são mais locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + calibrated: + 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não usa uma grade hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione um ou mais tokens primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + nothingToUndo: 'Não há preenchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + unexpected: 'Algo deu errado: {message}', + }, + hints: { + noPage: 'Abra a página na qual deseja trabalhar ou selecione algo nela.', + notHex: 'Defina a grade da página como Hex (V) ou Hex (H) nas Configurações da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre ao redor da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', + tooMany: 'Preencha uma área menor ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + unknownCommand: 'Digite !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as configurações.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log do console da API.', + }, + help: { + menu: 'Mostre o cardápio.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma configuração ou mostre todas as configurações.', + pageSet: 'Substituir uma configuração de revelação somente na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + locationsDesc: + 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + footer: 'Consulte o folheto "{help}" para obter instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Use o folheto "{deck}" para controles de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Somente GMs podem usar esses comandos. A maioria atua nos objetos selecionados; o resto atua na página que você está visualizando.', + colCommand: 'Comando', + colDesc: 'O que isso faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + colKey: 'Chave', + colName: 'Contexto', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualizando da versão 1', + points: [ + 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', + 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original por', + maintainer: 'Versão 2 mantida por', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se você encontrar um bug ou tiver uma ideia, poste no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do log do console da API.', + }, + }, + }; + + const TRANSLATION$4 = { + titles: { + ready: 'Геразведка готова.', + settings: 'Настройки Hexploration', + languages: 'Выберите язык', + pageSettings: 'Настройки страницы: {page}', + status: 'Статус гексоразведки: {page}', + help: 'Команды гексоразведки', + confirm: 'Пожалуйста, подтвердите', + }, + discovery: { + title: 'Местоположение обнаружено', + }, + menu: { + draw: 'Рисовать', + reveal: 'Показать и скрыть', + locations: 'Локации', + tools: 'Инструменты', + layerInUse: 'Новые гексы рисуются на {layer}.', + pageSettingsHelp: + 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', + }, + buttons: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + undo: 'Отменить заливку', + reveal: 'Раскрывать', + conceal: 'Скрыть', + explore: 'Исследовать', + revealPage: 'Открыть страницу', + resetPage: 'Сбросить страницу', + mark: 'Отметить местоположение', + unmark: 'Снять отметку', + name: 'Шестнадцатеричное имя', + settings: 'Настройки', + pageSettings: 'Настройки страницы', + status: 'Статус', + rescan: 'Повторное сканирование', + calibrate: 'Калибровка', + calibrateReset: 'Сброс калибровки', + help: 'Помощь', + change: 'Изменять', + menu: 'Меню', + clearOverrides: 'Очистить переопределения', + confirmReset: 'Да, удалить все шестигранники', + }, + prompts: { + name: 'Название местоположения (оставьте пустым, чтобы очистить)', + }, + values: { + on: 'На', + off: 'Выключенный', + none: 'Никто', + hexLayer: { + auto: 'Авто (на переднем плане, если доступно)', + foreground: 'передний слой', + objects: 'слой токенов', + }, + revealBy: { + players: 'Жетоны игроков', + characters: 'Жетоны персонажей', + all: 'Все токены', + }, + revealMode: { + clear: 'Прозрачный', + glimpse: 'Случайно заметить', + }, + announce: { + all: 'Каждый', + gm: 'только ГМ', + off: 'Выключенный', + }, + orientation: { + vertical: 'Шестигранник (В)', + horizontal: 'Шестигранник (H)', + }, + fillKind: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + conceal: 'Скрыть', + }, + }, + settings: { + language: { + label: 'Язык', + desc: 'Язык меню, сообщений и раздаточных материалов.', + }, + hexLayer: { + label: 'Шестнадцатеричный слой', + desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + }, + fillColor: { + label: 'Цвет заливки', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Цвет границы', + desc: 'Цвет контура новых гексов.', + }, + labelColor: { + label: 'Цвет этикетки', + desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + }, + glimpseColor: { + label: 'Взгляд цвета', + desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + }, + strokeWidth: { + label: 'Ширина границы', + desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + }, + maxDistance: { + label: 'Расстояние раскрытия шестигранника', + desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', + }, + revealDistance: { + label: 'Расстояние обзора', + desc: 'Сколько гексов вокруг движущегося жетона обнаружено (от 0 до 20). 0 показывает только те гексы, через которые проходит фишка.', + }, + lineOfSight: { + label: 'Линия видимости', + desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', + }, + revealPath: { + label: 'Показать вдоль пути', + desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', + }, + revealBy: { + label: 'Жетоны, которые раскрывают', + desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', + }, + revealMode: { + label: 'Режим раскрытия', + desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + }, + announce: { + label: 'Объявлять об открытиях', + desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', + }, + pingDiscoveries: { + label: 'Пинг-открытия', + desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + }, + hideCoveredTokens: { + label: 'Скрыть покрытые токены', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + }, + }, + status: { + engine: 'Игровой движок', + grid: 'Сетка', + layer: 'Шестнадцатеричный слой', + hexes: 'шестиугольники', + named: 'Именованные шестигранники', + icons: 'Жетоны местоположения', + glimpsed: 'Замеченные гексы', + pending: 'Места, ожидающие заполнения', + calibrated: 'Калиброванный', + overrides: 'Переопределения страниц', + undo: 'Отмена доступна', + }, + messages: { + filled: + 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', + revealed: 'Обнаружены гексы: {count}.', + revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + confirmReset: + 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + resetPage: 'Со страницы удалены шестигранники: {count}.', + undone: + 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Шестигранники с именем "{name}": {count}.', + unnamed: 'Имена удалены: {count}.', + marked: + 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', + unmarked: 'Токены, которые больше не являются локациями: {count}.', + settingChanged: 'Для {setting} установлено значение {value}.', + rescanned: + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + calibrated: + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + calibrationReset: + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', + migrated: + 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + pruned: + 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + readyHint: + 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + }, + warnings: { + foregroundUnavailable: + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + someFailed: + 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', + }, + errors: { + noPage: 'Не удалось найти страницу для работы.', + notHex: 'На этой странице не используется шестигранная сетка.', + noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', + emptyArea: 'Выбранная область не содержит шестигранных центров.', + tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', + nothingToReveal: + 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + noTokens: 'Сначала выберите один или несколько жетонов.', + noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', + nothingToUndo: 'Нет заливки, которую можно было бы отменить.', + unknownCommand: 'Неизвестная команда: {command}', + unknownSetting: 'Неизвестная настройка: {key}.', + unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', + invalidValue: '«{value}» не является допустимым значением для {key}.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', + unexpected: 'Что-то пошло не так: {message}', + }, + hints: { + noPage: 'Откройте страницу, над которой хотите работать, или выберите что-нибудь на ней.', + notHex: 'Установите сетку страницы на Hex (V) или Hex (H) в настройках страницы.', + noPolygons: + 'Нарисуйте многоугольник, прямоугольник, эллипс или фигуру от руки вокруг области, выберите ее и повторите попытку.', + emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', + tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', + noHexes: + 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', + unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', + calibrateNeedsTokens: + 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + calibrateFailed: + 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + unexpected: 'Подробности в журнале консоли API.', + }, + help: { + menu: 'Покажите меню.', + fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', + undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', + revealPage: 'Раскройте каждый гекс на странице без объявлений.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', + explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', + mark: 'Превратите выбранные жетоны в скрытые локации.', + unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', + set: 'Измените настройку или отобразите все настройки.', + pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageClear: 'Удалить переопределения текущей страницы.', + rescan: + 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + calibrate: + 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + calibrateReset: 'Удалить калибровку текущей страницы.', + status: 'Покажите, что Hexploration знает о текущей странице.', + journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + help: 'Покажите этот список.', + handout: 'Полные инструкции приведены в раздаточном материале «{name}».', + }, + deck: { + subtitle: 'Командная колода', + drawDesc: + 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + revealDesc: + 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + locationsDesc: + 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', + toolsDesc: + 'Настройки, переопределение страниц, статус, повторное сканирование скопированных страниц и калибровка сетки.', + footer: 'Подробные инструкции см. в раздаточном материале «{help}».', + }, + handout: { + versionLabel: 'Версия', + subtitle: 'Шестнадцатеричное исследование для Roll20', + footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', + overview: { + heading: 'Обзор', + body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + demo: 'Посмотрите короткую демонстрацию (из версии 1)', + }, + quickStart: { + heading: 'Быстрый старт', + steps: [ + 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', + 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', + 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', + 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', + 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + ], + }, + commands: { + heading: 'Команды', + intro: + 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + colCommand: 'Команда', + colDesc: 'Что он делает', + }, + revealing: { + heading: 'Как работает выявление', + points: [ + 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', + 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', + 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', + 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', + 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + ], + }, + locations: { + heading: 'Именованные гексы и локации', + points: [ + 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', + 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', + 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', + 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + ], + }, + settings: { + heading: 'Настройки', + intro: + 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + colKey: 'Ключ', + colName: 'Параметр', + colDesc: 'Описание', + perPage: '(Можно установить для каждой страницы.)', + }, + jumpgate: { + heading: 'Джампгейт и Наследие', + points: [ + 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', + 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + ], + }, + upgrading: { + heading: 'Обновление с версии 1', + points: [ + 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', + 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', + 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + ], + colV1: 'Команда версии 1', + colV2: 'Команда версии 2', + }, + troubleshooting: { + heading: 'Поиск неисправностей', + points: [ + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', + 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', + 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', + 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', + ], + }, + languages: { + heading: 'Языки', + body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + }, + credits: { + heading: 'Кредиты', + original: 'Оригинальный мод от', + maintainer: 'Версия 2 поддерживается', + marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', + support: + 'Если вы обнаружили ошибку или у вас есть идея, напишите сообщение на форуме Roll20 Mod или откройте проблему на GitHub и включите все сообщения из журнала консоли API.', + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: 'La hexploración está lista.', + settings: 'Configuración de hexploración', + languages: 'Elige un idioma', + pageSettings: 'Configuración de página: {page}', + status: 'Estado de exploración: {page}', + help: 'Comandos de hexploración', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Ubicación descubierta', + }, + menu: { + draw: 'Dibujar', + reveal: 'Revelar y ocultar', + locations: 'Ubicaciones', + tools: 'Herramientas', + layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + pageSettingsHelp: + 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', + }, + buttons: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + undo: 'Deshacer relleno', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Restablecer página', + mark: 'Marcar ubicación', + unmark: 'Desmarcar', + name: 'Nombre hexadecimal', + settings: 'Ajustes', + pageSettings: 'Configuración de página', + status: 'Estado', + rescan: 'Volver a escanear', + calibrate: 'Calibrar', + calibrateReset: 'Restablecer calibración', + help: 'Ayuda', + change: 'Cambiar', + menu: 'Menú', + clearOverrides: 'Borrar anulaciones', + confirmReset: 'Sí, eliminar todos los hexágonos', + }, + prompts: { + name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', + }, + values: { + on: 'En', + off: 'Apagado', + none: 'Ninguno', + hexLayer: { + auto: 'Auto (primer plano si está disponible)', + foreground: 'capa de primer plano', + objects: 'capa de token', + }, + revealBy: { + players: 'fichas de jugador', + characters: 'Fichas de personaje', + all: 'Todas las fichas', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vistazo', + }, + announce: { + all: 'Todos', + gm: 'solo GM', + off: 'Apagado', + }, + orientation: { + vertical: 'Hexágono (V)', + horizontal: 'Hexagonal (H)', + }, + fillKind: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menús, mensajes y folletos.', + }, + hexLayer: { + label: 'Capa hexagonal', + desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', + }, + fillColor: { + label: 'Color de relleno', + desc: 'Color de nuevos hexágonos. Utilice rgba() para hexágonos transparentes, por ejemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color del borde', + desc: 'Color del contorno de nuevos hexágonos.', + }, + labelColor: { + label: 'Color de la etiqueta', + desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + }, + glimpseColor: { + label: 'Color de vislumbre', + desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + }, + strokeWidth: { + label: 'Ancho del borde', + desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', + }, + maxDistance: { + label: 'Distancia de revelación hexagonal', + desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', + }, + revealDistance: { + label: 'Distancia de visión', + desc: 'Cuántos hexágonos se revelan alrededor de una ficha en movimiento (0 a 20). 0 revela sólo los hexágonos por los que pasa la ficha.', + }, + lineOfSight: { + label: 'Línea de visión', + desc: 'Cuando está activado, un hexágono sólo se revela si no hay ningún hexágono cubierto entre él y la ficha.', + }, + revealPath: { + label: 'Revelar a lo largo del camino', + desc: 'Cuando está activado, se revela cada hexágono por el que pasa una ficha mientras es arrastrada (incluidos los puntos de ruta), no solo dónde se detiene.', + }, + revealBy: { + label: 'Fichas que revelan', + desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', + }, + revealMode: { + label: 'Modo revelar', + desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + }, + announce: { + label: 'Anunciar descubrimientos', + desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', + }, + pingDiscoveries: { + label: 'Descubrimientos de ping', + desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cubiertos', + desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + }, + }, + status: { + engine: 'motor de juego', + grid: 'Red', + layer: 'capa hexagonal', + hexes: 'Hexágonos', + named: 'Hexágonos con nombre', + icons: 'Fichas de ubicación', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Ubicaciones esperando ser llenadas', + calibrated: 'Calibrado', + overrides: 'Anulaciones de página', + undo: 'Deshacer disponible', + }, + messages: { + filled: + 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + revealed: 'Hexágonos revelados: {count}.', + revealedPage: 'Cada hexágono en la página revelado ({count}).', + confirmReset: + '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', + resetPage: 'Hexes eliminados de la página: {count}.', + undone: + 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nombres borrados: {count}.', + marked: + 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', + unmarked: 'Tokens que ya no son ubicaciones: {count}.', + settingChanged: '{setting} establecido en {value}.', + rescanned: + 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + calibrated: + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + calibrationReset: + 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', + migrated: + 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + pruned: + 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', + readyHint: + 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este juego no admite dibujar en la capa de primer plano, por lo que los hexágonos se dibujaron en la capa de fichas.', + someFailed: + 'Hexágonos que no se pudieron dibujar: {count}. Consulte la consola API para obtener más detalles.', + }, + errors: { + noPage: 'No se pudo encontrar la página para trabajar.', + notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', + emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', + nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', + nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', + noTokens: 'Seleccione uno o más tokens primero.', + noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', + nothingToUndo: 'No hay ningún relleno que deshacer.', + unknownCommand: 'Comando desconocido: {command}', + unknownSetting: 'Configuración desconocida: {key}', + unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', + invalidValue: '"{value}" no es un valor válido para {key}.', + calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', + unexpected: 'Algo salió mal: {message}', + }, + hints: { + noPage: 'Abra la página en la que desea trabajar o seleccione algo en ella.', + notHex: + 'Establezca la cuadrícula de la página en Hex (V) o Hex (H) en Configuración de página.', + noPolygons: + 'Dibuja un polígono, un rectángulo, una elipse o una forma a mano alzada alrededor del área, selecciónala y vuelve a intentarlo.', + emptyArea: + 'Dibuja una forma más grande o verifica la configuración de la cuadrícula de la página.', + tooMany: 'Rellene un área más pequeña o divida el área en varias formas.', + noHexes: + 'Los hexágonos están en primer plano o en la capa de fichas; cambie a esa capa para seleccionarlas.', + unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', + unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', + calibrateNeedsTokens: + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + calibrateFailed: + 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + unexpected: 'Los detalles se encuentran en el registro de la consola API.', + }, + help: { + menu: 'Mostrar el menú.', + fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', + fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', + undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + reveal: + 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', + revealPage: 'Revela cada hexágono de la página sin anuncios.', + conceal: + 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', + explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', + name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', + mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', + unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + set: 'Cambie una configuración o muestre todas las configuraciones.', + pageSet: 'Anula una configuración de revelación solo en la página actual.', + pageClear: 'Elimine las anulaciones de la página actual.', + rescan: + 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + calibrate: + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + calibrateReset: 'Elimina la calibración de la página actual.', + status: 'Muestra lo que Hexploration sabe sobre la página actual.', + journal: 'Reconstruya los folletos de Ayuda y Comando.', + help: 'Muestra esta lista.', + handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', + }, + deck: { + subtitle: 'Cubierta de mando', + drawDesc: + 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + revealDesc: + 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + locationsDesc: + 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', + toolsDesc: + 'Configuraciones, anulaciones de páginas, estado, volver a escanear páginas copiadas y calibrar la cuadrícula.', + footer: 'Consulte el folleto "{help}" para obtener instrucciones completas.', + }, + handout: { + versionLabel: 'Versión', + subtitle: 'Exploración hexágono por hexágono para Roll20', + footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', + overview: { + heading: 'Descripción general', + body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + demo: 'Vea una breve demostración (de la versión 1)', + }, + quickStart: { + heading: 'Inicio rápido', + steps: [ + 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', + 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', + 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Dominio', + colDesc: 'que hace', + }, + revealing: { + heading: 'Cómo funciona la revelación', + points: [ + 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', + 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + ], + }, + locations: { + heading: 'Hexágonos y ubicaciones con nombre', + points: [ + 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', + 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + ], + }, + settings: { + heading: 'Ajustes', + intro: + 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + colKey: 'Llave', + colName: 'Configuración', + colDesc: 'Descripción', + perPage: '(Se puede configurar por página).', + }, + jumpgate: { + heading: 'Jumpgate y legado', + points: [ + 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', + 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + ], + }, + upgrading: { + heading: 'Actualización desde la versión 1', + points: [ + 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', + 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', + 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + ], + colV1: 'Comando versión 1', + colV2: 'Comando versión 2', + }, + troubleshooting: { + heading: 'Solución de problemas', + points: [ + 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', + 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', + 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versión 2 mantenida por', + marketplace: 'Paquetes de arte de Ada en Roll20 Marketplace', + support: + 'Si encuentra un error o tiene una idea, publíquelo en el foro Roll20 Mod o abra un problema en GitHub e incluya cualquier mensaje del registro de la consola API.', + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'Hexploration är redo.', + settings: 'Heexploration Inställningar', + languages: 'Välj ett språk', + pageSettings: 'Sidinställningar: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandon', + confirm: 'Vänligen bekräfta', + }, + discovery: { + title: 'Plats upptäckt', + }, + menu: { + draw: 'Dra', + reveal: 'Avslöja och göm', + locations: 'Platser', + tools: 'Verktyg', + layerInUse: 'Nya sexkanter ritas på {layer}.', + pageSettingsHelp: + 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', + }, + buttons: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + undo: 'Ångra Fyll', + reveal: 'Avslöja', + conceal: 'Dölja', + explore: 'Utforska', + revealPage: 'Avslöja sidan', + resetPage: 'Återställ sida', + mark: 'Markera plats', + unmark: 'Avmarkera', + name: 'Namn Hex', + settings: 'Inställningar', + pageSettings: 'Sidinställningar', + status: 'Status', + rescan: 'Skanna igen', + calibrate: 'Kalibrera', + calibrateReset: 'Återställ kalibrering', + help: 'Hjälp', + change: 'Ändra', + menu: 'Meny', + clearOverrides: 'Rensa åsidosättningar', + confirmReset: 'Ja, ta bort alla hexar', + }, + prompts: { + name: 'Platsnamn (låt vara tomt för att rensa)', + }, + values: { + on: 'På', + off: 'Av', + none: 'Ingen', + hexLayer: { + auto: 'Auto (förgrund om tillgängligt)', + foreground: 'förgrundsskikt', + objects: 'symbollager', + }, + revealBy: { + players: 'Spelarpoletter', + characters: 'Karaktärspoletter', + all: 'Alla tokens', + }, + revealMode: { + clear: 'Rensa', + glimpse: 'Glimt', + }, + announce: { + all: 'Alla', + gm: 'Endast GM', + off: 'Av', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + conceal: 'Dölja', + }, + }, + settings: { + language: { + label: 'Språk', + desc: 'Språk för menyer, meddelanden och åhörarkopior.', + }, + hexLayer: { + label: 'Hexlager', + desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + }, + fillColor: { + label: 'Fyllningsfärg', + desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfärg', + desc: 'Färg på konturerna av nya sexkanter.', + }, + labelColor: { + label: 'Etikettfärg', + desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + }, + glimpseColor: { + label: 'Glimt färg', + desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + }, + strokeWidth: { + label: 'Kantbredd', + desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + }, + maxDistance: { + label: 'Hexavslöjande avstånd', + desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', + }, + revealDistance: { + label: 'Siktavstånd', + desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', + }, + lineOfSight: { + label: 'Synlinje', + desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', + }, + revealPath: { + label: 'Avslöja längs vägen', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + }, + revealBy: { + label: 'Tokens som avslöjar', + desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + }, + revealMode: { + label: 'Avslöjande läge', + desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + }, + announce: { + label: 'Tillkännage upptäckter', + desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', + }, + pingDiscoveries: { + label: 'Ping upptäckter', + desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', + }, + hideCoveredTokens: { + label: 'Dölj täckta polletter', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + }, + }, + status: { + engine: 'Spelmotor', + grid: 'Rutnät', + layer: 'Hexskikt', + hexes: 'Hex', + named: 'Namngivna hexar', + icons: 'Platsskyltar', + glimpsed: 'Glimmade hexar', + pending: 'Platser som väntar på fyllning', + calibrated: 'Kalibrerad', + overrides: 'Sida åsidosätter', + undo: 'Ångra tillgängligt', + }, + messages: { + filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', + revealed: 'Hexen avslöjade: {count}.', + revealedPage: 'Varje hex på sidan avslöjas ({count}).', + confirmReset: + 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexen har tagits bort från sidan: {count}.', + undone: + 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + named: 'Hex med namnet "{name}": {count}.', + unnamed: 'Namn raderade: {count}.', + marked: + 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + unmarked: 'Tokens som inte längre är platser: {count}.', + settingChanged: '{setting} inställd på {value}.', + rescanned: + 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + calibrated: + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + calibrationReset: + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + journalRebuilt: '"{help}" och "{deck}" har byggts om.', + migrated: + 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + pruned: + 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + readyHint: + 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', + someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + }, + errors: { + noPage: 'Kunde inte hitta sidan att arbeta på.', + notHex: 'Den här sidan använder inte ett hex-rutnät.', + noPolygons: 'Välj en eller flera ritade former att fylla.', + emptyArea: 'Det valda området innehåller inga hexa-center.', + tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', + nothingToConceal: 'Välj ritade former eller tokens att dölja.', + nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + noTokens: 'Välj först en eller flera tokens.', + noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + nothingToUndo: 'Det finns ingen fyllning att ångra.', + unknownCommand: 'Okänt kommando: {command}', + unknownSetting: 'Okänd inställning: {key}', + unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', + invalidValue: '"{value}" är inte ett giltigt värde för {key}.', + calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', + unexpected: 'Något gick fel: {message}', + }, + hints: { + noPage: 'Öppna sidan du vill arbeta på eller välj något på den.', + notHex: 'Ställ in sidrutnätet på Hex (V) eller Hex (H) i Sidinställningar.', + noPolygons: + 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', + emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', + tooMany: 'Fyll ett mindre område, eller dela området i flera former.', + noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + unknownCommand: 'Skriv !hexploration help för att lista kommandona.', + unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', + calibrateNeedsTokens: + 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', + calibrateFailed: + 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + unexpected: 'Detaljer finns i API-konsolloggen.', + }, + help: { + menu: 'Visa menyn.', + fill: 'Täck de utvalda ritade formerna med hex.', + fillInverse: 'Täck hela sidan utom inuti de valda formerna.', + undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', + reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', + revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', + resetPage: 'Ta bort varje hex på sidan (frågar först).', + name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + mark: 'Förvandla de valda tokens till dolda platser.', + unmark: 'Stoppa de valda tokens från att vara dolda platser.', + set: 'Ändra en inställning eller visa alla inställningar.', + pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', + pageClear: 'Ta bort den aktuella sidans åsidosättningar.', + rescan: + 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', + calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrateReset: 'Ta bort den aktuella sidans kalibrering.', + status: 'Visa vad Hexploration vet om den aktuella sidan.', + journal: 'Bygg om hjälp- och kommandodäcken.', + help: 'Visa den här listan.', + handout: 'Fullständiga instruktioner finns i "{name}" handout.', + }, + deck: { + subtitle: 'Kommandodäck', + drawDesc: + 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + revealDesc: + 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + locationsDesc: + 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + toolsDesc: + 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', + footer: 'Se "{help}"-handouten för fullständiga instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-utforskning för Roll20', + footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', + overview: { + heading: 'Översikt', + body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + demo: 'Se en kort demo (från version 1)', + }, + quickStart: { + heading: 'Snabbstart', + steps: [ + 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', + 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', + 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + ], + }, + commands: { + heading: 'Kommandon', + intro: + 'Endast GM:er kan använda dessa kommandon. De flesta agerar på de valda objekten; resten agerar på sidan du tittar på.', + colCommand: 'Kommando', + colDesc: 'Vad den gör', + }, + revealing: { + heading: 'Hur avslöjande fungerar', + points: [ + 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', + 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', + 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', + 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + ], + }, + locations: { + heading: 'Namngivna Hex och platser', + points: [ + 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', + 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', + 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', + 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + ], + }, + settings: { + heading: 'Inställningar', + intro: + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + colKey: 'Nyckel', + colName: 'Miljö', + colDesc: 'Beskrivning', + perPage: '(Kan ställas in per sida.)', + }, + jumpgate: { + heading: 'Jumpgate och Legacy', + points: [ + 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', + 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', + 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + ], + }, + upgrading: { + heading: 'Uppgraderar från version 1', + points: [ + 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', + 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', + 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + ], + colV1: 'Kommandot version 1', + colV2: 'Kommandot version 2', + }, + troubleshooting: { + heading: 'Felsökning', + points: [ + 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', + 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', + ], + }, + languages: { + heading: 'Språk', + body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + }, + credits: { + heading: 'Krediter', + original: 'Originalmod av', + maintainer: 'Version 2 underhålls av', + marketplace: 'Adas konstpaket på Roll20 Marketplace', + support: + 'Om du hittar en bugg eller har en idé, posta i Roll20 Mod-forumet eller öppna ett problem på GitHub och inkludera eventuella meddelanden från API-konsolloggen.', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Keşif hazır.', + settings: 'Keşif Ayarları', + languages: 'Bir Dil Seçin', + pageSettings: 'Sayfa Ayarları: {page}', + status: 'Keşif Durumu: {page}', + help: 'Keşif Komutları', + confirm: 'Lütfen Onaylayın', + }, + discovery: { + title: 'Konum Keşfedildi', + }, + menu: { + draw: 'Çizmek', + reveal: 'Göster ve Gizle', + locations: 'Konumlar', + tools: 'Aletler', + layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + pageSettingsHelp: + 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', + }, + buttons: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + undo: 'Doldurmayı Geri Al', + reveal: 'Ortaya çıkarmak', + conceal: 'Gizle', + explore: 'Keşfetmek', + revealPage: 'Sayfayı Göster', + resetPage: 'Sayfayı Sıfırla', + mark: 'Konumu İşaretle', + unmark: 'İşareti kaldır', + name: 'Ad Hex', + settings: 'Ayarlar', + pageSettings: 'Sayfa Ayarları', + status: 'Durum', + rescan: 'Yeniden tara', + calibrate: 'Kalibre et', + calibrateReset: 'Kalibrasyonu Sıfırla', + help: 'Yardım', + change: 'Değiştirmek', + menu: 'Menü', + clearOverrides: 'Geçersiz Kılmaları Temizle', + confirmReset: 'Evet, Tüm Altıgenleri Kaldır', + }, + prompts: { + name: 'Konum adı (temizlemek için boş bırakın)', + }, + values: { + on: 'Açık', + off: 'Kapalı', + none: 'Hiçbiri', + hexLayer: { + auto: 'Otomatik (varsa ön planda)', + foreground: 'ön plan katmanı', + objects: 'belirteç katmanı', + }, + revealBy: { + players: 'Oyuncu jetonları', + characters: 'Karakter belirteçleri', + all: 'Tüm jetonlar', + }, + revealMode: { + clear: 'Temizlemek', + glimpse: 'Kısa bakış', + }, + announce: { + all: 'Herkes', + gm: 'Yalnızca GM', + off: 'Kapalı', + }, + orientation: { + vertical: 'Altıgen (V)', + horizontal: 'Altıgen (H)', + }, + fillKind: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + conceal: 'Gizle', + }, + }, + settings: { + language: { + label: 'Dil', + desc: 'Menüler, mesajlar ve bildiriler için dil.', + }, + hexLayer: { + label: 'Altıgen Katman', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + }, + fillColor: { + label: 'Dolgu Rengi', + desc: 'Yeni altıgenlerin rengi. Şeffaf altıgenler için rgba() kullanın; örneğin rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kenarlık Rengi', + desc: 'Yeni altıgenlerin ana hatlarının rengi.', + }, + labelColor: { + label: 'Etiket Rengi', + desc: 'Adlandırılmış altıgenlerdeki yalnızca GM ad etiketlerinin rengi.', + }, + glimpseColor: { + label: 'Bakış Rengi', + desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + }, + strokeWidth: { + label: 'Kenar Genişliği', + desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', + }, + maxDistance: { + label: 'Hex Ortaya Çıkma Mesafesi', + desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', + }, + revealDistance: { + label: 'Görüş Mesafesi', + desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + }, + lineOfSight: { + label: 'Görüş Hattı', + desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', + }, + revealPath: { + label: 'Yol Boyunca Ortaya Çıkar', + desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + }, + revealBy: { + label: 'Ortaya Çıkan Tokenlar', + desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', + }, + revealMode: { + label: 'Ortaya Çıkarma Modu', + desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + }, + announce: { + label: 'Keşifleri Duyurun', + desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', + }, + pingDiscoveries: { + label: 'Ping Keşifleri', + desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + }, + hideCoveredTokens: { + label: 'Kapalı Jetonları Gizle', + desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + }, + }, + status: { + engine: 'Oyun motoru', + grid: 'Izgara', + layer: 'Altıgen katman', + hexes: 'Altıgenler', + named: 'Adlandırılmış altıgenler', + icons: 'Konum belirteçleri', + glimpsed: 'Kısa bir bakış altıgenler', + pending: 'Doldurulmayı bekleyen yerler', + calibrated: 'Kalibre edildi', + overrides: 'Sayfa geçersiz kılmaları', + undo: 'Geri alma seçeneği mevcut', + }, + messages: { + filled: + 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', + revealed: 'Büyüler ortaya çıktı: {count}.', + revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', + confirmReset: + '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + undone: + 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', + named: '"{name}" adlı altıgenler: {count}.', + unnamed: 'İsimler temizlendi: {count}.', + marked: + 'Mevcut altıgenlerde gizli konumlar: {attached}. Bunları kapsayan bir sonraki dolgu bekleniyor: {pending}.', + unmarked: 'Artık konum olmayan jetonlar: {count}.', + settingChanged: '{setting}, {value} olarak ayarlandı.', + rescanned: + 'Yeniden tarama tamamlandı. Tutulan: {kept}. Kabul edildi: {adopted}. Yeniden dosyalandı: {moved}. Eksik ve unutulmuş: {dropped}. Etiketler yeniden bağlandı: {labels}. Konum jetonları yeniden bağlandı: {icons}.', + calibrated: + 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + calibrationReset: + 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + migrated: + 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + pruned: + "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", + readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + }, + warnings: { + foregroundUnavailable: + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', + }, + errors: { + noPage: 'Üzerinde çalışılacak sayfa bulunamadı.', + notHex: 'Bu sayfada altıgen ızgara kullanılmamaktadır.', + noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', + emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', + tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', + noTokens: 'Önce bir veya daha fazla jeton seçin.', + noHexes: + 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', + nothingToUndo: 'Geri alınacak bir dolgu yok.', + unknownCommand: 'Bilinmeyen komut: {command}', + unknownSetting: 'Bilinmeyen ayar: {key}', + unknownPageSetting: 'Sayfa başına ayarlanabilen ayarlar: {keys}', + invalidValue: '"{value}", {key} için geçerli bir değer değil.', + calibrateNeedsTokens: 'Altıgen merkezlere tutturulmuş bir veya iki jeton seçin.', + calibrateFailed: 'Bu jetonlar kalibrasyon için kullanılamaz.', + unexpected: 'Bir şeyler ters gitti: {message}', + }, + hints: { + noPage: 'Üzerinde çalışmak istediğiniz sayfayı açın veya üzerinde bir şey seçin.', + notHex: "Sayfa Ayarları'nda sayfa ızgarasını Hex (V) veya Hex (H) olarak ayarlayın.", + noPolygons: + 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', + emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', + tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', + noHexes: + 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + unknownCommand: 'Komutları listelemek için !hexploration help yazın.', + unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', + calibrateNeedsTokens: + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + calibrateFailed: + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + unexpected: 'Ayrıntılar API konsolu günlüğündedir.', + }, + help: { + menu: 'Menüyü göster.', + fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', + fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', + undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + reveal: + 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', + conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', + explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', + resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', + name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + mark: 'Seçilen jetonları gizli konumlara dönüştürün.', + unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', + pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', + rescan: + 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + calibrate: + 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', + calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', + status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + help: 'Bu listeyi göster.', + handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', + }, + deck: { + subtitle: 'Komut Güvertesi', + drawDesc: + 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + revealDesc: + 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + locationsDesc: + 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + toolsDesc: + 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', + footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', + }, + handout: { + versionLabel: 'Sürüm', + subtitle: 'Roll20 için hex-hex keşif', + footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', + overview: { + heading: 'Genel Bakış', + body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + demo: "Kısa bir demo izleyin (versiyon 1'den)", + }, + quickStart: { + heading: 'Hızlı Başlangıç', + steps: [ + 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', + 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', + "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", + 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', + ], + }, + commands: { + heading: 'Komutlar', + intro: + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", + colCommand: 'Emretmek', + colDesc: 'Ne işe yarar', + }, + revealing: { + heading: 'Açığa Çıkarma Nasıl Çalışır?', + points: [ + 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', + 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', + 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + ], + }, + locations: { + heading: 'Adlandırılmış Altıgenler ve Konumlar', + points: [ + 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', + "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", + 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", + "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + ], + }, + settings: { + heading: 'Ayarlar', + intro: + '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + colKey: 'Anahtar', + colName: 'Ayar', + colDesc: 'Tanım', + perPage: '(Sayfa başına ayarlanabilir.)', + }, + jumpgate: { + heading: 'Jumpgate ve Eski', + points: [ + 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', + 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', + "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + ], + }, + upgrading: { + heading: "Sürüm 1'den yükseltme", + points: [ + "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", + 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', + 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + ], + colV1: 'Sürüm 1 komutu', + colV2: 'Sürüm 2 komutu', + }, + troubleshooting: { + heading: 'Sorun giderme', + points: [ + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', + "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", + 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', + ], + }, + languages: { + heading: 'Diller', + body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + }, + credits: { + heading: 'Kredi', + original: 'Orijinal mod', + maintainer: 'Versiyon 2 tarafından sürdürülen', + marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", + support: + "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration готовий.', + settings: 'Налаштування Hexploration', + languages: 'Виберіть мову', + pageSettings: 'Параметри сторінки: {page}', + status: 'Статус дослідження: {page}', + help: 'Команди Hexploration', + confirm: 'Будь ласка, підтвердьте', + }, + discovery: { + title: 'Розташування виявлено', + }, + menu: { + draw: 'малювати', + reveal: 'Відкрити і приховати', + locations: 'Розташування', + tools: 'Інструменти', + layerInUse: 'Нові гекси малюються на {layer}.', + pageSettingsHelp: + 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', + }, + buttons: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + undo: 'Скасувати заповнення', + reveal: 'Розкрити', + conceal: 'Приховати', + explore: 'Досліджуйте', + revealPage: 'Відкрити сторінку', + resetPage: 'Скинути сторінку', + mark: 'Позначте розташування', + unmark: 'Зняти позначку', + name: "Ім'я Hex", + settings: 'Налаштування', + pageSettings: 'Параметри сторінки', + status: 'Статус', + rescan: 'Повторне сканування', + calibrate: 'Відкалібрувати', + calibrateReset: 'Скинути калібрування', + help: 'Довідка', + change: 'Зміна', + menu: 'Меню', + clearOverrides: 'Очистити перевизначення', + confirmReset: 'Так, видалити всі гекси', + }, + prompts: { + name: 'Назва місця (залиште порожнім, щоб очистити)', + }, + values: { + on: 'Увімкнено', + off: 'Вимкнено', + none: 'Жодного', + hexLayer: { + auto: 'Автоматично (на передньому плані, якщо доступно)', + foreground: 'шар переднього плану', + objects: 'маркерний шар', + }, + revealBy: { + players: 'Жетони гравців', + characters: 'Символьні маркери', + all: 'Усі жетони', + }, + revealMode: { + clear: 'ясно', + glimpse: 'Поблиск', + }, + announce: { + all: 'Всі', + gm: 'Тільки GM', + off: 'Вимкнено', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + conceal: 'Приховати', + }, + }, + settings: { + language: { + label: 'Мова', + desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', + }, + hexLayer: { + label: 'Шістнадцятковий шар', + desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + }, + fillColor: { + label: 'Колір заливки', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Колір рамки', + desc: 'Колір контуру нових гексів.', + }, + labelColor: { + label: 'Колір етикетки', + desc: 'Колір написів імен лише для GM на іменованих гексах.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + }, + strokeWidth: { + label: 'Ширина кордону', + desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', + }, + maxDistance: { + label: 'Шестигранна відстань розкриття', + desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', + }, + revealDistance: { + label: 'Дистанція огляду', + desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', + }, + lineOfSight: { + label: 'Пряма видимість', + desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', + }, + revealPath: { + label: 'Показати уздовж шляху', + desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', + }, + revealBy: { + label: 'Жетони, які розкривають', + desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', + }, + revealMode: { + label: 'Режим виявлення', + desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + }, + announce: { + label: 'Оголосити відкриття', + desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + }, + pingDiscoveries: { + label: 'Ping відкриття', + desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + }, + hideCoveredTokens: { + label: 'Приховати закриті токени', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + }, + }, + status: { + engine: 'Ігровий двигун', + grid: 'Сітка', + layer: 'Шестигранний шар', + hexes: 'Гекси', + named: 'Іменовані гекси', + icons: 'Жетони розташування', + glimpsed: 'Помітені прокляття', + pending: 'Локації очікують на заповнення', + calibrated: 'Відкалібрований', + overrides: 'Перевизначення сторінок', + undo: 'Доступне скасування', + }, + messages: { + filled: + 'Заповнення завершено. Намальовані гекси: {created}. Рестайлінг: {restyled}. Приховані місця: {icons}.', + revealed: 'Розкрито гекси: {count}.', + revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', + confirmReset: + 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + resetPage: 'Зі сторінки видалено шестигранники: {count}.', + undone: + 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', + named: 'Гекси з назвою "{name}": {count}.', + unnamed: 'Імена видалено: {count}.', + marked: + 'Місця, приховані в існуючих гексах: {attached}. Очікування наступного заповнення, яке охопить їх: {pending}.', + unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', + settingChanged: '{setting} встановлено на {value}.', + rescanned: + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + calibrated: + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + calibrationReset: + 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', + migrated: + 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + pruned: + 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + readyHint: + 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + }, + warnings: { + foregroundUnavailable: + 'Ця гра не підтримує малювання на передньому шарі, тому гекси були намальовані на шарі жетонів.', + someFailed: + 'Гекси, які не вдалося намалювати: {count}. Перевірте консоль API для отримання деталей.', + }, + errors: { + noPage: 'Не вдалося знайти сторінку для роботи.', + notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', + emptyArea: 'Вибрана область не містить шестигранних центрів.', + tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', + nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', + nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + noTokens: 'Спочатку виберіть один або кілька токенів.', + noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', + nothingToUndo: 'Немає заповнення, яке можна скасувати.', + unknownCommand: 'Невідома команда: {command}', + unknownSetting: 'Невідоме налаштування: {key}', + unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', + invalidValue: '"{value}" не є дійсним значенням для {key}.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', + unexpected: 'Щось пішло не так: {message}', + }, + hints: { + noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', + notHex: + 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + noPolygons: + 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', + emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', + tooMany: 'Заповніть меншу область або розділіть її на кілька фігур.', + noHexes: + 'Гекси знаходяться на передньому плані або шарі жетонів; перейдіть на цей шар, щоб вибрати їх.', + unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', + unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', + calibrateNeedsTokens: + 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + calibrateFailed: + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + unexpected: 'Подробиці в журналі консолі API.', + }, + help: { + menu: 'Показати меню.', + fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', + undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', + reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', + revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', + resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', + name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', + mark: 'Перетворіть вибрані жетони на приховані місця.', + unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + set: 'Змінити налаштування або показати всі налаштування.', + pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageClear: 'Видаліть перевизначення поточної сторінки.', + rescan: + 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + calibrate: + 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + calibrateReset: 'Видалити калібрування поточної сторінки.', + status: 'Покажіть, що Hexploration знає про поточну сторінку.', + journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + help: 'Покажіть цей список.', + handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', + }, + deck: { + subtitle: 'Командна колода', + drawDesc: + 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + revealDesc: + 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + locationsDesc: + 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', + toolsDesc: + 'Налаштування, перевизначення сторінок, статус, повторне сканування скопійованих сторінок і калібрування сітки.', + footer: 'Перегляньте роздатковий матеріал "{help}", щоб отримати повні інструкції.', + }, + handout: { + versionLabel: 'Версія', + subtitle: 'Шістнадцяткове дослідження для Roll20', + footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', + overview: { + heading: 'Огляд', + body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + demo: 'Перегляньте коротку демонстрацію (з версії 1)', + }, + quickStart: { + heading: 'Швидкий старт', + steps: [ + 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', + 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', + 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', + 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', + 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + ], + }, + commands: { + heading: 'Команди', + intro: + "Тільки GM можуть використовувати ці команди. Більшість діють на обрані об'єкти; решта діють на сторінці, яку ви переглядаєте.", + colCommand: 'Команда', + colDesc: 'Що воно робить', + }, + revealing: { + heading: 'Як працює розкриття', + points: [ + 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', + 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', + 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', + 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', + 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + ], + }, + locations: { + heading: 'Іменовані гекси та локації', + points: [ + 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', + 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', + 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', + 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + ], + }, + settings: { + heading: 'Налаштування', + intro: + 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + colKey: 'ключ', + colName: 'Налаштування', + colDesc: 'опис', + perPage: '(Можна встановити на сторінку.)', + }, + jumpgate: { + heading: 'Jumpgate і Legacy', + points: [ + 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', + 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', + 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + ], + }, + upgrading: { + heading: 'Оновлення з версії 1', + points: [ + 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', + 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', + 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + ], + colV1: 'Команда версії 1', + colV2: 'Команда версії 2', + }, + troubleshooting: { + heading: 'Усунення несправностей', + points: [ + 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', + 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', + 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', + 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', + ], + }, + languages: { + heading: 'Мови', + body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + }, + credits: { + heading: 'Кредити', + original: 'Оригінальний мод від', + maintainer: 'Версія 2 підтримується', + marketplace: 'Художні набори Ади на Roll20 Marketplace', + support: + 'Якщо ви знайшли помилку або маєте ідею, опублікуйте на форумі Roll20 Mod або відкрийте проблему на GitHub і додайте будь-які повідомлення з журналу консолі API.', + }, + }, + }; const DEFAULT_LOCALE = 'en-US'; @@ -3573,30 +10286,30 @@ const HexplorationMod = (() => { SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); const TRANSLATIONS = { - af: TRANSLATION$4, - ca: TRANSLATION$3, - 'zh-TW': TRANSLATION$2, - cs: TRANSLATION$1, - da: TRANSLATION, - nl: localeNl, + af: TRANSLATION$m, + ca: TRANSLATION$l, + 'zh-TW': TRANSLATION$k, + cs: TRANSLATION$j, + da: TRANSLATION$i, + nl: TRANSLATION$h, 'en-US': localeEnUS, - fi: localeFi, - fr: localeFr, - de: localeDe, - el: localeEl, - he: localeHe, - hu: localeHu, - it: localeIt, - ja: localeJa, - ko: localeKo, - pl: localePl, - 'pt-PT': localePtPT, - 'pt-BR': localePtBR, - ru: localeRu, - es: localeEs, - sv: localeSv, - tr: localeTr, - uk: localeUk, + fi: TRANSLATION$g, + fr: TRANSLATION$f, + de: TRANSLATION$e, + el: TRANSLATION$d, + he: TRANSLATION$c, + hu: TRANSLATION$b, + it: TRANSLATION$a, + ja: TRANSLATION$9, + ko: TRANSLATION$8, + pl: TRANSLATION$7, + 'pt-PT': TRANSLATION$6, + 'pt-BR': TRANSLATION$5, + ru: TRANSLATION$4, + es: TRANSLATION$3, + sv: TRANSLATION$2, + tr: TRANSLATION$1, + uk: TRANSLATION, }; /** diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index 0c7a1fbc00..642b8477ec 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -1,370 +1,368 @@ const TRANSLATION = { titles: { - ready: "Heeksplorasie is gereed.", - settings: "Heksplorasie-instellings", + ready: 'Heeksplorasie is gereed.', + settings: 'Heksplorasie-instellings', languages: "Kies 'n taal", - pageSettings: "Bladsyinstellings: {page}", - status: "Heksplorasiestatus: {page}", - help: "Heksplorasie-opdragte", - confirm: "Bevestig asseblief", + pageSettings: 'Bladsyinstellings: {page}', + status: 'Heksplorasiestatus: {page}', + help: 'Heksplorasie-opdragte', + confirm: 'Bevestig asseblief', }, discovery: { - title: "Ligging ontdek", + title: 'Ligging ontdek', }, menu: { - draw: "Teken", - reveal: "Openbaar en versteek", - locations: "Liggings", - tools: "Gereedskap", - layerInUse: "Nuwe hekse word op die {layer} geteken.", + draw: 'Teken', + reveal: 'Openbaar en versteek', + locations: 'Liggings', + tools: 'Gereedskap', + layerInUse: 'Nuwe hekse word op die {layer} geteken.', pageSettingsHelp: - "Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.", + 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', }, buttons: { - fill: "Vul", - fillInverse: "Omgekeerde vul", - undo: "Ontdoen vul", - reveal: "Onthul", - conceal: "Versteek", - explore: "Verken", - revealPage: "Onthul bladsy", - resetPage: "Stel bladsy terug", - mark: "Merk ligging", - unmark: "Ontmerk", - name: "Noem Hex", - settings: "Instellings", - pageSettings: "Bladsy-instellings", - status: "Status", - rescan: "Skandeer weer", - calibrate: "Kalibreer", - calibrateReset: "Stel Kalibrasie terug", - help: "Help", - change: "Verander", - menu: "Spyskaart", - clearOverrides: "Vee oorskrywings uit", - confirmReset: "Ja, verwyder alle hekse", + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + undo: 'Ontdoen vul', + reveal: 'Onthul', + conceal: 'Versteek', + explore: 'Verken', + revealPage: 'Onthul bladsy', + resetPage: 'Stel bladsy terug', + mark: 'Merk ligging', + unmark: 'Ontmerk', + name: 'Noem Hex', + settings: 'Instellings', + pageSettings: 'Bladsy-instellings', + status: 'Status', + rescan: 'Skandeer weer', + calibrate: 'Kalibreer', + calibrateReset: 'Stel Kalibrasie terug', + help: 'Help', + change: 'Verander', + menu: 'Spyskaart', + clearOverrides: 'Vee oorskrywings uit', + confirmReset: 'Ja, verwyder alle hekse', }, prompts: { - name: "Liggingnaam (laat leeg om skoon te maak)", + name: 'Liggingnaam (laat leeg om skoon te maak)', }, values: { - on: "Aan", - off: "Af", - none: "Geen", + on: 'Aan', + off: 'Af', + none: 'Geen', hexLayer: { - auto: "Outo (voorgrond indien beskikbaar)", - foreground: "voorgrond laag", - objects: "tekenlaag", + auto: 'Outo (voorgrond indien beskikbaar)', + foreground: 'voorgrond laag', + objects: 'tekenlaag', }, revealBy: { - players: "Speler tokens", - characters: "Karaktertekens", - all: "Alle tekens", + players: 'Speler tokens', + characters: 'Karaktertekens', + all: 'Alle tekens', }, revealMode: { - clear: "Duidelik", - glimpse: "Glimpie", + clear: 'Duidelik', + glimpse: 'Glimpie', }, announce: { - all: "Almal", - gm: "Slegs GM", - off: "Af", + all: 'Almal', + gm: 'Slegs GM', + off: 'Af', }, orientation: { - vertical: "Heks (V)", - horizontal: "Heks (H)", + vertical: 'Heks (V)', + horizontal: 'Heks (H)', }, fillKind: { - fill: "Vul", - fillInverse: "Omgekeerde vul", - conceal: "Versteek", + fill: 'Vul', + fillInverse: 'Omgekeerde vul', + conceal: 'Versteek', }, }, settings: { language: { - label: "Taal", - desc: "Taal vir spyskaarte, boodskappe en uitdeelstukke.", + label: 'Taal', + desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', }, hexLayer: { - label: "Hex laag", - desc: "Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.", + label: 'Hex laag', + desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', }, fillColor: { - label: "Vul kleur", - desc: "Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).", + label: 'Vul kleur', + desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { - label: "Rand Kleur", - desc: "Kleur van die buitelyn van nuwe hekse.", + label: 'Rand Kleur', + desc: 'Kleur van die buitelyn van nuwe hekse.', }, labelColor: { - label: "Etiket Kleur", - desc: "Kleur van die GM-net naametikette op benoemde hekse.", + label: 'Etiket Kleur', + desc: 'Kleur van die GM-net naametikette op benoemde hekse.', }, glimpseColor: { - label: "Glimp kleur", + label: 'Glimp kleur', desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", }, strokeWidth: { - label: "Grens breedte", - desc: "Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).", + label: 'Grens breedte', + desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', }, maxDistance: { - label: "Hex Reveal Distance", + label: 'Hex Reveal Distance', desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", }, revealDistance: { - label: "Sigafstand", + label: 'Sigafstand', desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", }, lineOfSight: { - label: "Siglyn", + label: 'Siglyn', desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", }, revealPath: { - label: "Openbaar Langs Pad", + label: 'Openbaar Langs Pad', desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", }, revealBy: { - label: "Tekens wat openbaar", + label: 'Tekens wat openbaar', desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", }, revealMode: { - label: "Onthullingsmodus", + label: 'Onthullingsmodus', desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", }, announce: { - label: "Kondig ontdekkings aan", + label: 'Kondig ontdekkings aan', desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", }, pingDiscoveries: { - label: "Ping Ontdekkings", + label: 'Ping Ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, + hideCoveredTokens: { + label: 'Versteek bedekte tekens', + desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + }, }, status: { - engine: "Spel enjin", - grid: "Rooster", - layer: "Hex laag", - hexes: "Hekse", - named: "Benoemde hekse", - icons: "Liggingtekens", - glimpsed: "Geskimpte hekkies", + engine: 'Spel enjin', + grid: 'Rooster', + layer: 'Hex laag', + hexes: 'Hekse', + named: 'Benoemde hekse', + icons: 'Liggingtekens', + glimpsed: 'Geskimpte hekkies', pending: "Liggings wat wag vir 'n vulling", - calibrated: "Gekalibreer", - overrides: "Bladsy ignoreer", - undo: "Ontdoen beskikbaar", + calibrated: 'Gekalibreer', + overrides: 'Bladsy ignoreer', + undo: 'Ontdoen beskikbaar', }, messages: { filled: - "Vul voltooi: {created} heks geteken, {restyled} herstileer, {icons} liggings versteek.", - revealed: "{count} hekkies geopenbaar.", - revealedPage: "Alle {count} hekse op die bladsy is geopenbaar.", + 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Hekse geopenbaar: {count}.', + revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', confirmReset: - 'Verwyder alle {count} hekse van "{page}"? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: "{count} hekse van die bladsy verwyder.", + 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Hekse verwyder van die bladsy: {count}.', undone: - "Laaste invulling is ongedaan gemaak: {removed} hekse is verwyder, {restored} herstileerde hekse is teruggestel.", - named: '{count} heksies genaamd "{name}".', - unnamed: "Naam verwyder van {count} hekse.", + 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', + named: 'Hekse genaamd "{name}": {count}.', + unnamed: 'Name skoongemaak: {count}.', marked: - "{attached} liggings versteek in bestaande hekkies; {pending} sal versteek word deur die volgende vul wat hulle bedek.", - unmarked: "{count} tekens is nie meer liggings nie.", - settingChanged: "{setting} gestel na {value}.", + 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', + unmarked: 'Tekens wat nie meer liggings is nie: {count}.', + settingChanged: '{setting} gestel na {value}.', rescanned: - "Herskandering voltooi: {kept} hekkies gehou, {adopted} aangeneem, {moved} herliasseer, {dropped} ontbrekende hekse vergete, {labels} etikette en __HEX_PLACEHOLDER's herskakel na.", + 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', calibrated: - "Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.", + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', calibrationReset: - "Kalibrasie verwyder. Herskandeer: {kept} behou, {moved} herliasseer, {adopted} aangeneem.", + 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", pruned: - "{dropped} gestoorde hekkies bestaan ​​nie meer nie en is vergeet. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.", + 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', readyHint: 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, warnings: { foregroundUnavailable: - "Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.", + 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', someFailed: - "{count} heks kon nie geteken word nie. Gaan die API-konsole na vir besonderhede.", + 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', }, errors: { - noPage: "Kon nie die bladsy vind om aan te werk nie.", + noPage: 'Kon nie die bladsy vind om aan te werk nie.', notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", - noPolygons: "Kies een of meer getekende vorms om te vul.", - emptyArea: "Die geselekteerde area bevat geen heksasiemiddels nie.", - tooMany: "Dit sal {count} hexes skep, wat te veel in een slag is.", - nothingToConceal: "Kies getekende vorms of tekens om te versteek.", - nothingToReveal: "Kies hekkies, getekende vorms of tekens om te openbaar.", - noTokens: "Kies eers een of meer tekens.", - noHexes: "Kies eers een of meer hekse (of tekens wat op hekse staan).", - nothingToUndo: "Daar is geen vul om ongedaan te maak nie.", - unknownCommand: "Onbekende opdrag: {command}", - unknownSetting: "Onbekende instelling: {key}", - unknownPageSetting: "Instellings wat per bladsy gestel kan word: {keys}", + noPolygons: 'Kies een of meer getekende vorms om te vul.', + emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', + tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', + nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', + noTokens: 'Kies eers een of meer tekens.', + noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', + unknownCommand: 'Onbekende opdrag: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', - calibrateNeedsTokens: - "Kies een of twee tokens wat aan heksende middelpunte geknip is.", - calibrateFailed: "Daardie tekens kan nie gebruik word om te kalibreer nie.", - unexpected: "Iets het verkeerd geloop: {message}", + calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', + calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + unexpected: 'Iets het verkeerd geloop: {message}', }, hints: { - noPage: "Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.", - notHex: - "Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.", + noPage: 'Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.', + notHex: 'Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.', noPolygons: "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", - tooMany: "Vul `n kleiner area, of verdeel die area in verskeie vorms.", - noHexes: - "Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.", - unknownCommand: "Tik !hexploration help om die opdragte te lys.", - unknownSetting: "Tik !hexploration set om elke instelling te sien.", + tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', + noHexes: 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + unknownCommand: 'Tik !hexploration help om die opdragte te lys.', + unknownSetting: 'Tik !hexploration set om elke instelling te sien.', calibrateNeedsTokens: "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", calibrateFailed: - "Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.", - unexpected: "Besonderhede is in die API-konsole-logboek.", + 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + unexpected: 'Besonderhede is in die API-konsole-logboek.', }, help: { - menu: "Wys die spyskaart.", - fill: "Bedek die geselekteerde getekende vorms met hekse.", - fillInverse: "Bedek die hele bladsy behalwe binne die geselekteerde vorms.", - undo: "Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.", - reveal: - "Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.", - revealPage: "Onthul elke heksie op die bladsy sonder aankondigings.", - conceal: - "Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.", - explore: - "Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.", - resetPage: "Verwyder elke heks op die bladsy (vra eers).", - name: "Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.", - mark: "Verander die geselekteerde tekens in versteekte liggings.", - unmark: "Stop dat die geselekteerde tokens versteekte liggings is.", + menu: 'Wys die spyskaart.', + fill: 'Bedek die geselekteerde getekende vorms met hekse.', + fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', + undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', + reveal: 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', + revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', + conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', + explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', + resetPage: 'Verwyder elke heks op die bladsy (vra eers).', + name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', + mark: 'Verander die geselekteerde tekens in versteekte liggings.', + unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', set: "Verander 'n instelling, of wys alle instellings.", pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", - pageClear: "Verwyder die huidige bladsy se ignorering.", + pageClear: 'Verwyder die huidige bladsy se ignorering.', rescan: "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", calibrate: - "Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.", - calibrateReset: "Verwyder die huidige bladsy se kalibrasie.", - status: "Wys wat Hexploration van die huidige bladsy weet.", - journal: "Herbou die hulp- en beveldek-uitdeelstukke.", - help: "Wys hierdie lys.", + 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', + status: 'Wys wat Hexploration van die huidige bladsy weet.', + journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + help: 'Wys hierdie lys.', handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', }, deck: { - subtitle: "Beveldek", - drawDesc: - "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + subtitle: 'Beveldek', + drawDesc: "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", revealDesc: - "Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.", + 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', locationsDesc: "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", toolsDesc: - "Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.", + 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', }, handout: { - versionLabel: "Weergawe", - subtitle: "Heks-vir-heks verkenning vir Roll20", + versionLabel: 'Weergawe', + subtitle: 'Heks-vir-heks verkenning vir Roll20', footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', overview: { - heading: "Oorsig", + heading: 'Oorsig', body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", }, quickStart: { - heading: "Vinnige Begin", + heading: 'Vinnige Begin', steps: [ "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", - "Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.", - "Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.", - "Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.", + 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', + 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', + 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", ], }, commands: { - heading: "Opdragte", + heading: 'Opdragte', intro: "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", - colCommand: "Bevel", - colDesc: "Wat dit doen", + colCommand: 'Bevel', + colDesc: 'Wat dit doen', }, revealing: { - heading: "Hoe onthulling werk", + heading: 'Hoe onthulling werk', points: [ - "Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.", + 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", - "Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.", + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { - heading: "Genoemde hekse en liggings", + heading: 'Genoemde hekse en liggings', points: [ "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", - "Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.", - "Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.", + 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", - "Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.", + 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, settings: { - heading: "Instellings", + heading: 'Instellings', intro: - "Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.", - colKey: "Sleutel", - colName: "Instelling", - colDesc: "Beskrywing", - perPage: "(Kan per bladsy gestel word.)", + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beskrywing', + perPage: '(Kan per bladsy gestel word.)', }, jumpgate: { - heading: "Jumpgate en Legacy", + heading: 'Jumpgate en Legacy', points: [ - "Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.", - "Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.", + 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', + 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", ], }, upgrading: { - heading: "Opgradering vanaf weergawe 1", + heading: 'Opgradering vanaf weergawe 1', points: [ "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", - "Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.", - "Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.", + 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", ], - colV1: "Weergawe 1 opdrag", - colV2: "Weergawe 2 opdrag", + colV1: 'Weergawe 1 opdrag', + colV2: 'Weergawe 2 opdrag', }, troubleshooting: { - heading: "Probleemoplossing", + heading: 'Probleemoplossing', points: [ "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", - "Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.", - "Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.", + 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', ], }, languages: { - heading: "Tale", + heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", }, credits: { - heading: "Krediete", - original: "Oorspronklike mod deur", - maintainer: "Weergawe 2 onderhou deur", - marketplace: "Ada se kunspakkies op die Roll20 Marketplace", + heading: 'Krediete', + original: 'Oorspronklike mod deur', + maintainer: 'Weergawe 2 onderhou deur', + marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', support: "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", }, diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index cd19ce55cf..b2b924e306 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -2,231 +2,231 @@ const TRANSLATION = { titles: { ready: "L'exploració està a punt.", settings: "Configuració d'exploració", - languages: "Trieu un idioma", - pageSettings: "Configuració de la pàgina: {page}", + languages: 'Trieu un idioma', + pageSettings: 'Configuració de la pàgina: {page}', status: "Estat de l'exploració: {page}", help: "Comandes d'exploració", - confirm: "Si us plau, confirmeu", + confirm: 'Si us plau, confirmeu', }, discovery: { - title: "Localització descoberta", + title: 'Localització descoberta', }, menu: { - draw: "Dibuixa", - reveal: "Revela i amaga", - locations: "Ubicacions", - tools: "Eines", + draw: 'Dibuixa', + reveal: 'Revela i amaga', + locations: 'Ubicacions', + tools: 'Eines', layerInUse: "S'estan dibuixant nous hexagones al {layer}.", pageSettingsHelp: "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", }, buttons: { - fill: "Omplir", - fillInverse: "Farciment invers", - undo: "Desfer el farciment", - reveal: "Revelar", - conceal: "Ocultar", - explore: "Explora", - revealPage: "Revela la pàgina", - resetPage: "Restableix la pàgina", - mark: "Marca la ubicació", - unmark: "Desmarca", - name: "Nom Hex", - settings: "Configuració", - pageSettings: "Configuració de la pàgina", - status: "Estat", - rescan: "Torna a escanejar", - calibrate: "Calibrar", - calibrateReset: "Restableix la calibració", - help: "Ajuda", - change: "Canviar", - menu: "Menú", - clearOverrides: "Esborra les substitucions", - confirmReset: "Sí, traieu tots els hexagones", + fill: 'Omplir', + fillInverse: 'Farciment invers', + undo: 'Desfer el farciment', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explora', + revealPage: 'Revela la pàgina', + resetPage: 'Restableix la pàgina', + mark: 'Marca la ubicació', + unmark: 'Desmarca', + name: 'Nom Hex', + settings: 'Configuració', + pageSettings: 'Configuració de la pàgina', + status: 'Estat', + rescan: 'Torna a escanejar', + calibrate: 'Calibrar', + calibrateReset: 'Restableix la calibració', + help: 'Ajuda', + change: 'Canviar', + menu: 'Menú', + clearOverrides: 'Esborra les substitucions', + confirmReset: 'Sí, traieu tots els hexagones', }, prompts: { - name: "Nom de la ubicació (deixeu en blanc per esborrar)", + name: 'Nom de la ubicació (deixeu en blanc per esborrar)', }, values: { - on: "Encès", - off: "Apagat", - none: "Cap", + on: 'Encès', + off: 'Apagat', + none: 'Cap', hexLayer: { - auto: "Automàtic (en primer pla si està disponible)", - foreground: "capa de primer pla", - objects: "capa de testimoni", + auto: 'Automàtic (en primer pla si està disponible)', + foreground: 'capa de primer pla', + objects: 'capa de testimoni', }, revealBy: { - players: "Fitxes de jugador", - characters: "Fitxes de personatges", - all: "Totes les fitxes", + players: 'Fitxes de jugador', + characters: 'Fitxes de personatges', + all: 'Totes les fitxes', }, revealMode: { - clear: "Clar", + clear: 'Clar', glimpse: "Un cop d'ull", }, announce: { - all: "Tothom", - gm: "Només GM", - off: "Apagat", + all: 'Tothom', + gm: 'Només GM', + off: 'Apagat', }, orientation: { - vertical: "Hexadecimal (V)", - horizontal: "Hex (H)", + vertical: 'Hexadecimal (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: "Omplir", - fillInverse: "Farciment invers", - conceal: "Ocultar", + fill: 'Omplir', + fillInverse: 'Farciment invers', + conceal: 'Ocultar', }, }, settings: { language: { - label: "Llengua", - desc: "Idioma per a menús, missatges i fullets.", + label: 'Llengua', + desc: 'Idioma per a menús, missatges i fullets.', }, hexLayer: { - label: "Capa hexagonal", + label: 'Capa hexagonal', desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", }, fillColor: { - label: "Color de farciment", - desc: "Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).", + label: 'Color de farciment', + desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', }, strokeColor: { - label: "Color de la vora", - desc: "Color del contorn dels nous hexagonals.", + label: 'Color de la vora', + desc: 'Color del contorn dels nous hexagonals.', }, labelColor: { label: "Color de l'etiqueta", - desc: "Color de les etiquetes de nom només de GM en hexadecims amb nom.", + desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', }, glimpseColor: { label: "Color d'ull", - desc: "Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.", + desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', }, strokeWidth: { - label: "Amplada de la vora", - desc: "Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).", + label: 'Amplada de la vora', + desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', }, maxDistance: { - label: "Distància de revelació hexagonal", + label: 'Distància de revelació hexagonal', desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", }, revealDistance: { - label: "Distància de visió", + label: 'Distància de visió', desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", }, lineOfSight: { - label: "Línia de visió", - desc: "Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.", + label: 'Línia de visió', + desc: 'Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.', }, revealPath: { - label: "Revela al llarg del camí", + label: 'Revela al llarg del camí', desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", }, revealBy: { - label: "Fitxes que revelen", - desc: "Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.", + label: 'Fitxes que revelen', + desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', }, revealMode: { - label: "Mode de revelació", + label: 'Mode de revelació', desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", }, announce: { - label: "Anunciar descobriments", - desc: "Qui veu el missatge de xat quan es descobreix una ubicació amb nom.", + label: 'Anunciar descobriments', + desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', }, pingDiscoveries: { - label: "Ping Descobriments", - desc: "Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.", + label: 'Ping Descobriments', + desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', + }, + hideCoveredTokens: { + label: 'Amaga les fitxes cobertes', + desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', }, }, status: { - engine: "Motor de joc", - grid: "Quadrícula", - layer: "Capa hexagonal", - hexes: "Hexes", - named: "Hexagones anomenats", + engine: 'Motor de joc', + grid: 'Quadrícula', + layer: 'Capa hexagonal', + hexes: 'Hexes', + named: 'Hexagones anomenats', icons: "Fitxes d'ubicació", - glimpsed: "Hexagones albirats", + glimpsed: 'Hexagones albirats', pending: "Ubicacions a l'espera d'omplir-se", - calibrated: "Calibrat", - overrides: "Anul·lació de la pàgina", - undo: "Desfer disponible", + calibrated: 'Calibrat', + overrides: 'Anul·lació de la pàgina', + undo: 'Desfer disponible', }, messages: { filled: - "Ompliment complet: {created} hexadecimals dibuixats, {restyled} redissenyats, {icons} ubicacions amagades.", - revealed: "{count} hexadecimals revelats.", - revealedPage: "S'han revelat tots els {count} hexadecificis de la pàgina.", + 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + revealed: 'Hexagones revelats: {count}.', + revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", confirmReset: - 'Vols suprimir tots els {count} hexadecimals de "{page}"? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: "{count} hexadecimals eliminats de la pàgina.", + 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', + resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', undone: - "Últim farciment desfet: {removed} hexadecimals eliminats, {restored} hexadecimals restaurats.", - named: '{count} hexadecimals anomenats "{name}".', - unnamed: "S'ha esborrat el nom de {count} hexadecimals.", + 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + named: 'Hexadecimals anomenats "{name}": {count}.', + unnamed: 'Noms esborrats: {count}.', marked: - "{attached} ubicacions amagades als hexàgons existents; {pending} s'amagarà pel següent farcit que els cobreixi.", - unmarked: "Les fitxes {count} ja no són ubicacions.", + 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "S'ha completat la tornada de l'exploració: {kept} hexadecimals conservats, {adopted} adoptat, {moved} tornat a arxivar, {dropped} hexadecimals que falten oblidats, __HEX_PLACEHOLDER_4_etiquetes_4__ S'han tornat a enllaçar {icons} fitxes d'ubicació.", + "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", calibrated: - "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: {kept} conservat, {moved} tornat a arxivar, {adopted} adoptat.", + "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", pruned: - "Els {dropped} desats ja no existeixen i s'han oblidat. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", readyHint: 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', }, warnings: { foregroundUnavailable: - "Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.", + 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', someFailed: - "No s'han pogut dibuixar {count} hexadecimals. Consulteu la consola de l'API per obtenir més informació.", + "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", - notHex: "Aquesta pàgina no utilitza una graella hexadecimal.", - noPolygons: "Seleccioneu una o més formes dibuixades per omplir.", + notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia {count} hexadecimals, que són massa d'una vegada.", - nothingToConceal: "Seleccioneu formes dibuixades o fitxes per ocultar.", - nothingToReveal: - "Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.", - noTokens: "Seleccioneu primer un o més fitxes.", - noHexes: - "Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).", - nothingToUndo: "No hi ha cap emplenament per desfer.", - unknownCommand: "Ordre desconeguda: {command}", - unknownSetting: "Configuració desconeguda: {key}", - unknownPageSetting: "Configuració que es pot establir per pàgina: {keys}", + tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', + nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer un o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToUndo: 'No hi ha cap emplenament per desfer.', + unknownCommand: 'Ordre desconeguda: {command}', + unknownSetting: 'Configuració desconeguda: {key}', + unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', invalidValue: '"{value}" no és un valor vàlid per a {key}.', - calibrateNeedsTokens: - "Seleccioneu una o dues fitxes encaixades als centres hexagonals.", - calibrateFailed: "Aquestes fitxes no es poden utilitzar per calibrar.", + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', unexpected: "S'ha produït un error: {message}", }, hints: { - noPage: - "Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.", + noPage: 'Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.', notHex: - "Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.", + 'Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.', noPolygons: "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", emptyArea: - "Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.", + 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", noHexes: - "Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.", - unknownCommand: "Escriviu !hexploration help per llistar les ordres.", - unknownSetting: "Escriviu !hexploration set per veure tots els paràmetres.", + 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', + unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', calibrateNeedsTokens: "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", calibrateFailed: @@ -234,87 +234,84 @@ const TRANSLATION = { unexpected: "Els detalls es troben al registre de la consola de l'API.", }, help: { - menu: "Mostra el menú.", - fill: "Cobriu les formes dibuixades seleccionades amb hexagonals.", - fillInverse: - "Cobriu tota la pàgina excepte dins de les formes seleccionades.", + menu: 'Mostra el menú.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", reveal: - "Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.", - revealPage: "Revela cada hexadecimal de la pàgina sense anuncis.", - conceal: - "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", - explore: - "Revela les fitxes seleccionades com si acabessin de moure's allà.", - resetPage: "Traieu tots els hexadecimals de la pàgina (demana primer).", - name: "Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.", - mark: "Converteix les fitxes seleccionades en llocs ocults.", - unmark: "Deixeu que les fitxes seleccionades siguin ubicacions ocultes.", - set: "Canvia un paràmetre o mostra tots els paràmetres.", - pageSet: - "Substituïu una configuració de revelació només a la pàgina actual.", - pageClear: "Elimina les substitucions de la pàgina actual.", + 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + mark: 'Converteix les fitxes seleccionades en llocs ocults.', + unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + set: 'Canvia un paràmetre o mostra tots els paràmetres.', + pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', + pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: - "Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.", + 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', calibrate: - "Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.", - calibrateReset: "Elimineu el calibratge de la pàgina actual.", - status: "Mostra què sap Hexploration sobre la pàgina actual.", + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + calibrateReset: 'Elimineu el calibratge de la pàgina actual.', + status: 'Mostra què sap Hexploration sobre la pàgina actual.', journal: "Reconstruïu els fulls d'ajuda i de comandaments.", - help: "Mostra aquesta llista.", + help: 'Mostra aquesta llista.', handout: 'Les instruccions completes es troben al fullet "{name}".', }, deck: { - subtitle: "Comandament de la plataforma", + subtitle: 'Comandament de la plataforma', drawDesc: "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", revealDesc: "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", locationsDesc: - "Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.", + 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', toolsDesc: - "Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.", + 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', }, handout: { - versionLabel: "Versió", - subtitle: "Exploració hexadecimal per hexadecimal per a Roll20", + versionLabel: 'Versió', + subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { - heading: "Visió general", + heading: 'Visió general', body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", - demo: "Mira una petita demostració (de la versió 1)", + demo: 'Mira una petita demostració (de la versió 1)', }, quickStart: { - heading: "Inici ràpid", + heading: 'Inici ràpid', steps: [ - "Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).", + 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", - "Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.", + 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', ], }, commands: { - heading: "Ordres", + heading: 'Ordres', intro: - "Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.", - colCommand: "Comandament", - colDesc: "Què fa", + 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', + colCommand: 'Comandament', + colDesc: 'Què fa', }, revealing: { - heading: "Com funciona la revelació", + heading: 'Com funciona la revelació', points: [ - "Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.", + 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { - heading: "Hexes i ubicacions anomenades", + heading: 'Hexes i ubicacions anomenades', points: [ "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", @@ -324,52 +321,52 @@ const TRANSLATION = { ], }, settings: { - heading: "Configuració", + heading: 'Configuració', intro: "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", - colKey: "clau", - colName: "Configuració", - colDesc: "Descripció", - perPage: "(Es pot configurar per pàgina.)", + colKey: 'clau', + colName: 'Configuració', + colDesc: 'Descripció', + perPage: '(Es pot configurar per pàgina.)', }, jumpgate: { - heading: "Jumpgate i Legacy", + heading: 'Jumpgate i Legacy', points: [ - "Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.", + 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", ], }, upgrading: { - heading: "Actualització de la versió 1", + heading: 'Actualització de la versió 1', points: [ - "La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.", + 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", - "Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.", - "La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.", + 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', ], - colV1: "Comandament de la versió 1", - colV2: "Comandament de la versió 2", + colV1: 'Comandament de la versió 1', + colV2: 'Comandament de la versió 2', }, troubleshooting: { - heading: "Resolució de problemes", + heading: 'Resolució de problemes', points: [ - "No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).", - "Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.", - "Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.", + 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', + 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', + 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", ], }, languages: { - heading: "Idiomes", + heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", }, credits: { - heading: "Crèdits", - original: "Mod original de", - maintainer: "Versió 2 mantinguda per", + heading: 'Crèdits', + original: 'Mod original de', + maintainer: 'Versió 2 mantinguda per', marketplace: "Els paquets d'art de l'Ada al mercat Roll20", support: "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index 7689b35747..3c171e4cfd 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -1,377 +1,370 @@ const TRANSLATION = { titles: { - ready: "Heexploration je připraven.", - settings: "Nastavení Heexploration", - languages: "Vyberte jazyk", - pageSettings: "Nastavení stránky: {page}", - status: "Stav průzkumu: {page}", - help: "Příkazy pro průzkum", - confirm: "Prosím potvrďte", + ready: 'Heexploration je připraven.', + settings: 'Nastavení Heexploration', + languages: 'Vyberte jazyk', + pageSettings: 'Nastavení stránky: {page}', + status: 'Stav průzkumu: {page}', + help: 'Příkazy pro průzkum', + confirm: 'Prosím potvrďte', }, discovery: { - title: "Místo objeveno", + title: 'Místo objeveno', }, menu: { - draw: "Remíza", - reveal: "Odhalit a skrýt", - locations: "Místa", - tools: "Nástroje", - layerInUse: "Na {layer} se kreslí nové hexy.", + draw: 'Remíza', + reveal: 'Odhalit a skrýt', + locations: 'Místa', + tools: 'Nástroje', + layerInUse: 'Na {layer} se kreslí nové hexy.', pageSettingsHelp: - "Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.", + 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', }, buttons: { - fill: "Vyplnit", - fillInverse: "Inverzní výplň", - undo: "Vrátit zpět výplň", - reveal: "Odhalit", - conceal: "Skrývat", - explore: "Prozkoumat", - revealPage: "Odhalit stránku", - resetPage: "Obnovit stránku", - mark: "Označte umístění", - unmark: "Zrušit označení", - name: "Jméno Hex", - settings: "Nastavení", - pageSettings: "Nastavení stránky", - status: "Postavení", - rescan: "Znovu naskenujte", - calibrate: "Kalibrovat", - calibrateReset: "Resetovat kalibraci", - help: "Pomoc", - change: "Přeměna", - menu: "Menu", - clearOverrides: "Vymazat přepisy", - confirmReset: "Ano, Odebrat všechny hexy", + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + undo: 'Vrátit zpět výplň', + reveal: 'Odhalit', + conceal: 'Skrývat', + explore: 'Prozkoumat', + revealPage: 'Odhalit stránku', + resetPage: 'Obnovit stránku', + mark: 'Označte umístění', + unmark: 'Zrušit označení', + name: 'Jméno Hex', + settings: 'Nastavení', + pageSettings: 'Nastavení stránky', + status: 'Postavení', + rescan: 'Znovu naskenujte', + calibrate: 'Kalibrovat', + calibrateReset: 'Resetovat kalibraci', + help: 'Pomoc', + change: 'Přeměna', + menu: 'Menu', + clearOverrides: 'Vymazat přepisy', + confirmReset: 'Ano, Odebrat všechny hexy', }, prompts: { - name: "Název místa (pro vymazání ponechte prázdné)", + name: 'Název místa (pro vymazání ponechte prázdné)', }, values: { - on: "Na", - off: "Vypnuto", - none: "Žádný", + on: 'Na', + off: 'Vypnuto', + none: 'Žádný', hexLayer: { - auto: "Auto (popředí, pokud je k dispozici)", - foreground: "vrstva popředí", - objects: "vrstva tokenů", + auto: 'Auto (popředí, pokud je k dispozici)', + foreground: 'vrstva popředí', + objects: 'vrstva tokenů', }, revealBy: { - players: "Hráčské žetony", - characters: "Žetony postav", - all: "Všechny tokeny", + players: 'Hráčské žetony', + characters: 'Žetony postav', + all: 'Všechny tokeny', }, revealMode: { - clear: "Jasný", - glimpse: "Záblesk", + clear: 'Jasný', + glimpse: 'Záblesk', }, announce: { - all: "Každý", - gm: "Pouze GM", - off: "Vypnuto", + all: 'Každý', + gm: 'Pouze GM', + off: 'Vypnuto', }, orientation: { - vertical: "Hexadecimální (V)", - horizontal: "Hexadecimální (H)", + vertical: 'Hexadecimální (V)', + horizontal: 'Hexadecimální (H)', }, fillKind: { - fill: "Vyplnit", - fillInverse: "Inverzní výplň", - conceal: "Skrývat", + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + conceal: 'Skrývat', }, }, settings: { language: { - label: "Jazyk", - desc: "Jazyk pro nabídky, zprávy a letáky.", + label: 'Jazyk', + desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: "Hexadecimální vrstva", - desc: "Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.", + label: 'Hexadecimální vrstva', + desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { - label: "Barva výplně", - desc: "Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).", + label: 'Barva výplně', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', }, strokeColor: { - label: "Barva ohraničení", - desc: "Barva obrysu nových hexů.", + label: 'Barva ohraničení', + desc: 'Barva obrysu nových hexů.', }, labelColor: { - label: "Barva štítku", - desc: "Barva jmenovek pouze GM na pojmenovaných hexech.", + label: 'Barva štítku', + desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', }, glimpseColor: { - label: "Barva záblesku", - desc: "Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().", + label: 'Barva záblesku', + desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', }, strokeWidth: { - label: "Šířka okraje", - desc: "Šířka obrysu nových hexů v pixelech (0 až 20).", + label: 'Šířka okraje', + desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: "Hexadecimální vzdálenost odhalení", - desc: "Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.", + label: 'Hexadecimální vzdálenost odhalení', + desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', }, revealDistance: { - label: "Pohledová vzdálenost", - desc: "Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.", + label: 'Pohledová vzdálenost', + desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', }, lineOfSight: { - label: "Zornost", - desc: "Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.", + label: 'Zornost', + desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', }, revealPath: { - label: "Odhalení Po cestě", - desc: "Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.", + label: 'Odhalení Po cestě', + desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', }, revealBy: { - label: "Tokeny, které odhalují", - desc: "Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.", + label: 'Tokeny, které odhalují', + desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', }, revealMode: { - label: "Režim odhalení", - desc: "Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.", + label: 'Režim odhalení', + desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', }, announce: { - label: "Oznamte objevy", - desc: "Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.", + label: 'Oznamte objevy', + desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', }, pingDiscoveries: { - label: "Ping Discovery", - desc: "Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.", + label: 'Ping Discovery', + desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', + }, + hideCoveredTokens: { + label: 'Skryjte kryté žetony', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', }, }, status: { - engine: "Herní engine", - grid: "Mřížka", - layer: "Hexadecimální vrstva", - hexes: "Hexy", - named: "Pojmenované hexy", - icons: "Tokeny polohy", - glimpsed: "Zahlédnuté hexy", - pending: "Místa čekající na zaplnění", - calibrated: "Zkalibrováno", - overrides: "Přepíše stránku", - undo: "Zpět k dispozici", + engine: 'Herní engine', + grid: 'Mřížka', + layer: 'Hexadecimální vrstva', + hexes: 'Hexy', + named: 'Pojmenované hexy', + icons: 'Tokeny polohy', + glimpsed: 'Zahlédnuté hexy', + pending: 'Místa čekající na zaplnění', + calibrated: 'Zkalibrováno', + overrides: 'Přepíše stránku', + undo: 'Zpět k dispozici', }, messages: { filled: - "Vyplnění dokončeno: {created} nakreslených hexů, {restyled} změněných, {icons} míst skrytých.", - revealed: "{count} odhalených hexů.", - revealedPage: "Všechny {count} hexy na stránce odhaleny.", + 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + revealed: 'Odhalené hexy: {count}.', + revealedPage: 'Každé odhalené hex na stránce ({count}).', confirmReset: - "Odebrat všechny {count} hexy z „{page}“? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.", - resetPage: "{count} hexy odstraněny ze stránky.", + 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - "Poslední vyplnění bylo zrušeno: {removed} hexy odstraněny, {restored} obnovené hexy s novým stylem.", - named: "{count} hexy s názvem „{name}“.", - unnamed: "Název byl vymazán z {count} hexů.", + 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + named: 'Hexusy s názvem „{name}“: {count}.', + unnamed: 'Jména vymazána: {count}.', marked: - "{attached} umístění skrytá na stávajících hexech; {pending} budou skryty další výplní, která je zakryje.", - unmarked: "{count} tokeny již nejsou umístění.", - settingChanged: "{setting} nastaveno na {value}.", + 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', + unmarked: 'Tokeny, které již nejsou umístěními: {count}.', + settingChanged: '{setting} nastaveno na {value}.', rescanned: - "Opětovné skenování dokončeno: {kept} hexy ponechány, {adopted} přijato, {moved} znovu zaregistrováno, {dropped} chybějící hexy zapomenuty, __HEX_PLACEHOLDER__5_4_ umístěníHEX_4_ umístění tokeny znovu propojeny.", + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - "Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.", + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', calibrationReset: - "Kalibrace odstraněna. Znovu naskenovat: {kept} ponecháno, {moved} znovu zaevidováno, {adopted} přijato.", - journalRebuilt: "Materiály „{help}“ a „{deck}“ byly přepracovány.", + 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: - "Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.", + 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', pruned: - "{dropped} uložená hexy již neexistují a byla zapomenuta. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.", + 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', readyHint: - "Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.", + 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', }, warnings: { foregroundUnavailable: - "Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.", + 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', someFailed: - "{count} hexy nelze nakreslit. Podrobnosti naleznete v konzole API.", + 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { - noPage: "Nelze najít stránku, na které by se dalo pracovat.", - notHex: "Tato stránka nepoužívá hexadecimální mřížku.", - noPolygons: - "Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.", - emptyArea: "Vybraná oblast neobsahuje žádné středy šestihran.", - tooMany: "To by vytvořilo {count} hexů, což je příliš mnoho najednou.", - nothingToConceal: - "Vyberte nakreslené tvary nebo žetony, které chcete skrýt.", - nothingToReveal: - "Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.", - noTokens: "Nejprve vyberte jeden nebo více žetonů.", - noHexes: - "Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).", - nothingToUndo: "Neexistuje žádná výplň, kterou lze vrátit zpět.", - unknownCommand: "Neznámý příkaz: {command}", - unknownSetting: "Neznámé nastavení: {key}", - unknownPageSetting: "Nastavení, která lze nastavit na stránce: {keys}", - invalidValue: "„{value}“ není platná hodnota pro {key}.", - calibrateNeedsTokens: - "Vyberte jeden nebo dva žetony přichycené na středy hexů.", - calibrateFailed: "Tyto tokeny nelze použít ke kalibraci.", - unexpected: "Něco se pokazilo: {message}", + noPage: 'Nelze najít stránku, na které by se dalo pracovat.', + notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', + nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', + nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', + noTokens: 'Nejprve vyberte jeden nebo více žetonů.', + noHexes: 'Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).', + nothingToUndo: 'Neexistuje žádná výplň, kterou lze vrátit zpět.', + unknownCommand: 'Neznámý příkaz: {command}', + unknownSetting: 'Neznámé nastavení: {key}', + unknownPageSetting: 'Nastavení, která lze nastavit na stránce: {keys}', + invalidValue: '„{value}“ není platná hodnota pro {key}.', + calibrateNeedsTokens: 'Vyberte jeden nebo dva žetony přichycené na středy hexů.', + calibrateFailed: 'Tyto tokeny nelze použít ke kalibraci.', + unexpected: 'Něco se pokazilo: {message}', }, hints: { - noPage: - "Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.", - notHex: - "Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.", + noPage: 'Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.', + notHex: 'Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.', noPolygons: - "Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.", - emptyArea: - "Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.", - tooMany: "Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.", - noHexes: - "Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.", - unknownCommand: - "Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.", - unknownSetting: - "Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.", + 'Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.', + emptyArea: 'Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.', + tooMany: 'Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.', + noHexes: 'Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.', + unknownCommand: 'Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.', + unknownSetting: 'Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.', calibrateNeedsTokens: - "Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.", + 'Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.', calibrateFailed: - "Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.", - unexpected: "Podrobnosti jsou v protokolu konzoly API.", + 'Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.', + unexpected: 'Podrobnosti jsou v protokolu konzoly API.', }, help: { - menu: "Ukaž menu.", - fill: "Zakryjte vybrané nakreslené tvary hexy.", - fillInverse: "Zakryjte celou stránku kromě vybraných tvarů.", - undo: "Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.", - reveal: "Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.", - revealPage: "Odhalte každé hex na stránce bez oznámení.", - conceal: "Znovu zakryjte oblast pod vybranými tvary a žetony hexy.", - explore: "Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.", - resetPage: "Odstraňte každý hex na stránce (nejprve se ptá).", - name: "Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.", - mark: "Proměňte vybrané žetony na skrytá místa.", - unmark: "Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.", - set: "Změňte nastavení nebo zobrazte všechna nastavení.", - pageSet: "Přepsat nastavení odkrytí pouze na aktuální stránce.", - pageClear: "Odstraňte přepsání aktuální stránky.", - rescan: - "Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.", + menu: 'Ukaž menu.', + fill: 'Zakryjte vybrané nakreslené tvary hexy.', + fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', + undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', + reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', + revealPage: 'Odhalte každé hex na stránce bez oznámení.', + conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', + explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', + resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', + name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', + mark: 'Proměňte vybrané žetony na skrytá místa.', + unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + set: 'Změňte nastavení nebo zobrazte všechna nastavení.', + pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', + pageClear: 'Odstraňte přepsání aktuální stránky.', + rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', calibrate: - "Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.", - calibrateReset: "Odstraňte kalibraci aktuální stránky.", - status: "Ukažte, co Heexploration ví o aktuální stránce.", - journal: "Znovu sestavte podklady pro balíček nápovědy a příkazů.", - help: "Zobrazit tento seznam.", - handout: "Úplné pokyny jsou v letáku „{name}“.", + 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', + calibrateReset: 'Odstraňte kalibraci aktuální stránky.', + status: 'Ukažte, co Heexploration ví o aktuální stránce.', + journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + help: 'Zobrazit tento seznam.', + handout: 'Úplné pokyny jsou v letáku „{name}“.', }, deck: { - subtitle: "Velitelský balíček", + subtitle: 'Velitelský balíček', drawDesc: - "Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.", + 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', revealDesc: - "Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.", + 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', locationsDesc: - "Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.", + 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', toolsDesc: - "Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.", - footer: "Úplné pokyny naleznete v letáku „{help}“.", + 'Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.', + footer: 'Úplné pokyny naleznete v letáku „{help}“.', }, handout: { - versionLabel: "Verze", - subtitle: "Průzkum hex po hexu pro Roll20", - footer: "Pro ovládání jedním kliknutím použijte leták „{deck}“.", + versionLabel: 'Verze', + subtitle: 'Průzkum hex po hexu pro Roll20', + footer: 'Pro ovládání jedním kliknutím použijte leták „{deck}“.', overview: { - heading: "Přehled", - body: "Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.", - demo: "Podívejte se na krátkou ukázku (od verze 1)", + heading: 'Přehled', + body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', + demo: 'Podívejte se na krátkou ukázku (od verze 1)', }, quickStart: { - heading: "Rychlý start", + heading: 'Rychlý start', steps: [ - "Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).", - "Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.", - "Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.", - "Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.", - "Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.", + 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', + 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', + 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', ], }, commands: { - heading: "Příkazy", + heading: 'Příkazy', intro: - "Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.", - colCommand: "Příkaz", - colDesc: "Co to dělá", + 'Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.', + colCommand: 'Příkaz', + colDesc: 'Co to dělá', }, revealing: { - heading: "Jak funguje odhalování", + heading: 'Jak funguje odhalování', points: [ - "Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.", - "Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.", - "Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.", - "Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.", - "V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.", - "API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.", + 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', + 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', + 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', + 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', ], }, locations: { - heading: "Pojmenované hexy a umístění", + heading: 'Pojmenované hexy a umístění', points: [ - "Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.", - "Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.", - "Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.", - "Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.", - "Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.", + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', + 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', + 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', + 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', ], }, settings: { - heading: "Nastavení", + heading: 'Nastavení', intro: - "Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.", - colKey: "Klíč", - colName: "Nastavení", - colDesc: "Popis", - perPage: "(Lze nastavit na stránku.)", + 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + colKey: 'Klíč', + colName: 'Nastavení', + colDesc: 'Popis', + perPage: '(Lze nastavit na stránku.)', }, jumpgate: { - heading: "Jumpgate a Legacy", + heading: 'Jumpgate a Legacy', points: [ - "Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.", - "Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.", - "Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.", - "Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.", + 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', + 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', ], }, upgrading: { - heading: "Upgrade z verze 1", + heading: 'Upgrade z verze 1', points: [ - "Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.", - "Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.", - "Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.", - "Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.", + 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', + 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', + 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', + 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', ], - colV1: "Příkaz verze 1", - colV2: "Příkaz verze 2", + colV1: 'Příkaz verze 1', + colV2: 'Příkaz verze 2', }, troubleshooting: { - heading: "Odstraňování problémů", + heading: 'Odstraňování problémů', points: [ - "Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).", - "Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.", - "Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.", - "Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.", - "Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.", + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', + 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', ], }, languages: { - heading: "Jazyky", - body: "Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:", + heading: 'Jazyky', + body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', }, credits: { - heading: "Kredity", - original: "Původní mod od", - maintainer: "Verze 2 spravovaná společností", - marketplace: "Adiny umělecké balíčky na Roll20 Marketplace", + heading: 'Kredity', + original: 'Původní mod od', + maintainer: 'Verze 2 spravovaná společností', + marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', support: - "Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.", + 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', }, }, }; diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index f40e4849cd..e17e753284 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -1,375 +1,368 @@ const TRANSLATION = { titles: { - ready: "Hexploration er klar.", - settings: "Indstillinger for Hexploration", - languages: "Vælg et sprog", - pageSettings: "Sideindstillinger: {page}", - status: "Hexploration Status: {page}", - help: "Hexploration kommandoer", - confirm: "Bekræft venligst", + ready: 'Hexploration er klar.', + settings: 'Indstillinger for Hexploration', + languages: 'Vælg et sprog', + pageSettings: 'Sideindstillinger: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandoer', + confirm: 'Bekræft venligst', }, discovery: { - title: "Sted opdaget", + title: 'Sted opdaget', }, menu: { - draw: "Tegne", - reveal: "Afsløre og skjul", - locations: "Steder", - tools: "Værktøjer", - layerInUse: "Nye sekskanter bliver tegnet på {layer}.", + draw: 'Tegne', + reveal: 'Afsløre og skjul', + locations: 'Steder', + tools: 'Værktøjer', + layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', pageSettingsHelp: - "Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.", + 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', }, buttons: { - fill: "Fylde", - fillInverse: "Omvendt fyld", - undo: "Fortryd Fyld", - reveal: "Afsløre", - conceal: "Skjule", - explore: "Udforske", - revealPage: "Afsløre side", - resetPage: "Nulstil side", - mark: "Marker placering", - unmark: "Fjern markering", - name: "Navn Hex", - settings: "Indstillinger", - pageSettings: "Sideindstillinger", - status: "Status", - rescan: "Scan igen", - calibrate: "Kalibrer", - calibrateReset: "Nulstil kalibrering", - help: "Hjælp", - change: "Forandring", - menu: "Menu", - clearOverrides: "Ryd tilsidesættelser", - confirmReset: "Ja, Fjern alle Hexes", + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + undo: 'Fortryd Fyld', + reveal: 'Afsløre', + conceal: 'Skjule', + explore: 'Udforske', + revealPage: 'Afsløre side', + resetPage: 'Nulstil side', + mark: 'Marker placering', + unmark: 'Fjern markering', + name: 'Navn Hex', + settings: 'Indstillinger', + pageSettings: 'Sideindstillinger', + status: 'Status', + rescan: 'Scan igen', + calibrate: 'Kalibrer', + calibrateReset: 'Nulstil kalibrering', + help: 'Hjælp', + change: 'Forandring', + menu: 'Menu', + clearOverrides: 'Ryd tilsidesættelser', + confirmReset: 'Ja, Fjern alle Hexes', }, prompts: { - name: "Placeringsnavn (lad tom for at rydde)", + name: 'Placeringsnavn (lad tom for at rydde)', }, values: { - on: "På", - off: "Slukket", - none: "Ingen", + on: 'På', + off: 'Slukket', + none: 'Ingen', hexLayer: { - auto: "Auto (forgrund, hvis tilgængelig)", - foreground: "forgrundslaget", - objects: "symbollag", + auto: 'Auto (forgrund, hvis tilgængelig)', + foreground: 'forgrundslaget', + objects: 'symbollag', }, revealBy: { - players: "Spillerpoletter", - characters: "Karakter tokens", - all: "Alle tokens", + players: 'Spillerpoletter', + characters: 'Karakter tokens', + all: 'Alle tokens', }, revealMode: { - clear: "Klar", - glimpse: "Glimt", + clear: 'Klar', + glimpse: 'Glimt', }, announce: { - all: "Alle sammen", - gm: "Kun GM", - off: "Slukket", + all: 'Alle sammen', + gm: 'Kun GM', + off: 'Slukket', }, orientation: { - vertical: "Hex (V)", - horizontal: "Hex (H)", + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: "Fylde", - fillInverse: "Omvendt fyld", - conceal: "Skjule", + fill: 'Fylde', + fillInverse: 'Omvendt fyld', + conceal: 'Skjule', }, }, settings: { language: { - label: "Sprog", - desc: "Sprog til menuer, beskeder og uddelingskopier.", + label: 'Sprog', + desc: 'Sprog til menuer, beskeder og uddelingskopier.', }, hexLayer: { - label: "Hex lag", - desc: "Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.", + label: 'Hex lag', + desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', }, fillColor: { - label: "Fyld farve", - desc: "Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).", + label: 'Fyld farve', + desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { - label: "Kantfarve", - desc: "Farve på omridset af nye sekskanter.", + label: 'Kantfarve', + desc: 'Farve på omridset af nye sekskanter.', }, labelColor: { - label: "Etiket farve", - desc: "Farven på GM-only navneetiketter på navngivne sekskanter.", + label: 'Etiket farve', + desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', }, glimpseColor: { - label: "Glimt farve", - desc: "Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.", + label: 'Glimt farve', + desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', }, strokeWidth: { - label: "Border Bredde", - desc: "Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).", + label: 'Border Bredde', + desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: "Hex Reveal Distance", - desc: "Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.", + label: 'Hex afsløre afstand', + desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { - label: "Synsafstand", - desc: "Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.", + label: 'Synsafstand', + desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', }, lineOfSight: { - label: "Synslinie", - desc: "Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.", + label: 'Synslinie', + desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', }, revealPath: { - label: "Afsløre langs stien", - desc: "Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.", + label: 'Afsløre langs stien', + desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', }, revealBy: { - label: "Tokens, der afslører", - desc: "Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.", + label: 'Tokens, der afslører', + desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { - label: "Reveal Mode", - desc: "Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.", + label: 'Afsløringstilstand', + desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', }, announce: { - label: "Annoncer opdagelser", - desc: "Hvem ser chatbeskeden, når en navngivet placering opdages.", + label: 'Annoncer opdagelser', + desc: 'Hvem ser chatbeskeden, når en navngivet placering opdages.', }, pingDiscoveries: { - label: "Ping opdagelser", - desc: "Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.", + label: 'Ping opdagelser', + desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', + }, + hideCoveredTokens: { + label: 'Skjul dækkede tokens', + desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', }, }, status: { - engine: "Spil motor", - grid: "Gitter", - layer: "Hex lag", - hexes: "Hekser", - named: "Navngivne hexes", - icons: "Placeringstokens", - glimpsed: "Glimpede sekskanter", - pending: "Steder, der venter på udfyldning", - calibrated: "Kalibreret", - overrides: "Side tilsidesætter", - undo: "Fortryd tilgængelig", + engine: 'Spil motor', + grid: 'Gitter', + layer: 'Hex lag', + hexes: 'Hekser', + named: 'Navngivne hexes', + icons: 'Placeringstokens', + glimpsed: 'Glimpede sekskanter', + pending: 'Steder, der venter på udfyldning', + calibrated: 'Kalibreret', + overrides: 'Side tilsidesætter', + undo: 'Fortryd tilgængelig', }, messages: { - filled: - "Fyld fuldført: {created} hexes tegnet, {restyled} restylet, {icons} placeringer skjult.", - revealed: "{count} hexes afsløret.", - revealedPage: "Alle {count} hexes på siden afsløret.", + filled: 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexer afsløret: {count}.', + revealedPage: 'Hver hex på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne alle {count} hexes fra "{page}"? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: "{count} sekskanter fjernet fra siden.", + 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexer fjernet fra siden: {count}.', undone: - "Sidste udfyldning fortrydet: {removed} hexes fjernet, {restored} restyled hexes gendannet.", - named: '{count} hexes med navnet "{name}".', - unnamed: "Navnet er ryddet fra {count} hexes.", + 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', + named: 'Hexer med navnet "{name}": {count}.', + unnamed: 'Navne ryddet: {count}.', marked: - "{attached} placeringer skjult i eksisterende hexes; {pending} vil blive skjult af den næste udfyldning, der dækker dem.", - unmarked: "{count} tokens er ikke længere placeringer.", - settingChanged: "{setting} indstillet til {value}.", + 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + unmarked: 'Tokens, der ikke længere er placeringer: {count}.', + settingChanged: '{setting} indstillet til {value}.', rescanned: - "Genscanning fuldført: {kept} hexes bevaret, {adopted} adopteret, {moved} genarkiveret, {dropped} manglende hexes glemt, {labels} etiketter og __HEX_PLACEHOLDERs gentilknyttede placeringer.", + 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - "Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: {kept} beholdt, {moved} genindgivet, {adopted} vedtaget.", + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', calibrationReset: - "Kalibrering fjernet. Genscan: {kept} beholdes, {moved} genindgivet, {adopted} blev vedtaget.", - journalRebuilt: - 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: - "Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.", + 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', pruned: - "{dropped} gemte hexes eksisterer ikke længere og blev glemt. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.", + 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', readyHint: 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', }, warnings: { foregroundUnavailable: - "Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.", - someFailed: - "{count} sekskanter kunne ikke tegnes. Tjek API-konsollen for detaljer.", + 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', + someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { - noPage: "Kunne ikke finde siden at arbejde på.", - notHex: "Denne side bruger ikke et hex-gitter.", - noPolygons: "Vælg en eller flere tegnede figurer, der skal udfyldes.", - emptyArea: "Det valgte område indeholder ingen hex-centre.", - tooMany: "Det ville skabe {count} hexes, hvilket er for mange på én gang.", - nothingToConceal: "Vælg tegnede figurer eller tokens til at skjule.", - nothingToReveal: - "Vælg sekskanter, tegnede figurer eller tokens for at afsløre.", - noTokens: "Vælg først et eller flere tokens.", - noHexes: - "Vælg først en eller flere hexes (eller poletter stående på hexes).", - nothingToUndo: "Der er ingen udfyldning at fortryde.", - unknownCommand: "Ukendt kommando: {command}", - unknownSetting: "Ukendt indstilling: {key}", - unknownPageSetting: "Indstillinger, der kan indstilles pr. side: {keys}", + noPage: 'Kunne ikke finde siden at arbejde på.', + notHex: 'Denne side bruger ikke et hex-gitter.', + noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', + emptyArea: 'Det valgte område indeholder ingen hex-centre.', + tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', + nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + noTokens: 'Vælg først et eller flere tokens.', + noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + nothingToUndo: 'Der er ingen udfyldning at fortryde.', + unknownCommand: 'Ukendt kommando: {command}', + unknownSetting: 'Ukendt indstilling: {key}', + unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', - calibrateNeedsTokens: "Vælg et eller to tokens fastgjort til hex-centre.", - calibrateFailed: "Disse tokens kan ikke bruges til at kalibrere.", - unexpected: "Noget gik galt: {message}", + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', + unexpected: 'Noget gik galt: {message}', }, hints: { - noPage: "Åbn den side, du vil arbejde på, eller vælg noget på den.", - notHex: - "Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.", + noPage: 'Åbn den side, du vil arbejde på, eller vælg noget på den.', + notHex: 'Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.', noPolygons: - "Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.", - emptyArea: - "Tegn en større form, eller kontroller indstillingerne for sidegitteret.", - tooMany: "Udfyld et mindre område, eller opdel området i flere former.", - noHexes: - "Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.", - unknownCommand: "Skriv !hexploration help for at vise kommandoerne.", - unknownSetting: "Skriv !hexploration set for at se alle indstillinger.", + 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', + emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', + tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', + noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', + unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', calibrateNeedsTokens: - "Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.", + 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', calibrateFailed: - "To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.", - unexpected: "Detaljer er i API-konsolloggen.", + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + unexpected: 'Detaljer er i API-konsolloggen.', }, help: { - menu: "Vis menuen.", - fill: "Dæk de valgte tegnede figurer med sekskanter.", - fillInverse: "Dæk hele siden undtagen inde i de valgte former.", - undo: "Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.", - reveal: "Afslør de valgte hexes og hexes under de valgte former og tokens.", - revealPage: "Afslør hver hex på siden uden meddelelser.", - conceal: - "Dæk området under de valgte former og tokens med sekskanter igen.", - explore: - "Afslør omkring de valgte tokens, som om de lige var flyttet dertil.", - resetPage: "Fjern hver hex på siden (spørg først).", - name: "Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.", - mark: "Gør de valgte tokens til skjulte placeringer.", - unmark: "Stop de valgte tokens med at være skjulte placeringer.", - set: "Skift en indstilling, eller vis alle indstillinger.", - pageSet: "Tilsidesæt kun en afsløringsindstilling på den aktuelle side.", - pageClear: "Fjern den aktuelle sides tilsidesættelser.", - rescan: - "Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.", + menu: 'Vis menuen.', + fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', + undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', + reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', + revealPage: 'Afslør hver hex på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', + resetPage: 'Fjern hver hex på siden (spørg først).', + name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + mark: 'Gør de valgte tokens til skjulte placeringer.', + unmark: 'Stop de valgte tokens med at være skjulte placeringer.', + set: 'Skift en indstilling, eller vis alle indstillinger.', + pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', + pageClear: 'Fjern den aktuelle sides tilsidesættelser.', + rescan: 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', calibrate: - "Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.", - calibrateReset: "Fjern den aktuelle sides kalibrering.", - status: "Vis, hvad Hexploration ved om den aktuelle side.", - journal: "Genopbyg hjælpe- og kommandodækket-uddelingsarkene.", - help: "Vis denne liste.", + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + calibrateReset: 'Fjern den aktuelle sides kalibrering.', + status: 'Vis, hvad Hexploration ved om den aktuelle side.', + journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + help: 'Vis denne liste.', handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', }, deck: { - subtitle: "Kommandodæk", + subtitle: 'Kommandodæk', drawDesc: - "Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.", + 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', revealDesc: - "Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.", + 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', locationsDesc: - "Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.", + 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', toolsDesc: - "Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.", + 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', }, handout: { - versionLabel: "Version", - subtitle: "Hex-by-hex-udforskning for Roll20", - footer: - 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + versionLabel: 'Version', + subtitle: 'Hex-by-hex-udforskning for Roll20', + footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', overview: { - heading: "Oversigt", - body: "Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.", - demo: "Se en kort demo (fra version 1)", + heading: 'Oversigt', + body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + demo: 'Se en kort demo (fra version 1)', }, quickStart: { - heading: "Hurtig start", + heading: 'Hurtig start', steps: [ - "Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).", - "Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.", - "Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.", - "Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.", - "Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.", + 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', + 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', + 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', + 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', + 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', ], }, commands: { - heading: "Kommandoer", + heading: 'Kommandoer', intro: "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", - colCommand: "Kommando", - colDesc: "Hvad den gør", + colCommand: 'Kommando', + colDesc: 'Hvad den gør', }, revealing: { - heading: "Sådan fungerer afsløring", + heading: 'Sådan fungerer afsløring', points: [ - "Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.", - "Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.", - "Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.", - "Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.", - "I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.", + 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', + 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', + 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', + 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', + "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", ], }, locations: { - heading: "Navngivne Hekser og Steder", + heading: 'Navngivne Hekser og Steder', points: [ - "Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.", - "Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.", - "Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.", - "Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.", - "Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.", + 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', + 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', ], }, settings: { - heading: "Indstillinger", + heading: 'Indstillinger', intro: "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", - colKey: "Nøgle", - colName: "Indstilling", - colDesc: "Beskrivelse", - perPage: "(Kan indstilles pr. side.)", + colKey: 'Nøgle', + colName: 'Indstilling', + colDesc: 'Beskrivelse', + perPage: '(Kan indstilles pr. side.)', }, jumpgate: { - heading: "Jumpgate og Legacy", + heading: 'Jumpgate og Legacy', points: [ - "Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.", - "Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.", - "Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.", + 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', + 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", ], }, upgrading: { - heading: "Opgradering fra version 1", + heading: 'Opgradering fra version 1', points: [ - "Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.", - "Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.", - "Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.", - "Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.", + 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', + 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', + 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', ], - colV1: "Version 1 kommando", - colV2: "Version 2 kommando", + colV1: 'Version 1 kommando', + colV2: 'Version 2 kommando', }, troubleshooting: { - heading: "Fejlfinding", + heading: 'Fejlfinding', points: [ - "Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).", - "Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.", - "Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.", - "Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.", - "For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.", + 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', + 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', + 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', + 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', ], }, languages: { - heading: "Sprog", - body: "Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:", + heading: 'Sprog', + body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', }, credits: { - heading: "Credits", - original: "Original mod af", - maintainer: "Version 2 vedligeholdes af", - marketplace: "Adas kunstpakker på Roll20 Marketplace", + heading: 'Kreditter', + original: 'Original mod af', + maintainer: 'Version 2 vedligeholdes af', + marketplace: 'Adas kunstpakker på Roll20 Marketplace', support: - "Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.", + 'Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.', }, }, }; diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index ff8b4c5632..f16bcf0608 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -1 +1,382 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Hexploration ist fertig.', + settings: 'Erkundungseinstellungen', + languages: 'Wählen Sie eine Sprache', + pageSettings: 'Seiteneinstellungen: {page}', + status: 'Erkundungsstatus: {page}', + help: 'Erkundungsbefehle', + confirm: 'Bitte bestätigen', + }, + discovery: { + title: 'Standort entdeckt', + }, + menu: { + draw: 'Ziehen', + reveal: 'Enthüllen und Verstecken', + locations: 'Standorte', + tools: 'Werkzeuge', + layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + pageSettingsHelp: + 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', + }, + buttons: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + undo: 'Füllung rückgängig machen', + reveal: 'Aufdecken', + conceal: 'Verbergen', + explore: 'Erkunden', + revealPage: 'Seite enthüllen', + resetPage: 'Seite zurücksetzen', + mark: 'Standort markieren', + unmark: 'Markierung aufheben', + name: 'Name Hex', + settings: 'Einstellungen', + pageSettings: 'Seiteneinstellungen', + status: 'Status', + rescan: 'Erneut scannen', + calibrate: 'Kalibrieren', + calibrateReset: 'Kalibrierung zurücksetzen', + help: 'Helfen', + change: 'Ändern', + menu: 'Speisekarte', + clearOverrides: 'Überschreibungen löschen', + confirmReset: 'Ja, alle Verhexungen entfernen', + }, + prompts: { + name: 'Standortname (zum Löschen leer lassen)', + }, + values: { + on: 'An', + off: 'Aus', + none: 'Keiner', + hexLayer: { + auto: 'Auto (Vordergrund, falls verfügbar)', + foreground: 'Vordergrundebene', + objects: 'Token-Schicht', + }, + revealBy: { + players: 'Spielertoken', + characters: 'Charaktertoken', + all: 'Alle Token', + }, + revealMode: { + clear: 'Klar', + glimpse: 'Blick', + }, + announce: { + all: 'Alle', + gm: 'Nur GM', + off: 'Aus', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Sechskant (H)', + }, + fillKind: { + fill: 'Füllen', + fillInverse: 'Inverse Füllung', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Sprache', + desc: 'Sprache für Menüs, Nachrichten und Handouts.', + }, + hexLayer: { + label: 'Hex-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + }, + fillColor: { + label: 'Füllfarbe', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randfarbe', + desc: 'Farbe der Umrisse neuer Hexfelder.', + }, + labelColor: { + label: 'Etikettenfarbe', + desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', + }, + glimpseColor: { + label: 'Einblick in die Farbe', + desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + }, + strokeWidth: { + label: 'Randbreite', + desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', + }, + maxDistance: { + label: 'Hex-Enthüllungsabstand', + desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', + }, + revealDistance: { + label: 'Sichtweite', + desc: 'Wie viele Hexfelder um einen beweglichen Spielstein herum angezeigt werden (0 bis 20). 0 zeigt nur die Hexfelder an, die der Token durchquert.', + }, + lineOfSight: { + label: 'Sichtlinie', + desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', + }, + revealPath: { + label: 'Auf dem Weg enthüllen', + desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', + }, + revealBy: { + label: 'Zeichen, die offenbaren', + desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + }, + revealMode: { + label: 'Reveal-Modus', + desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + }, + announce: { + label: 'Kündigen Sie Entdeckungen an', + desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', + }, + pingDiscoveries: { + label: 'Ping-Entdeckungen', + desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', + }, + hideCoveredTokens: { + label: 'Verdeckte Token ausblenden', + desc: 'Roll20 zeichnet Namen, Balken und Auren über Hexfeldern. Wenn diese Option aktiviert ist, werden der für den Spieler sichtbare Name, die Balken und die Auren von Spielsteinen unter einem abgedeckten Hexfeld ausgeschaltet und wieder eingeschaltet, wenn sie aufgedeckt werden.', + }, + }, + status: { + engine: 'Spiel-Engine', + grid: 'Netz', + layer: 'Hex-Schicht', + hexes: 'Verhexungen', + named: 'Benannte Verhexungen', + icons: 'Standorttoken', + glimpsed: 'Gesehene Verhexungen', + pending: 'Orte, die auf eine Besetzung warten', + calibrated: 'Kalibriert', + overrides: 'Seitenüberschreibungen', + undo: 'Rückgängig machen verfügbar', + }, + messages: { + filled: + 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', + revealed: 'Aufgedeckte Verhexungen: {count}.', + revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + confirmReset: + 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + undone: + 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexen mit dem Namen „{name}“: {count}.', + unnamed: 'Gelöschte Namen: {count}.', + marked: + 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', + unmarked: 'Token, die keine Standorte mehr sind: {count}.', + settingChanged: '{setting} wird auf {value} gesetzt.', + rescanned: + 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + calibrated: + 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + calibrationReset: + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', + migrated: + 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + pruned: + 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + readyHint: + 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + }, + warnings: { + foregroundUnavailable: + 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', + someFailed: + 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + }, + errors: { + noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', + notHex: 'Diese Seite verwendet kein Hex-Raster.', + noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', + emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', + tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + nothingToConceal: + 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + nothingToReveal: + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', + noHexes: + 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', + nothingToUndo: 'Es gibt keine Füllung, die rückgängig gemacht werden könnte.', + unknownCommand: 'Unbekannter Befehl: {command}', + unknownSetting: 'Unbekannte Einstellung: {key}', + unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', + invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', + calibrateNeedsTokens: + 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', + unexpected: 'Es ist ein Fehler aufgetreten: {message}', + }, + hints: { + noPage: 'Öffnen Sie die Seite, an der Sie arbeiten möchten, oder wählen Sie etwas darauf aus.', + notHex: 'Stellen Sie das Seitenraster in den Seiteneinstellungen auf Hex (V) oder Hex (H) ein.', + noPolygons: + 'Zeichnen Sie ein Polygon, ein Rechteck, eine Ellipse oder eine Freihandform um den Bereich, wählen Sie es aus und versuchen Sie es erneut.', + emptyArea: 'Zeichnen Sie eine größere Form oder überprüfen Sie die Seitenrastereinstellungen.', + tooMany: + 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', + noHexes: + 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', + unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', + calibrateNeedsTokens: + 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', + calibrateFailed: + 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + unexpected: 'Details finden Sie im API-Konsolenprotokoll.', + }, + help: { + menu: 'Zeigen Sie das Menü an.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', + undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + reveal: + 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', + revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + conceal: + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + explore: + 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', + set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', + pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', + rescan: + 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + calibrate: + 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', + status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', + journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + help: 'Diese Liste anzeigen.', + handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', + }, + deck: { + subtitle: 'Kommandodeck', + drawDesc: + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + revealDesc: + 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + locationsDesc: + 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + toolsDesc: + 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', + footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-für-Hex-Erkundung für Roll20', + footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', + overview: { + heading: 'Überblick', + body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', + }, + quickStart: { + heading: 'Schnellstart', + steps: [ + 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', + 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', + 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', + 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + ], + }, + commands: { + heading: 'Befehle', + intro: + 'Nur GMs können diese Befehle verwenden. Die meisten wirken auf die ausgewählten Objekte; Der Rest wirkt auf der Seite, die Sie gerade betrachten.', + colCommand: 'Befehl', + colDesc: 'Was es bewirkt', + }, + revealing: { + heading: 'Wie Offenlegung funktioniert', + points: [ + 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', + 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', + 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + ], + }, + locations: { + heading: 'Benannte Hexfelder und Orte', + points: [ + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', + 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', + 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + ], + }, + settings: { + heading: 'Einstellungen', + intro: + 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + colKey: 'Schlüssel', + colName: 'Einstellung', + colDesc: 'Beschreibung', + perPage: '(Kann pro Seite eingestellt werden.)', + }, + jumpgate: { + heading: 'Jumpgate und Legacy', + points: [ + 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', + 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + ], + }, + upgrading: { + heading: 'Upgrade von Version 1', + points: [ + 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', + 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', + 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + ], + colV1: 'Befehl der Version 1', + colV2: 'Befehl der Version 2', + }, + troubleshooting: { + heading: 'Fehlerbehebung', + points: [ + 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', + 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', + 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', + ], + }, + languages: { + heading: 'Sprachen', + body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + }, + credits: { + heading: 'Credits', + original: 'Original-Mod von', + maintainer: 'Version 2 verwaltet von', + marketplace: 'Adas Kunstpakete auf dem Roll20-Marktplatz', + support: + 'Wenn Sie einen Fehler finden oder eine Idee haben, posten Sie im Roll20 Mod-Forum oder öffnen Sie ein Problem auf GitHub und fügen Sie alle Meldungen aus dem API-Konsolenprotokoll hinzu.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index ff8b4c5632..af0ebade76 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -1 +1,375 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Η εξερεύνηση είναι έτοιμη.', + settings: 'Ρυθμίσεις εξερεύνησης', + languages: 'Επιλέξτε μια γλώσσα', + pageSettings: 'Ρυθμίσεις σελίδας: {page}', + status: 'Κατάσταση εξερεύνησης: {page}', + help: 'Εντολές Εξερεύνησης', + confirm: 'Επιβεβαιώστε', + }, + discovery: { + title: 'Ανακαλύφθηκε τοποθεσία', + }, + menu: { + draw: 'Ισοπαλία', + reveal: 'Αποκάλυψη και απόκρυψη', + locations: 'Τοποθεσίες', + tools: 'Εργαλεία', + layerInUse: 'Νέα εξάγωνα σχεδιάζονται στο {layer}.', + pageSettingsHelp: + 'Αυτές οι ρυθμίσεις ισχύουν μόνο για αυτήν τη σελίδα. Οι ρυθμίσεις με την ένδειξη ★ αντικαθιστούν τις καθολικές ρυθμίσεις.', + }, + buttons: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + undo: 'Αναίρεση συμπλήρωσης', + reveal: 'Αποκαλύπτω', + conceal: 'Απόκρυψη', + explore: 'Εξερευνώ', + revealPage: 'Αποκάλυψη σελίδας', + resetPage: 'Επαναφορά σελίδας', + mark: 'Επισήμανση τοποθεσίας', + unmark: 'Κατάργηση επισήμανσης', + name: 'Όνομα Hex', + settings: 'Ρυθμίσεις', + pageSettings: 'Ρυθμίσεις σελίδας', + status: 'Κατάσταση', + rescan: 'Εκ νέου σάρωση', + calibrate: 'Μετρώ την διάμετρο', + calibrateReset: 'Επαναφορά βαθμονόμησης', + help: 'Βοήθεια', + change: 'Αλλαγή', + menu: 'Μενού', + clearOverrides: 'Εκκαθάριση παρακάμψεων', + confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + }, + prompts: { + name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', + }, + values: { + on: 'Επί', + off: 'Μακριά από', + none: 'Κανένας', + hexLayer: { + auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', + foreground: 'στρώμα πρώτου πλάνου', + objects: 'συμβολικό στρώμα', + }, + revealBy: { + players: 'Μαρκάρια παίκτη', + characters: 'Μαρκάρια χαρακτήρων', + all: 'Όλες οι μάρκες', + }, + revealMode: { + clear: 'Σαφής', + glimpse: 'Ματιά', + }, + announce: { + all: 'Καθένας', + gm: 'Μόνο GM', + off: 'Μακριά από', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + conceal: 'Απόκρυψη', + }, + }, + settings: { + language: { + label: 'Γλώσσα', + desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', + }, + hexLayer: { + label: 'Εξάγωνο στρώμα', + desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + }, + fillColor: { + label: 'Χρώμα πλήρωσης', + desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Χρώμα περιγράμματος', + desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + }, + labelColor: { + label: 'Χρώμα ετικέτας', + desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', + }, + glimpseColor: { + label: 'Χρώμα Glimpse', + desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + }, + strokeWidth: { + label: 'Πλάτος περιγράμματος', + desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + }, + maxDistance: { + label: 'Εξάγωνο αποκαλύπτουν απόσταση', + desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', + }, + revealDistance: { + label: 'Απόσταση όρασης', + desc: 'Πόσα εξάγωνα γύρω από ένα κινούμενο διακριτικό αποκαλύπτονται (0 έως 20). Το 0 αποκαλύπτει μόνο τα εξάγωνα από τα οποία διέρχεται το διακριτικό.', + }, + lineOfSight: { + label: 'Γραμμή όρασης', + desc: 'Όταν είναι ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο μεταξύ αυτού και του διακριτικού.', + }, + revealPath: { + label: 'Αποκάλυψη κατά μήκος της διαδρομής', + desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', + }, + revealBy: { + label: 'Tokens που αποκαλύπτουν', + desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + }, + revealMode: { + label: 'Λειτουργία αποκάλυψης', + desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + }, + announce: { + label: 'Ανακοινώστε Ανακαλύψεις', + desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', + }, + pingDiscoveries: { + label: 'Ping ανακαλύψεις', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + }, + hideCoveredTokens: { + label: 'Απόκρυψη καλυμμένων κουπονιών', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + }, + }, + status: { + engine: 'Μηχανή παιχνιδιού', + grid: 'Πλέγμα', + layer: 'Εξάγωνο στρώμα', + hexes: 'Εξάγωνα', + named: 'Ονομασμένα εξάγωνα', + icons: 'Διακριτικά τοποθεσίας', + glimpsed: 'Καθαρά εξάγωνα', + pending: 'Τοποθεσίες που περιμένουν γέμισμα', + calibrated: 'Βαθμονομημένο', + overrides: 'Σελίδα παρακάμπτει', + undo: 'Αναίρεση διαθέσιμη', + }, + messages: { + filled: + 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', + revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + confirmReset: + 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', + resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', + undone: + 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', + named: 'Hexes με όνομα "{name}": {count}.', + unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', + marked: + 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', + settingChanged: 'Το {setting} ορίστηκε σε {value}.', + rescanned: + 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + calibrated: + 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + calibrationReset: + 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', + migrated: + 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + pruned: + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + readyHint: + 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + someFailed: + 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + }, + errors: { + noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', + notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', + unknownCommand: 'Άγνωστη εντολή: {command}', + unknownSetting: 'Άγνωστη ρύθμιση: {key}', + unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', + invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', + unexpected: 'Κάτι πήγε στραβά: {message}', + }, + hints: { + noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', + notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + noPolygons: + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', + noHexes: + 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', + unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', + calibrateNeedsTokens: + 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + calibrateFailed: + 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', + }, + help: { + menu: 'Εμφάνιση του μενού.', + fill: 'Καλύψτε τα επιλεγμένα σχεδιασμένα σχήματα με εξάγωνα.', + fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', + undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', + reveal: + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', + conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', + name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', + mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', + unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', + pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', + pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', + rescan: + 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + calibrate: + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', + status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', + journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + help: 'Εμφάνιση αυτής της λίστας.', + handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', + }, + deck: { + subtitle: 'Κατάστρωμα εντολών', + drawDesc: + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + revealDesc: + 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + locationsDesc: + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + toolsDesc: + 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', + footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', + }, + handout: { + versionLabel: 'Εκδοχή', + subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', + overview: { + heading: 'Επισκόπηση', + body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', + }, + quickStart: { + heading: 'Γρήγορη εκκίνηση', + steps: [ + 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', + 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + ], + }, + commands: { + heading: 'Εντολές', + intro: + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + colCommand: 'Εντολή', + colDesc: 'Τι κάνει', + }, + revealing: { + heading: 'Πώς λειτουργεί η αποκάλυψη', + points: [ + 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', + 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', + 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', + 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + ], + }, + locations: { + heading: 'Με όνομα Hexes and Locations', + points: [ + 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + ], + }, + settings: { + heading: 'Ρυθμίσεις', + intro: + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + colKey: 'Κλειδί', + colName: 'Σύνθεση', + colDesc: 'Περιγραφή', + perPage: '(Μπορεί να οριστεί ανά σελίδα.)', + }, + jumpgate: { + heading: 'Jumpgate και Legacy', + points: [ + 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', + 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + ], + }, + upgrading: { + heading: 'Αναβάθμιση από την έκδοση 1', + points: [ + 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', + 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', + 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + ], + colV1: 'Εντολή έκδοσης 1', + colV2: 'Εντολή έκδοσης 2', + }, + troubleshooting: { + heading: 'Αντιμετώπιση προβλημάτων', + points: [ + 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', + 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', + 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', + 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', + ], + }, + languages: { + heading: 'Γλώσσες', + body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + }, + credits: { + heading: 'Πιστώσεις', + original: 'Πρωτότυπο mod από', + maintainer: 'Έκδοση 2 που διατηρείται από', + marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', + support: + 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index ff8b4c5632..71894b75ad 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -1 +1,377 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'La hexploración está lista.', + settings: 'Configuración de hexploración', + languages: 'Elige un idioma', + pageSettings: 'Configuración de página: {page}', + status: 'Estado de exploración: {page}', + help: 'Comandos de hexploración', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Ubicación descubierta', + }, + menu: { + draw: 'Dibujar', + reveal: 'Revelar y ocultar', + locations: 'Ubicaciones', + tools: 'Herramientas', + layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + pageSettingsHelp: + 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', + }, + buttons: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + undo: 'Deshacer relleno', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Restablecer página', + mark: 'Marcar ubicación', + unmark: 'Desmarcar', + name: 'Nombre hexadecimal', + settings: 'Ajustes', + pageSettings: 'Configuración de página', + status: 'Estado', + rescan: 'Volver a escanear', + calibrate: 'Calibrar', + calibrateReset: 'Restablecer calibración', + help: 'Ayuda', + change: 'Cambiar', + menu: 'Menú', + clearOverrides: 'Borrar anulaciones', + confirmReset: 'Sí, eliminar todos los hexágonos', + }, + prompts: { + name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', + }, + values: { + on: 'En', + off: 'Apagado', + none: 'Ninguno', + hexLayer: { + auto: 'Auto (primer plano si está disponible)', + foreground: 'capa de primer plano', + objects: 'capa de token', + }, + revealBy: { + players: 'fichas de jugador', + characters: 'Fichas de personaje', + all: 'Todas las fichas', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vistazo', + }, + announce: { + all: 'Todos', + gm: 'solo GM', + off: 'Apagado', + }, + orientation: { + vertical: 'Hexágono (V)', + horizontal: 'Hexagonal (H)', + }, + fillKind: { + fill: 'Llenar', + fillInverse: 'Relleno inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menús, mensajes y folletos.', + }, + hexLayer: { + label: 'Capa hexagonal', + desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', + }, + fillColor: { + label: 'Color de relleno', + desc: 'Color de nuevos hexágonos. Utilice rgba() para hexágonos transparentes, por ejemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color del borde', + desc: 'Color del contorno de nuevos hexágonos.', + }, + labelColor: { + label: 'Color de la etiqueta', + desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + }, + glimpseColor: { + label: 'Color de vislumbre', + desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + }, + strokeWidth: { + label: 'Ancho del borde', + desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', + }, + maxDistance: { + label: 'Distancia de revelación hexagonal', + desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', + }, + revealDistance: { + label: 'Distancia de visión', + desc: 'Cuántos hexágonos se revelan alrededor de una ficha en movimiento (0 a 20). 0 revela sólo los hexágonos por los que pasa la ficha.', + }, + lineOfSight: { + label: 'Línea de visión', + desc: 'Cuando está activado, un hexágono sólo se revela si no hay ningún hexágono cubierto entre él y la ficha.', + }, + revealPath: { + label: 'Revelar a lo largo del camino', + desc: 'Cuando está activado, se revela cada hexágono por el que pasa una ficha mientras es arrastrada (incluidos los puntos de ruta), no solo dónde se detiene.', + }, + revealBy: { + label: 'Fichas que revelan', + desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', + }, + revealMode: { + label: 'Modo revelar', + desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + }, + announce: { + label: 'Anunciar descubrimientos', + desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', + }, + pingDiscoveries: { + label: 'Descubrimientos de ping', + desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cubiertos', + desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + }, + }, + status: { + engine: 'motor de juego', + grid: 'Red', + layer: 'capa hexagonal', + hexes: 'Hexágonos', + named: 'Hexágonos con nombre', + icons: 'Fichas de ubicación', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Ubicaciones esperando ser llenadas', + calibrated: 'Calibrado', + overrides: 'Anulaciones de página', + undo: 'Deshacer disponible', + }, + messages: { + filled: + 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + revealed: 'Hexágonos revelados: {count}.', + revealedPage: 'Cada hexágono en la página revelado ({count}).', + confirmReset: + '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', + resetPage: 'Hexes eliminados de la página: {count}.', + undone: + 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nombres borrados: {count}.', + marked: + 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', + unmarked: 'Tokens que ya no son ubicaciones: {count}.', + settingChanged: '{setting} establecido en {value}.', + rescanned: + 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + calibrated: + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + calibrationReset: + 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', + migrated: + 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + pruned: + 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', + readyHint: + 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este juego no admite dibujar en la capa de primer plano, por lo que los hexágonos se dibujaron en la capa de fichas.', + someFailed: + 'Hexágonos que no se pudieron dibujar: {count}. Consulte la consola API para obtener más detalles.', + }, + errors: { + noPage: 'No se pudo encontrar la página para trabajar.', + notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', + emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', + nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', + nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', + noTokens: 'Seleccione uno o más tokens primero.', + noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', + nothingToUndo: 'No hay ningún relleno que deshacer.', + unknownCommand: 'Comando desconocido: {command}', + unknownSetting: 'Configuración desconocida: {key}', + unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', + invalidValue: '"{value}" no es un valor válido para {key}.', + calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', + unexpected: 'Algo salió mal: {message}', + }, + hints: { + noPage: 'Abra la página en la que desea trabajar o seleccione algo en ella.', + notHex: + 'Establezca la cuadrícula de la página en Hex (V) o Hex (H) en Configuración de página.', + noPolygons: + 'Dibuja un polígono, un rectángulo, una elipse o una forma a mano alzada alrededor del área, selecciónala y vuelve a intentarlo.', + emptyArea: + 'Dibuja una forma más grande o verifica la configuración de la cuadrícula de la página.', + tooMany: 'Rellene un área más pequeña o divida el área en varias formas.', + noHexes: + 'Los hexágonos están en primer plano o en la capa de fichas; cambie a esa capa para seleccionarlas.', + unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', + unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', + calibrateNeedsTokens: + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + calibrateFailed: + 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + unexpected: 'Los detalles se encuentran en el registro de la consola API.', + }, + help: { + menu: 'Mostrar el menú.', + fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', + fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', + undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + reveal: + 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', + revealPage: 'Revela cada hexágono de la página sin anuncios.', + conceal: 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', + explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', + name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', + mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', + unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + set: 'Cambie una configuración o muestre todas las configuraciones.', + pageSet: 'Anula una configuración de revelación solo en la página actual.', + pageClear: 'Elimine las anulaciones de la página actual.', + rescan: + 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + calibrate: + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + calibrateReset: 'Elimina la calibración de la página actual.', + status: 'Muestra lo que Hexploration sabe sobre la página actual.', + journal: 'Reconstruya los folletos de Ayuda y Comando.', + help: 'Muestra esta lista.', + handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', + }, + deck: { + subtitle: 'Cubierta de mando', + drawDesc: + 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + revealDesc: + 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + locationsDesc: + 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', + toolsDesc: + 'Configuraciones, anulaciones de páginas, estado, volver a escanear páginas copiadas y calibrar la cuadrícula.', + footer: 'Consulte el folleto "{help}" para obtener instrucciones completas.', + }, + handout: { + versionLabel: 'Versión', + subtitle: 'Exploración hexágono por hexágono para Roll20', + footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', + overview: { + heading: 'Descripción general', + body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + demo: 'Vea una breve demostración (de la versión 1)', + }, + quickStart: { + heading: 'Inicio rápido', + steps: [ + 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', + 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', + 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Dominio', + colDesc: 'que hace', + }, + revealing: { + heading: 'Cómo funciona la revelación', + points: [ + 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', + 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + ], + }, + locations: { + heading: 'Hexágonos y ubicaciones con nombre', + points: [ + 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', + 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + ], + }, + settings: { + heading: 'Ajustes', + intro: + 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + colKey: 'Llave', + colName: 'Configuración', + colDesc: 'Descripción', + perPage: '(Se puede configurar por página).', + }, + jumpgate: { + heading: 'Jumpgate y legado', + points: [ + 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', + 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + ], + }, + upgrading: { + heading: 'Actualización desde la versión 1', + points: [ + 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', + 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', + 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + ], + colV1: 'Comando versión 1', + colV2: 'Comando versión 2', + }, + troubleshooting: { + heading: 'Solución de problemas', + points: [ + 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', + 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', + 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versión 2 mantenida por', + marketplace: 'Paquetes de arte de Ada en Roll20 Marketplace', + support: + 'Si encuentra un error o tiene una idea, publíquelo en el foro Roll20 Mod o abra un problema en GitHub e incluya cualquier mensaje del registro de la consola API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index ff8b4c5632..a919e12f5b 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -1 +1,373 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Hexploration on valmis.', + settings: 'Tutkimusasetukset', + languages: 'Valitse kieli', + pageSettings: 'Sivuasetukset: {page}', + status: 'Tutkimuksen tila: {page}', + help: 'Hexploration komennot', + confirm: 'Ole hyvä ja vahvista', + }, + discovery: { + title: 'Sijainti löydetty', + }, + menu: { + draw: 'Piirrä', + reveal: 'Paljasta ja piilota', + locations: 'Sijainnit', + tools: 'Työkalut', + layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + pageSettingsHelp: + 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', + }, + buttons: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + undo: 'Kumoa täyttö', + reveal: 'Paljastaa', + conceal: 'Salata', + explore: 'Tutkia', + revealPage: 'Paljasta sivu', + resetPage: 'Nollaa sivu', + mark: 'Merkitse sijainti', + unmark: 'Poista merkintä', + name: 'Nimi Hex', + settings: 'Asetukset', + pageSettings: 'Sivun asetukset', + status: 'Status', + rescan: 'Skannaa uudelleen', + calibrate: 'Kalibroida', + calibrateReset: 'Nollaa kalibrointi', + help: 'Auttaa', + change: 'Muuttaa', + menu: 'Valikko', + clearOverrides: 'Tyhjennä ohitukset', + confirmReset: 'Kyllä, poista kaikki heksit', + }, + prompts: { + name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', + }, + values: { + on: 'Päällä', + off: 'Pois', + none: 'Ei mitään', + hexLayer: { + auto: 'Automaattinen (etualalla, jos saatavilla)', + foreground: 'etualan kerros', + objects: 'merkkikerros', + }, + revealBy: { + players: 'Pelaajan merkit', + characters: 'Hahmomerkit', + all: 'Kaikki merkit', + }, + revealMode: { + clear: 'Selkeä', + glimpse: 'Vilkkaus', + }, + announce: { + all: 'Kaikki', + gm: 'Vain GM', + off: 'Pois', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Täyttää', + fillInverse: 'Käänteinen täyttö', + conceal: 'Salata', + }, + }, + settings: { + language: { + label: 'Kieli', + desc: 'Valikkojen, viestien ja monisteiden kieli.', + }, + hexLayer: { + label: 'Hex kerros', + desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + }, + fillColor: { + label: 'Täyttöväri', + desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Reunuksen väri', + desc: 'Uusien kuusioiden ääriviivan väri.', + }, + labelColor: { + label: 'Etiketin väri', + desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + }, + strokeWidth: { + label: 'Reunan leveys', + desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', + }, + maxDistance: { + label: 'Hex paljastaa etäisyyttä', + desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', + }, + revealDistance: { + label: 'Näköetäisyys', + desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', + }, + lineOfSight: { + label: 'Näkökenttä', + desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', + }, + revealPath: { + label: 'Paljasta polun varrella', + desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + }, + revealBy: { + label: 'Tokenit jotka paljastavat', + desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + }, + revealMode: { + label: 'Paljastustila', + desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + }, + announce: { + label: 'Ilmoita löydökset', + desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', + }, + pingDiscoveries: { + label: 'Ping löydöt', + desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', + }, + hideCoveredTokens: { + label: 'Piilota peitetyt rahakkeet', + desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + }, + }, + status: { + engine: 'Pelin moottori', + grid: 'Ruudukko', + layer: 'Hex kerros', + hexes: 'Hexes', + named: 'Nimetyt heksat', + icons: 'Sijaintitunnukset', + glimpsed: 'Näytetyt kuusiot', + pending: 'Täyttöä odottavat paikat', + calibrated: 'Kalibroitu', + overrides: 'Sivun ohitukset', + undo: 'Kumoa käytettävissä', + }, + messages: { + filled: + 'Täyttö valmis. Heksat piirretty: {created}. Uudelleen muotoiltu: {restyled}. Piilotetut sijainnit: {icons}.', + revealed: 'Heksat paljastettiin: {count}.', + revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', + confirmReset: + 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Heksit poistettu sivulta: {count}.', + undone: + 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksaalit nimeltä "{name}": {count}.', + unnamed: 'Poistetut nimet: {count}.', + marked: + 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + settingChanged: '{setting} asetettu arvoon {value}.', + rescanned: + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + calibrated: + 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + calibrationReset: + 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', + migrated: + 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + pruned: + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', + readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + }, + warnings: { + foregroundUnavailable: + 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', + }, + errors: { + noPage: 'Työstettävää sivua ei löytynyt.', + notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', + emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', + tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', + nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + noTokens: 'Valitse ensin yksi tai useampi merkki.', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + nothingToUndo: 'Kumoavaa täyttöä ei ole.', + unknownCommand: 'Tuntematon komento: {command}', + unknownSetting: 'Tuntematon asetus: {key}', + unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', + invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', + calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', + calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + unexpected: 'Jotain meni pieleen: {message}', + }, + hints: { + noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', + notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + noPolygons: + 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', + emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', + tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', + noHexes: + 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', + unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', + calibrateNeedsTokens: + 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + calibrateFailed: + 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', + }, + help: { + menu: 'Näytä valikko.', + fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', + reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + explore: + 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', + resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', + mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', + unmark: 'Estä valittujen merkkien piilottaminen.', + set: 'Muuta asetusta tai näytä kaikki asetukset.', + pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', + pageClear: 'Poista nykyisen sivun ohitukset.', + rescan: + 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + calibrate: + 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + calibrateReset: 'Poista nykyisen sivun kalibrointi.', + status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', + journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + help: 'Näytä tämä luettelo.', + handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', + }, + deck: { + subtitle: 'Komentolevy', + drawDesc: + 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + revealDesc: + 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + locationsDesc: + 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + toolsDesc: + 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', + footer: 'Katso täydelliset ohjeet monisteesta "{help}".', + }, + handout: { + versionLabel: 'Versio', + subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', + overview: { + heading: 'Yleiskatsaus', + body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + demo: 'Katso lyhyt esittely (versiosta 1)', + }, + quickStart: { + heading: 'Pika-aloitus', + steps: [ + 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', + 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', + 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + ], + }, + commands: { + heading: 'komennot', + intro: + 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', + colCommand: 'Komento', + colDesc: 'Mitä se tekee', + }, + revealing: { + heading: 'Kuinka paljastaminen toimii', + points: [ + 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', + 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', + 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', + 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + ], + }, + locations: { + heading: 'Nimetty Heksit ja sijainnit', + points: [ + 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', + 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + ], + }, + settings: { + heading: 'Asetukset', + intro: + 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + colKey: 'Avain', + colName: 'Asetus', + colDesc: 'Kuvaus', + perPage: '(Voidaan asettaa sivukohtaisesti.)', + }, + jumpgate: { + heading: 'Jumpgate ja Legacy', + points: [ + 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', + 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', + 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + ], + }, + upgrading: { + heading: 'Päivitys versiosta 1', + points: [ + 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', + 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', + 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + ], + colV1: 'Version 1 komento', + colV2: 'Version 2 komento', + }, + troubleshooting: { + heading: 'Vianetsintä', + points: [ + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', + 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', + 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', + 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', + ], + }, + languages: { + heading: 'Kielet', + body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + }, + credits: { + heading: 'Krediitit', + original: 'Alkuperäinen mod', + maintainer: 'Versio 2 ylläpitäjä', + marketplace: 'Adan taidepaketit Roll20 Marketplacessa', + support: + 'Jos löydät virheen tai sinulla on idea, kirjoita viesti Roll20 Mod -foorumille tai avaa ongelma GitHubissa ja sisällytä kaikki viestit API-konsolin lokista.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index ff8b4c5632..1e615953aa 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -1 +1,378 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: "L'exploration est prête.", + settings: "Paramètres d'exploration", + languages: 'Choisissez une langue', + pageSettings: 'Paramètres de la page : {page}', + status: "Statut d'exploration : {page}", + help: "Commandes d'exploration", + confirm: 'Veuillez confirmer', + }, + discovery: { + title: 'Emplacement découvert', + }, + menu: { + draw: 'Dessiner', + reveal: 'Révéler et masquer', + locations: 'Emplacements', + tools: 'Outils', + layerInUse: 'De nouveaux hexagones sont dessinés sur le {layer}.', + pageSettingsHelp: + "Ces paramètres s'appliquent uniquement à cette page. Les paramètres marqués ★ remplacent les paramètres globaux.", + }, + buttons: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + undo: 'Annuler le remplissage', + reveal: 'Révéler', + conceal: 'Cacher', + explore: 'Explorer', + revealPage: 'Révéler la page', + resetPage: 'Page de réinitialisation', + mark: "Marquer l'emplacement", + unmark: 'Décocher', + name: 'Nom Hex', + settings: 'Paramètres', + pageSettings: 'Paramètres des pages', + status: 'Statut', + rescan: 'Nouvelle analyse', + calibrate: 'Étalonner', + calibrateReset: "Réinitialiser l'étalonnage", + help: 'Aide', + change: 'Changement', + menu: 'Menu', + clearOverrides: 'Effacer les remplacements', + confirmReset: 'Oui, supprimer tous les hexagones', + }, + prompts: { + name: 'Nom du lieu (laissez vide pour effacer)', + }, + values: { + on: 'Sur', + off: 'Désactivé', + none: 'Aucun', + hexLayer: { + auto: 'Auto (premier plan si disponible)', + foreground: 'calque de premier plan', + objects: 'couche de jetons', + }, + revealBy: { + players: 'Jetons de joueur', + characters: 'Jetons de personnage', + all: 'Tous les jetons', + }, + revealMode: { + clear: 'Clair', + glimpse: 'Aperçu', + }, + announce: { + all: 'Tout le monde', + gm: 'GM uniquement', + off: 'Désactivé', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + conceal: 'Cacher', + }, + }, + settings: { + language: { + label: 'Langue', + desc: 'Langue des menus, des messages et des documents.', + }, + hexLayer: { + label: 'Couche hexagonale', + desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', + }, + fillColor: { + label: 'Couleur de remplissage', + desc: 'Couleur des nouveaux hexagones. Utilisez rgba() pour les hexagones transparents, par exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Couleur de la bordure', + desc: 'Couleur du contour des nouveaux hexagones.', + }, + labelColor: { + label: "Couleur de l'étiquette", + desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + }, + glimpseColor: { + label: 'Aperçu de la couleur', + desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + }, + strokeWidth: { + label: 'Largeur de la bordure', + desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + }, + maxDistance: { + label: 'Distance de révélation hexagonale', + desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", + }, + revealDistance: { + label: 'Distance de vue', + desc: "Combien d'hexagones autour d'un jeton en mouvement sont révélés (0 à 20). 0 révèle uniquement les hexagones traversés par le jeton.", + }, + lineOfSight: { + label: 'Ligne de vue', + desc: "Lorsque cette option est activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre lui et le jeton.", + }, + revealPath: { + label: 'Révéler le long du chemin', + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + }, + revealBy: { + label: 'Des jetons qui révèlent', + desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", + }, + revealMode: { + label: 'Mode Révéler', + desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + }, + announce: { + label: 'Annoncer des découvertes', + desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", + }, + pingDiscoveries: { + label: 'Découvertes Ping', + desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", + }, + hideCoveredTokens: { + label: 'Masquer les jetons couverts', + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + }, + }, + status: { + engine: 'Moteur de jeu', + grid: 'Grille', + layer: 'Couche hexagonale', + hexes: 'Hexagones', + named: 'Hexs nommés', + icons: 'Jetons de localisation', + glimpsed: 'Hexs aperçus', + pending: "Emplacements en attente d'un remplissage", + calibrated: 'Calibré', + overrides: 'Remplacements de page', + undo: 'Annuler disponible', + }, + messages: { + filled: + 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + revealed: 'Hexs révélés : {count}.', + revealedPage: 'Chaque hexagone de la page révélé ({count}).', + confirmReset: + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', + resetPage: 'Hexs supprimés de la page : {count}.', + undone: + 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', + named: 'Hexs nommés "{name}" : {count}.', + unnamed: 'Noms effacés : {count}.', + marked: + 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', + settingChanged: '{setting} défini sur {value}.', + rescanned: + 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + calibrated: + 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + calibrationReset: + 'Calibrage supprimé. Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + journalRebuilt: 'Les documents « {help} » et « {deck} » ont été reconstruits.', + migrated: + "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", + pruned: + "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + readyHint: + 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + }, + warnings: { + foregroundUnavailable: + 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', + someFailed: + "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + }, + errors: { + noPage: 'Impossible de trouver la page sur laquelle travailler.', + notHex: "Cette page n'utilise pas de grille hexadécimale.", + noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', + emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", + tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", + nothingToConceal: 'Sélectionnez des formes dessinées ou des jetons à masquer.', + nothingToReveal: 'Sélectionnez des hexagones, des formes dessinées ou des jetons à révéler.', + noTokens: "Sélectionnez d'abord un ou plusieurs jetons.", + noHexes: + "Sélectionnez d'abord un ou plusieurs hexagones (ou des jetons placés sur des hexagones).", + nothingToUndo: "Il n'y a aucun remplissage à défaire.", + unknownCommand: 'Commande inconnue : {command}', + unknownSetting: 'Paramètre inconnu : {key}', + unknownPageSetting: 'Paramètres pouvant être définis par page : {keys}', + invalidValue: '"{value}" n\'est pas une valeur valide pour {key}.', + calibrateNeedsTokens: 'Sélectionnez un ou deux jetons accrochés aux centres des hexagones.', + calibrateFailed: 'Ces jetons ne peuvent pas être utilisés pour calibrer.', + unexpected: "Un problème s'est produit : {message}", + }, + hints: { + noPage: + 'Ouvrez la page sur laquelle vous souhaitez travailler ou sélectionnez quelque chose dessus.', + notHex: 'Définissez la grille de la page sur Hex (V) ou Hex (H) dans Paramètres de page.', + noPolygons: + 'Dessinez un polygone, un rectangle, une ellipse ou une forme à main levée autour de la zone, sélectionnez-le, puis réessayez.', + emptyArea: 'Dessinez une forme plus grande ou vérifiez les paramètres de la grille de la page.', + tooMany: 'Remplissez une zone plus petite ou divisez la zone en plusieurs formes.', + noHexes: + 'Les hexagones sont au premier plan ou sur la couche de jetons ; passez à ce calque pour les sélectionner.', + unknownCommand: 'Tapez !hexploration help pour lister les commandes.', + unknownSetting: 'Tapez !hexploration set pour voir tous les paramètres.', + calibrateNeedsTokens: + "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + calibrateFailed: + "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + unexpected: 'Les détails se trouvent dans le journal de la console API.', + }, + help: { + menu: 'Afficher le menu.', + fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', + fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", + undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + reveal: + 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', + revealPage: 'Révélez chaque hexagone de la page sans annonce.', + conceal: + 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', + explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", + mark: 'Transformez les jetons sélectionnés en emplacements cachés.', + unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", + set: 'Modifiez un paramètre ou affichez tous les paramètres.', + pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', + pageClear: 'Supprimez les remplacements de la page actuelle.', + rescan: + 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + calibrate: + 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', + calibrateReset: 'Supprimez le calibrage de la page actuelle.', + status: 'Montre ce que Hexploration sait de la page actuelle.', + journal: "Reconstruisez les documents d'aide et de commande.", + help: 'Montrez cette liste.', + handout: 'Les instructions complètes se trouvent dans le document « {name} ».', + }, + deck: { + subtitle: 'Pont de commandement', + drawDesc: + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + revealDesc: + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + locationsDesc: + "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", + toolsDesc: + 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Exploration hex par hex pour Roll20', + footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', + overview: { + heading: 'Aperçu', + body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + demo: 'Regardez une courte démo (à partir de la version 1)', + }, + quickStart: { + heading: 'Démarrage rapide', + steps: [ + 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', + 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', + 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", + "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + ], + }, + commands: { + heading: 'Commandes', + intro: + 'Seuls les MJ peuvent utiliser ces commandes. La plupart agissent sur les objets sélectionnés ; le reste agit sur la page que vous consultez.', + colCommand: 'Commande', + colDesc: 'Ce que ça fait', + }, + revealing: { + heading: 'Comment fonctionne la révélation', + points: [ + 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', + "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + ], + }, + locations: { + heading: 'Hexs et emplacements nommés', + points: [ + 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', + "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", + "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + ], + }, + settings: { + heading: 'Paramètres', + intro: + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + colKey: 'Clé', + colName: 'Paramètre', + colDesc: 'Description', + perPage: '(Peut être défini par page.)', + }, + jumpgate: { + heading: 'Jumpgate et héritage', + points: [ + "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", + "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", + ], + }, + upgrading: { + heading: 'Mise à niveau à partir de la version 1', + points: [ + "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", + 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', + 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', + "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + ], + colV1: 'Commande version 1', + colV2: 'Commande version 2', + }, + troubleshooting: { + heading: 'Dépannage', + points: [ + "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', + "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", + ], + }, + languages: { + heading: 'Langues', + body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + }, + credits: { + heading: 'Crédits', + original: 'Mod original par', + maintainer: 'Version 2 maintenue par', + marketplace: "Les packs artistiques d'Ada sur le Marketplace Roll20", + support: + 'Si vous trouvez un bug ou avez une idée, publiez-le sur le forum Roll20 Mod ou ouvrez un problème sur GitHub et incluez tous les messages du journal de la console API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index ff8b4c5632..0ea4d422dc 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -1 +1,365 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'החקירה מוכנה.', + settings: 'הגדרות החקירה', + languages: 'בחר שפה', + pageSettings: 'הגדרות דף: {page}', + status: 'סטטוס החקירה: {page}', + help: 'פקודות החקירה', + confirm: 'אנא אשר', + }, + discovery: { + title: 'מיקום התגלה', + }, + menu: { + draw: 'לִמְשׁוֹך', + reveal: 'לגלות ולהסתיר', + locations: 'מיקומים', + tools: 'כְּלֵי עֲבוֹדָה', + layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + pageSettingsHelp: + 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', + }, + buttons: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + undo: 'בטל מילוי', + reveal: 'לְגַלוֹת', + conceal: 'לְהַסתִיר', + explore: 'לַחקוֹר', + revealPage: 'גלה עמוד', + resetPage: 'אפס דף', + mark: 'סמן מיקום', + unmark: 'בטל את הסימון', + name: 'שם הקס', + settings: 'הגדרות', + pageSettings: 'הגדרות עמוד', + status: 'סטָטוּס', + rescan: 'סרוק מחדש', + calibrate: 'לְדַרֵג', + calibrateReset: 'אפס כיול', + help: 'עֶזרָה', + change: 'לְשַׁנוֹת', + menu: 'תַפרִיט', + clearOverrides: 'נקה עקיפות', + confirmReset: 'כן, הסר את כל המשושים', + }, + prompts: { + name: 'שם המיקום (השאירו ריק כדי לנקות)', + }, + values: { + on: 'עַל', + off: 'כבוי', + none: 'אַף לֹא אֶחָד', + hexLayer: { + auto: 'אוטומטי (בחזית אם זמין)', + foreground: 'שכבת חזית', + objects: 'שכבת אסימונים', + }, + revealBy: { + players: 'אסימוני שחקן', + characters: 'אסימוני תווים', + all: 'כל האסימונים', + }, + revealMode: { + clear: 'בָּרוּר', + glimpse: 'הֲצָצָה', + }, + announce: { + all: 'כֹּל אֶחָד', + gm: 'GM בלבד', + off: 'כבוי', + }, + orientation: { + vertical: 'משושה (V)', + horizontal: 'משושה (H)', + }, + fillKind: { + fill: 'לְמַלֵא', + fillInverse: 'מילוי הפוך', + conceal: 'לְהַסתִיר', + }, + }, + settings: { + language: { + label: 'שָׂפָה', + desc: 'שפה לתפריטים, הודעות ודפי מידע.', + }, + hexLayer: { + label: 'שכבת משושה', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + }, + fillColor: { + label: 'צבע מילוי', + desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'צבע גבול', + desc: 'צבע קווי המתאר של משושות חדשות.', + }, + labelColor: { + label: 'צבע התווית', + desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + }, + glimpseColor: { + label: 'צבע הצצה', + desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + }, + strokeWidth: { + label: 'רוחב גבול', + desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', + }, + maxDistance: { + label: 'מרחק חשיפת משושה', + desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', + }, + revealDistance: { + label: 'מרחק ראייה', + desc: 'כמה משושים סביב אסימון נע נחשפים (0 עד 20). 0 חושף רק את המשושים שהאסימון עובר דרכם.', + }, + lineOfSight: { + label: 'קו ראייה', + desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', + }, + revealPath: { + label: 'גלה לאורך הנתיב', + desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', + }, + revealBy: { + label: 'אסימונים שחושפים', + desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', + }, + revealMode: { + label: 'מצב חשיפה', + desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + }, + announce: { + label: 'הכריזו על תגליות', + desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", + }, + pingDiscoveries: { + label: 'פינג תגליות', + desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', + }, + hideCoveredTokens: { + label: 'הסתר אסימונים מכוסים', + desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + }, + }, + status: { + engine: 'מנוע משחק', + grid: 'רֶשֶׁת', + layer: 'שכבת משושה', + hexes: 'משושים', + named: 'ששים בשם', + icons: 'אסימוני מיקום', + glimpsed: 'משושים נוצצים', + pending: 'מיקומים ממתינים למילוי', + calibrated: 'מְכוּיָל', + overrides: 'עקיפת עמוד', + undo: 'בטל זמין', + }, + messages: { + filled: + 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', + revealed: 'נחשפו משושים: {count}.', + revealedPage: 'כל hex בדף נחשף ({count}).', + confirmReset: + 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', + resetPage: 'הקסים הוסרו מהדף: {count}.', + undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', + named: 'hexes בשם "{name}": {count}.', + unnamed: 'שמות נוקו: {count}.', + marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', + settingChanged: '{setting} מוגדר ל-{value}.', + rescanned: + 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + calibrated: + 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + calibrationReset: + 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', + migrated: + 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + pruned: + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + readyHint: 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', + someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + }, + errors: { + noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', + notHex: 'דף זה אינו משתמש ברשת משושה.', + noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', + tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', + nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', + noTokens: 'תחילה בחר אסימון אחד או יותר.', + noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + nothingToUndo: 'אין מילוי לבטל.', + unknownCommand: 'פקודה לא ידועה: {command}', + unknownSetting: 'הגדרה לא ידועה: {key}', + unknownPageSetting: 'הגדרות שניתן להגדיר לכל עמוד: {keys}', + invalidValue: '"{value}" אינו ערך חוקי עבור {key}.', + calibrateNeedsTokens: 'בחר אסימון אחד או שניים שהוצמדו למרכזי משושה.', + calibrateFailed: 'לא ניתן להשתמש באסימונים האלה לכיול.', + unexpected: 'משהו השתבש: {message}', + }, + hints: { + noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', + notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + noPolygons: + 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', + noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', + unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', + unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', + calibrateNeedsTokens: + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + calibrateFailed: + 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', + }, + help: { + menu: 'הצג את התפריט.', + fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', + undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', + revealPage: 'חשוף כל קסם בדף ללא הודעות.', + conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', + resetPage: 'הסר כל hex בדף (שואל תחילה).', + name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', + unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + set: 'שנה הגדרה או הצג את כל ההגדרות.', + pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', + pageClear: 'הסר את העקיפות של הדף הנוכחי.', + rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', + calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + calibrateReset: 'הסר את הכיול של הדף הנוכחי.', + status: 'הצג מה Hexploration יודע על הדף הנוכחי.', + journal: 'בנה מחדש את דפי העזרה והפקודה.', + help: 'הצג רשימה זו.', + handout: 'ההנחיות המלאות נמצאות בדף "{name}".', + }, + deck: { + subtitle: 'סיפון פיקוד', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + revealDesc: + 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + locationsDesc: + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', + footer: 'עיין בדף "{help}" להנחיות מלאות.', + }, + handout: { + versionLabel: 'גִרְסָה', + subtitle: 'חקירה משושה אחר קסם עבור Roll20', + footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', + overview: { + heading: 'סקירה כללית', + body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + demo: 'צפו בהדגמה קצרה (מגרסה 1)', + }, + quickStart: { + heading: 'התחלה מהירה', + steps: [ + 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', + 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + ], + }, + commands: { + heading: 'פקודות', + intro: + 'רק GMs יכולים להשתמש בפקודות אלה. רובם פועלים על האובייקטים שנבחרו; השאר פועלים בדף שבו אתה צופה.', + colCommand: 'פְּקוּדָה', + colDesc: 'מה זה עושה', + }, + revealing: { + heading: 'איך עובד גילוי', + points: [ + 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', + 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + ], + }, + locations: { + heading: 'בשם משושים ומיקומים', + points: [ + 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', + 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', + 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + ], + }, + settings: { + heading: 'הגדרות', + intro: + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + colKey: 'מַפְתֵחַ', + colName: 'סְבִיבָה', + colDesc: 'תֵאוּר', + perPage: '(ניתן להגדיר לכל עמוד.)', + }, + jumpgate: { + heading: 'Jumpgate ומורשת', + points: [ + 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', + 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', + 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', + ], + }, + upgrading: { + heading: 'משדרג מגרסה 1', + points: [ + 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', + 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', + 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + ], + colV1: 'פקודה גרסה 1', + colV2: 'פקודה גרסה 2', + }, + troubleshooting: { + heading: 'פתרון בעיות', + points: [ + 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', + 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', + 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', + ], + }, + languages: { + heading: 'שפות', + body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + }, + credits: { + heading: 'קרדיטים', + original: 'מוד מקורי מאת', + maintainer: 'גרסה 2 מתוחזקת על ידי', + marketplace: 'חבילות האמנות של עדה ב-Roll20 Marketplace', + support: + 'אם אתה מוצא באג או יש לך רעיון, פרסם בפורום Roll20 Mod או פתח בעיה ב-GitHub, וכלול הודעות כלשהן מיומן מסוף ה-API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index ff8b4c5632..63326b0418 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -1 +1,376 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'A hexploration készen áll.', + settings: 'Hexexploration beállítások', + languages: 'Válasszon nyelvet', + pageSettings: 'Oldalbeállítások: {page}', + status: 'Heti feltárás állapota: {page}', + help: 'Hexploration parancsok', + confirm: 'Kérjük, erősítse meg', + }, + discovery: { + title: 'Hely felfedezve', + }, + menu: { + draw: 'Rajzolj', + reveal: 'Felfedni és elrejteni', + locations: 'Helyszínek', + tools: 'Eszközök', + layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + pageSettingsHelp: + 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', + }, + buttons: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + undo: 'Kitöltés visszavonása', + reveal: 'Felfedni', + conceal: 'Elrejteni', + explore: 'Fedezze fel', + revealPage: 'Oldal feltárása', + resetPage: 'Oldal visszaállítása', + mark: 'Hely megjelölése', + unmark: 'Törölje a jelölést', + name: 'Név Hex', + settings: 'Beállítások elemre', + pageSettings: 'Oldalbeállítások', + status: 'Állapot', + rescan: 'Újraszkennelés', + calibrate: 'Kalibrálni', + calibrateReset: 'Kalibrálás visszaállítása', + help: 'Segítség', + change: 'Változás', + menu: 'Menü', + clearOverrides: 'Felülbírálások törlése', + confirmReset: 'Igen, távolítsa el az összes hexát', + }, + prompts: { + name: 'Helynév (a törléshez hagyja üresen)', + }, + values: { + on: 'On', + off: 'Le', + none: 'Egyik sem', + hexLayer: { + auto: 'Automatikus (előtérben, ha elérhető)', + foreground: 'előtér réteg', + objects: 'token réteg', + }, + revealBy: { + players: 'Játékos tokenek', + characters: 'Karakter tokenek', + all: 'Minden token', + }, + revealMode: { + clear: 'Világos', + glimpse: 'Bepillantás', + }, + announce: { + all: 'Mindenki', + gm: 'Csak GM', + off: 'Le', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Töltse ki', + fillInverse: 'Inverz kitöltés', + conceal: 'Elrejteni', + }, + }, + settings: { + language: { + label: 'Nyelv', + desc: 'A menük, üzenetek és tájékoztatók nyelve.', + }, + hexLayer: { + label: 'Hatlapos réteg', + desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + }, + fillColor: { + label: 'Kitöltés színe', + desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Szegély színe', + desc: 'Az új hatszögek körvonalának színe.', + }, + labelColor: { + label: 'Címke színe', + desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + }, + strokeWidth: { + label: 'Határ szélessége', + desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', + }, + maxDistance: { + label: 'Hex Reveal távolság', + desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', + }, + revealDistance: { + label: 'Látótávolság', + desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + }, + lineOfSight: { + label: 'Látóvonal', + desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', + }, + revealPath: { + label: 'Fedezd fel az ösvényen', + desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + }, + revealBy: { + label: 'Tokenek, amelyek felfedik', + desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + }, + revealMode: { + label: 'Felfedezési mód', + desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + }, + announce: { + label: 'Hirdesse a felfedezéseket', + desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', + }, + pingDiscoveries: { + label: 'Ping felfedezések', + desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', + }, + hideCoveredTokens: { + label: 'Fedett tokenek elrejtése', + desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + }, + }, + status: { + engine: 'Játék motor', + grid: 'Rács', + layer: 'Hatlapos réteg', + hexes: 'Hexák', + named: 'Elnevezett hexák', + icons: 'Helyjelzők', + glimpsed: 'Megpillantott hatszögek', + pending: 'Betöltésre váró helyek', + calibrated: 'Kalibrálva', + overrides: 'Oldal felülbírálása', + undo: 'Visszavonás elérhető', + }, + messages: { + filled: + 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', + revealed: 'Felfedezett hatszögek: {count}.', + revealedPage: 'Az oldalon minden hex látható ({count}).', + confirmReset: + 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + resetPage: 'Az oldalról eltávolított hatszögek: {count}.', + undone: + 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', + named: '"{name}" nevű hatszögek: {count}.', + unnamed: 'Törölt nevek: {count}.', + marked: + 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + unmarked: 'Tokenek, amelyek már nem helyek: {count}.', + settingChanged: '{setting} értéke {value}.', + rescanned: + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + calibrated: + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + calibrationReset: + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', + journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + migrated: + 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + pruned: + 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + readyHint: + 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + }, + warnings: { + foregroundUnavailable: + 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', + }, + errors: { + noPage: 'Nem található az oldal, amelyen dolgozni kellene.', + notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', + emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', + nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + nothingToReveal: + 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + noTokens: 'Először válasszon ki egy vagy több tokent.', + noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + nothingToUndo: 'Nincs visszavonható kitöltés.', + unknownCommand: 'Ismeretlen parancs: {command}', + unknownSetting: 'Ismeretlen beállítás: {key}', + unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', + invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', + calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', + unexpected: 'Hiba történt: {message}', + }, + hints: { + noPage: 'Nyissa meg azt az oldalt, amelyen dolgozni szeretne, vagy válasszon rajta valamit.', + notHex: 'Állítsa az oldalrácsot Hex (V) vagy Hex (H) értékre az Oldalbeállításokban.', + noPolygons: + 'Rajzoljon sokszöget, téglalapot, ellipszist vagy szabadkézi alakzatot a terület köré, jelölje ki, majd próbálkozzon újra.', + emptyArea: 'Rajzoljon nagyobb alakzatot, vagy ellenőrizze az oldalrács beállításait.', + tooMany: 'Töltsön ki egy kisebb területet, vagy ossza fel több formára.', + noHexes: + 'A hatszögek az előtérben vagy a token rétegben vannak; váltson át arra a rétegre a kijelölésükhöz.', + unknownCommand: 'Írja be a !hexploration help parancsot a parancsok listázásához.', + unknownSetting: 'Minden beállítás megtekintéséhez írja be a !hexploration set parancsot.', + calibrateNeedsTokens: + 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', + calibrateFailed: + 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + unexpected: 'A részletek az API-konzol naplójában találhatók.', + }, + help: { + menu: 'Mutasd a menüt.', + fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', + undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', + reveal: + 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', + revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + conceal: + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', + name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', + unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', + set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', + pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', + pageClear: 'Távolítsa el az aktuális oldal felülírásait.', + rescan: + 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + calibrate: + 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', + status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', + journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + help: 'Mutasd ezt a listát.', + handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', + }, + deck: { + subtitle: 'Parancsnoki pakli', + drawDesc: + 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', + revealDesc: + 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + locationsDesc: + 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + toolsDesc: + 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', + footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', + }, + handout: { + versionLabel: 'Változat', + subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', + overview: { + heading: 'Áttekintés', + body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + }, + quickStart: { + heading: 'Gyors kezdés', + steps: [ + 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', + 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', + 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', + ], + }, + commands: { + heading: 'Parancsok', + intro: + 'Csak a GM-ek használhatják ezeket a parancsokat. A legtöbb a kiválasztott objektumokra hat; a többi az éppen megtekintett oldalon működik.', + colCommand: 'Parancs', + colDesc: 'Mit csinál', + }, + revealing: { + heading: 'Hogyan működik a feltárás', + points: [ + 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', + 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', + 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', + 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', + 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + ], + }, + locations: { + heading: 'Hexák és helyek neve', + points: [ + 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', + 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + ], + }, + settings: { + heading: 'Beállítások elemre', + intro: + 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + colKey: 'Kulcsfontosságú', + colName: 'Beállítás', + colDesc: 'Leírás', + perPage: '(Oldalonként beállítható.)', + }, + jumpgate: { + heading: 'Jumpgate és Legacy', + points: [ + 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', + 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + ], + }, + upgrading: { + heading: 'Frissítés az 1-es verzióról', + points: [ + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', + 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + ], + colV1: '1-es verzió parancs', + colV2: '2-es verzió parancs', + }, + troubleshooting: { + heading: 'Hibaelhárítás', + points: [ + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', + 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', + 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + ], + }, + languages: { + heading: 'Nyelvek', + body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + }, + credits: { + heading: 'Kredit', + original: 'Eredeti mod által', + maintainer: 'A 2-es verziót karbantartja', + marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', + support: + 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index ff8b4c5632..d03842b0f4 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -1 +1,376 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: "L'esplorazione è pronta.", + settings: 'Impostazioni di esplorazione', + languages: 'Scegli una lingua', + pageSettings: 'Impostazioni pagina: {page}', + status: 'Stato esplorazione: {page}', + help: 'Comandi di esplorazione', + confirm: 'Per favore conferma', + }, + discovery: { + title: 'Posizione scoperta', + }, + menu: { + draw: 'Disegno', + reveal: 'Rivelare e nascondere', + locations: 'Posizioni', + tools: 'Utensili', + layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + pageSettingsHelp: + 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', + }, + buttons: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + undo: 'Annulla riempimento', + reveal: 'Svelare', + conceal: 'Nascondere', + explore: 'Esplorare', + revealPage: 'Rivela pagina', + resetPage: 'Reimposta pagina', + mark: 'Segna posizione', + unmark: 'Deseleziona', + name: 'Nome esadecimale', + settings: 'Impostazioni', + pageSettings: 'Impostazioni della pagina', + status: 'Stato', + rescan: 'Nuova scansione', + calibrate: 'Calibrare', + calibrateReset: 'Ripristina calibrazione', + help: 'Aiuto', + change: 'Modifica', + menu: 'Menu', + clearOverrides: 'Cancella sostituzioni', + confirmReset: 'Sì, rimuovi tutti gli esagoni', + }, + prompts: { + name: 'Nome della posizione (lascia vuoto per cancellare)', + }, + values: { + on: 'SU', + off: 'Spento', + none: 'Nessuno', + hexLayer: { + auto: 'Automatico (in primo piano se disponibile)', + foreground: 'strato di primo piano', + objects: 'strato di token', + }, + revealBy: { + players: 'Gettoni del giocatore', + characters: 'Segnalini personaggio', + all: 'Tutti i gettoni', + }, + revealMode: { + clear: 'Chiaro', + glimpse: 'Occhiata', + }, + announce: { + all: 'Tutti', + gm: 'Solo GM', + off: 'Spento', + }, + orientation: { + vertical: 'Esadecimale (V)', + horizontal: 'Esadecimale (H)', + }, + fillKind: { + fill: 'Riempire', + fillInverse: 'Riempimento inverso', + conceal: 'Nascondere', + }, + }, + settings: { + language: { + label: 'Lingua', + desc: 'Lingua per menu, messaggi e dispense.', + }, + hexLayer: { + label: 'Strato esagonale', + desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + }, + fillColor: { + label: 'Colore riempimento', + desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Colore del bordo', + desc: 'Colore del contorno dei nuovi esagoni.', + }, + labelColor: { + label: "Colore dell'etichetta", + desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', + }, + glimpseColor: { + label: 'Colore scorcio', + desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + }, + strokeWidth: { + label: 'Larghezza del bordo', + desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', + }, + maxDistance: { + label: 'Distanza di rivelazione esadecimale', + desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', + }, + revealDistance: { + label: 'Distanza visiva', + desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', + }, + lineOfSight: { + label: 'Linea di vista', + desc: 'Quando è attivo, un esagono viene rivelato solo se non si trova alcun esagono coperto tra esso e il segnalino.', + }, + revealPath: { + label: 'Rivela lungo il percorso', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + }, + revealBy: { + label: 'Segnalini che rivelano', + desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + }, + revealMode: { + label: 'Modalità Rivela', + desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + }, + announce: { + label: 'Annunciare le scoperte', + desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', + }, + pingDiscoveries: { + label: 'Scoperte del ping', + desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + }, + hideCoveredTokens: { + label: 'Nascondi i token coperti', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + }, + }, + status: { + engine: 'Motore di gioco', + grid: 'Griglia', + layer: 'Strato esagonale', + hexes: 'Esagoni', + named: 'Esagoni con nome', + icons: 'Gettoni di posizione', + glimpsed: 'Esagoni intravisti', + pending: 'Posizioni in attesa di riempimento', + calibrated: 'Calibrato', + overrides: "La pagina esegue l'override", + undo: 'Annulla disponibile', + }, + messages: { + filled: + 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + revealed: 'Esagoni rivelati: {count}.', + revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + confirmReset: + 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + resetPage: 'Esagoni rimossi dalla pagina: {count}.', + undone: + 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', + named: 'Esagoni denominati "{name}": {count}.', + unnamed: 'Nomi cancellati: {count}.', + marked: + 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', + unmarked: 'Token che non rappresentano più posizioni: {count}.', + settingChanged: '{setting} impostato su {value}.', + rescanned: + 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + calibrated: + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + calibrationReset: + 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', + migrated: + 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + pruned: + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + readyHint: + 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + }, + warnings: { + foregroundUnavailable: + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + someFailed: + 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', + }, + errors: { + noPage: 'Impossibile trovare la pagina su cui lavorare.', + notHex: 'Questa pagina non utilizza una griglia esadecimale.', + noPolygons: 'Seleziona una o più forme disegnate da riempire.', + emptyArea: "L'area selezionata non contiene centri esadecimali.", + tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', + nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', + noTokens: 'Seleziona prima uno o più token.', + noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToUndo: "Non c'è nessun riempimento da annullare.", + unknownCommand: 'Comando sconosciuto: {command}', + unknownSetting: 'Impostazione sconosciuta: {key}', + unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', + invalidValue: '"{value}" non è un valore valido per {key}.', + calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', + calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + unexpected: 'Qualcosa è andato storto: {message}', + }, + hints: { + noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', + notHex: + 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + noPolygons: + "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", + emptyArea: + 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', + tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", + noHexes: + 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + unknownCommand: 'Digita !hexploration help per elencare i comandi.', + unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', + calibrateNeedsTokens: + 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + calibrateFailed: + 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + unexpected: 'I dettagli si trovano nel registro della console API.', + }, + help: { + menu: 'Mostra il menù.', + fill: 'Copri le forme disegnate selezionate con esagoni.', + fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", + undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + reveal: 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', + conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", + explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', + unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + set: "Modifica un'impostazione o mostra tutte le impostazioni.", + pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageClear: 'Rimuovi le sostituzioni della pagina corrente.', + rescan: + "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + calibrate: + 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', + status: 'Mostra cosa sa Hexploration sulla pagina corrente.', + journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + help: 'Mostra questo elenco.', + handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + }, + deck: { + subtitle: 'Mazzo di comando', + drawDesc: + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + revealDesc: + 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + locationsDesc: + 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + toolsDesc: + 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', + footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + }, + handout: { + versionLabel: 'Versione', + subtitle: 'Esplorazione esagono per esagono per Roll20', + footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + overview: { + heading: 'Panoramica', + body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + demo: 'Guarda una breve demo (dalla versione 1)', + }, + quickStart: { + heading: 'Avvio rapido', + steps: [ + 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', + "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", + 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + ], + }, + commands: { + heading: 'Comandi', + intro: + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + colCommand: 'Comando', + colDesc: 'Cosa fa', + }, + revealing: { + heading: 'Come funziona la rivelazione', + points: [ + 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', + 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', + "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", + 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + ], + }, + locations: { + heading: 'Esagoni e posizioni con nome', + points: [ + 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", + 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + ], + }, + settings: { + heading: 'Impostazioni', + intro: + 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + colKey: 'Chiave', + colName: 'Collocamento', + colDesc: 'Descrizione', + perPage: '(Può essere impostato per pagina.)', + }, + jumpgate: { + heading: 'Jumpgate e Legacy', + points: [ + "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", + "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + ], + }, + upgrading: { + heading: 'Aggiornamento dalla versione 1', + points: [ + 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', + 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', + 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + ], + colV1: 'Comando della versione 1', + colV2: 'Comando della versione 2', + }, + troubleshooting: { + heading: 'Risoluzione dei problemi', + points: [ + 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', + 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', + "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', + ], + }, + languages: { + heading: 'Lingue', + body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + }, + credits: { + heading: 'Crediti', + original: 'Mod originale di', + maintainer: 'Versione 2 mantenuta da', + marketplace: 'I pacchetti artistici di Ada sul Marketplace Roll20', + support: + "Se trovi un bug o hai un'idea, pubblica un post nel forum Roll20 Mod o apri un problema su GitHub e includi eventuali messaggi dal registro della console API.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index ff8b4c5632..ca66a49be7 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -1 +1,371 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'H探索の準備は完了です。', + settings: 'H探索設定', + languages: '言語を選択してください', + pageSettings: 'ページ設定: {page}', + status: 'H探索ステータス: {page}', + help: 'H探索コマンド', + confirm: 'ご確認ください', + }, + discovery: { + title: '場所が発見されました', + }, + menu: { + draw: '描く', + reveal: '表示と非表示', + locations: '所在地', + tools: 'ツール', + layerInUse: '新しいヘクスが {layer} に描画されています。', + pageSettingsHelp: + 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', + }, + buttons: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + undo: '塗りつぶしを元に戻す', + reveal: '明らかにする', + conceal: '隠す', + explore: '探検する', + revealPage: 'ページを公開', + resetPage: 'ページをリセット', + mark: '位置をマークする', + unmark: 'マークを外す', + name: '名前の 16 進数', + settings: '設定', + pageSettings: 'ページ設定', + status: '状態', + rescan: '再スキャン', + calibrate: '校正する', + calibrateReset: 'キャリブレーションをリセットする', + help: 'ヘルプ', + change: '変化', + menu: 'メニュー', + clearOverrides: 'オーバーライドのクリア', + confirmReset: 'はい、すべてのヘクスを削除します', + }, + prompts: { + name: '場所の名前 (クリアするには空白のままにします)', + }, + values: { + on: 'の上', + off: 'オフ', + none: 'なし', + hexLayer: { + auto: '自動 (利用可能な場合は前景)', + foreground: '前景レイヤー', + objects: 'トークン層', + }, + revealBy: { + players: 'プレイヤートークン', + characters: 'キャラクタートークン', + all: 'すべてのトークン', + }, + revealMode: { + clear: 'クリア', + glimpse: '垣間見る', + }, + announce: { + all: 'みんな', + gm: 'GMのみ', + off: 'オフ', + }, + orientation: { + vertical: 'ヘックス(V)', + horizontal: '六角(H)', + }, + fillKind: { + fill: '埋める', + fillInverse: '逆塗りつぶし', + conceal: '隠す', + }, + }, + settings: { + language: { + label: '言語', + desc: 'メニュー、メッセージ、配布資料の言語。', + }, + hexLayer: { + label: 'ヘックスレイヤー', + desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + }, + fillColor: { + label: '塗りつぶしの色', + desc: '新しいヘクスの色。シースルー ヘクスには rgba() を使用します (例: rgba(0,0,0,0.8))。', + }, + strokeColor: { + label: '枠線の色', + desc: '新しいヘクスの輪郭の色。', + }, + labelColor: { + label: 'ラベルの色', + desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', + }, + glimpseColor: { + label: '垣間見える色', + desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + }, + strokeWidth: { + label: '枠線の幅', + desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', + }, + maxDistance: { + label: '16進数の表示距離', + desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', + }, + revealDistance: { + label: '視距離', + desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + }, + lineOfSight: { + label: '視線', + desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', + }, + revealPath: { + label: 'パスに沿って表示', + desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', + }, + revealBy: { + label: '明らかにするトークン', + desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + }, + revealMode: { + label: 'リビールモード', + desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + }, + announce: { + label: '発見の発表', + desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', + }, + pingDiscoveries: { + label: 'Ping の発見', + desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + }, + hideCoveredTokens: { + label: 'カバーされたトークンを非表示にする', + desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', + }, + }, + status: { + engine: 'ゲームエンジン', + grid: 'グリッド', + layer: 'ヘックスレイヤー', + hexes: 'ヘクス', + named: '名前付きヘクス', + icons: '位置トークン', + glimpsed: '垣間見えるヘクス', + pending: '埋まりを待っている場所', + calibrated: '校正済み', + overrides: 'ページの上書き', + undo: '元に戻すことが可能', + }, + messages: { + filled: + '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + revealed: '明らかになったヘクス: {count}。', + revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', + confirmReset: + '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + resetPage: 'ページから削除されたヘクス: {count}。', + undone: + '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', + named: '「{name}」という名前のヘクス: {count}。', + unnamed: '削除された名前: {count}。', + marked: + '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + unmarked: '場所ではなくなったトークン: {count}。', + settingChanged: '{setting} を {value} に設定します。', + rescanned: + '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + calibrated: + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + calibrationReset: + 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', + migrated: + 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + pruned: + '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', + readyHint: + 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + }, + warnings: { + foregroundUnavailable: + 'このゲームは前景レイヤーでの描画をサポートしていないため、ヘクスはトークン レイヤーに描画されました。', + someFailed: + '描画できなかったヘクス: {count}。詳細については API コンソールを確認してください。', + }, + errors: { + noPage: '作業するページが見つかりませんでした。', + notHex: 'このページでは 16 進グリッドは使用されていません。', + noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', + emptyArea: '選択した領域には六角中心が含まれていません。', + tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', + nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', + nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', + noTokens: '最初に 1 つ以上のトークンを選択します。', + noHexes: '最初に 1 つ以上のヘクス (またはヘクス上にあるトークン) を選択します。', + nothingToUndo: '元に戻す塗りつぶしはありません。', + unknownCommand: '不明なコマンド: {command}', + unknownSetting: '不明な設定: {key}', + unknownPageSetting: 'ページごとに設定できる設定: {keys}', + invalidValue: '「{value}」は、{key} の有効な値ではありません。', + calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateFailed: 'これらのトークンは調整には使用できません。', + unexpected: '問題が発生しました: {message}', + }, + hints: { + noPage: '作業したいページを開くか、ページ上で何かを選択します。', + notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + noPolygons: + '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', + emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', + tooMany: 'より小さい領域を塗りつぶすか、領域をいくつかの形状に分割します。', + noHexes: 'ヘクスは前景またはトークン層にあります。そのレイヤーに切り替えて選択します。', + unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', + unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', + calibrateNeedsTokens: + 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + calibrateFailed: + '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + unexpected: '詳細は API コンソールのログに記載されています。', + }, + help: { + menu: 'メニューを表示します。', + fill: '選択した描画形状を六角形で覆います。', + fillInverse: '選択した図形の内側を除いてページ全体を覆います。', + undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', + revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', + conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', + resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', + name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', + mark: '選択したトークンを非表示の場所に変更します。', + unmark: '選択したトークンが非表示の場所になるのを停止します。', + set: '設定を変更するか、すべての設定を表示します。', + pageSet: '現在のページでのみ公開設定をオーバーライドします。', + pageClear: '現在のページのオーバーライドを削除します。', + rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + calibrate: + '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + calibrateReset: '現在のページの調整を削除します。', + status: '現在のページについて Hexploration が知っていることを表示します。', + journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + help: 'このリストを表示します。', + handout: '完全な手順は配布資料「{name}」に記載されています。', + }, + deck: { + subtitle: 'コマンドデッキ', + drawDesc: + '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + revealDesc: + 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + locationsDesc: + 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + toolsDesc: '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', + footer: '完全な手順については、配布資料「{help}」を参照してください。', + }, + handout: { + versionLabel: 'バージョン', + subtitle: 'Roll20 のヘックスごとの探索', + footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', + overview: { + heading: '概要', + body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + demo: '短いデモを見る (バージョン 1 から)', + }, + quickStart: { + heading: 'クイックスタート', + steps: [ + 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', + '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', + 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', + 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + ], + }, + commands: { + heading: 'コマンド', + intro: + 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', + colCommand: '指示', + colDesc: '何をするのか', + }, + revealing: { + heading: '暴露の仕組み', + points: [ + 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', + 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', + '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', + 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', + 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + ], + }, + locations: { + heading: '名前付きヘクスと場所', + points: [ + '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', + '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', + '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + ], + }, + settings: { + heading: '設定', + intro: + '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + colKey: '鍵', + colName: '設定', + colDesc: '説明', + perPage: '（ページごとに設定可能）', + }, + jumpgate: { + heading: 'ジャンプゲートとレガシー', + points: [ + 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', + 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', + 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', + ], + }, + upgrading: { + heading: 'バージョン1からのアップグレード', + points: [ + 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', + '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', + 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + ], + colV1: 'バージョン1のコマンド', + colV2: 'バージョン 2 コマンド', + }, + troubleshooting: { + heading: 'トラブルシューティング', + points: [ + 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', + 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', + 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', + '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', + ], + }, + languages: { + heading: '言語', + body: '!hexploration set language で言語を選択します。利用可能な言語:', + }, + credits: { + heading: 'クレジット', + original: 'オリジナルMODによる', + maintainer: 'バージョン 2 の保守者', + marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', + support: + 'バグを見つけた場合やアイデアがある場合は、Roll20 Mod フォーラムに投稿するか、GitHub で問題を開いて、API コンソール ログからのメッセージを含めてください。', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index ff8b4c5632..12fcece854 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -1 +1,369 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: '탐색이 준비되었습니다.', + settings: '탐색 설정', + languages: '언어를 선택하세요', + pageSettings: '페이지 설정: {page}', + status: '탐색 상태: {page}', + help: '탐색 명령', + confirm: '확인해주세요', + }, + discovery: { + title: '발견된 위치', + }, + menu: { + draw: '그리다', + reveal: '공개 및 숨기기', + locations: '위치', + tools: '도구', + layerInUse: '{layer}에 새로운 헥스가 그려지고 있습니다.', + pageSettingsHelp: + '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', + }, + buttons: { + fill: '채우다', + fillInverse: '역 채우기', + undo: '채우기 실행 취소', + reveal: '드러내다', + conceal: '숨기다', + explore: '탐구하다', + revealPage: '페이지 공개', + resetPage: '페이지 재설정', + mark: '위치 표시', + unmark: '표시 해제', + name: '이름 헥스', + settings: '설정', + pageSettings: '페이지 설정', + status: '상태', + rescan: '다시 스캔', + calibrate: '교정', + calibrateReset: '교정 재설정', + help: '돕다', + change: '변화', + menu: '메뉴', + clearOverrides: '재정의 지우기', + confirmReset: '예, 모든 16진수를 제거합니다.', + }, + prompts: { + name: '위치 이름(지우려면 비워 두세요)', + }, + values: { + on: '~에', + off: '끄다', + none: '없음', + hexLayer: { + auto: '자동(사용 가능한 경우 전경)', + foreground: '전경 레이어', + objects: '토큰 레이어', + }, + revealBy: { + players: '플레이어 토큰', + characters: '캐릭터 토큰', + all: '모든 토큰', + }, + revealMode: { + clear: '분명한', + glimpse: '일견', + }, + announce: { + all: '모든 사람', + gm: 'GM 전용', + off: '끄다', + }, + orientation: { + vertical: '16진수(V)', + horizontal: '16진수(H)', + }, + fillKind: { + fill: '채우다', + fillInverse: '역 채우기', + conceal: '숨기다', + }, + }, + settings: { + language: { + label: '언어', + desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', + }, + hexLayer: { + label: '육각 레이어', + desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + }, + fillColor: { + label: '채우기 색상', + desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + }, + strokeColor: { + label: '테두리 색상', + desc: '새로운 육각형의 윤곽선 색상입니다.', + }, + labelColor: { + label: '라벨 색상', + desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + }, + glimpseColor: { + label: '미리보기 색상', + desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + }, + strokeWidth: { + label: '테두리 너비', + desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', + }, + maxDistance: { + label: '16진수 공개 거리', + desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', + }, + revealDistance: { + label: '시거리', + desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + }, + lineOfSight: { + label: '시선', + desc: '켜져 있으면 헥스와 토큰 사이에 가려진 헥스가 없는 경우에만 헥스가 드러납니다.', + }, + revealPath: { + label: '경로를 따라 표시', + desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', + }, + revealBy: { + label: '공개되는 토큰', + desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + }, + revealMode: { + label: '공개 모드', + desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + }, + announce: { + label: '발견 발표', + desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', + }, + pingDiscoveries: { + label: '핑 발견', + desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', + }, + hideCoveredTokens: { + label: '적용 토큰 숨기기', + desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + }, + }, + status: { + engine: '게임 엔진', + grid: '그리드', + layer: '육각층', + hexes: '헥스', + named: '명명된 헥스', + icons: '위치 토큰', + glimpsed: '살짝 엿본 육각형', + pending: '채우기를 기다리는 위치', + calibrated: '교정됨', + overrides: '페이지 재정의', + undo: '실행 취소 가능', + }, + messages: { + filled: + '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', + revealed: '공개된 헥스: {count}.', + revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + confirmReset: + '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거된 16진수: {count}.', + undone: + '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + named: '"{name}"이라는 헥스: {count}.', + unnamed: '지워진 이름: {count}.', + marked: + '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + unmarked: '더 이상 위치가 아닌 토큰: {count}.', + settingChanged: '{setting}이(가) {value}로 설정되었습니다.', + rescanned: + '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + calibrated: + '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + calibrationReset: + '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', + migrated: + 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + pruned: + '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', + readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + }, + warnings: { + foregroundUnavailable: + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', + someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + }, + errors: { + noPage: '작업할 페이지를 찾을 수 없습니다.', + notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', + emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', + nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', + nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + noTokens: '먼저 하나 이상의 토큰을 선택하세요.', + noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', + nothingToUndo: '실행 취소할 채우기가 없습니다.', + unknownCommand: '알 수 없는 명령: {command}', + unknownSetting: '알 수 없는 설정: {key}', + unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', + invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', + calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', + unexpected: '문제가 발생했습니다: {message}', + }, + hints: { + noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', + notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + noPolygons: + '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', + emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', + tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', + noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + calibrateNeedsTokens: + '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + calibrateFailed: + '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + unexpected: '세부정보는 API 콘솔 로그에 있습니다.', + }, + help: { + menu: '메뉴를 보여주세요.', + fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', + undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', + reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', + resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', + mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', + unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', + set: '설정을 변경하거나 모든 설정을 표시합니다.', + pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', + pageClear: '현재 페이지의 재정의를 제거합니다.', + rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', + calibrate: + '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + calibrateReset: '현재 페이지의 보정을 제거합니다.', + status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + help: '이 목록을 보여주세요.', + handout: '전체 지침은 "{name}" 유인물에 있습니다.', + }, + deck: { + subtitle: '커맨드 덱', + drawDesc: + '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + revealDesc: + '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + locationsDesc: + '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', + footer: '전체 지침은 "{help}" 유인물을 참조하세요.', + }, + handout: { + versionLabel: '버전', + subtitle: 'Roll20의 16진수 탐색', + footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', + overview: { + heading: '개요', + body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + demo: '짧은 데모 보기(버전 1부터)', + }, + quickStart: { + heading: '빠른 시작', + steps: [ + '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', + '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', + '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + ], + }, + commands: { + heading: '명령', + intro: + 'GM만이 이 명령을 사용할 수 있습니다. 대부분은 선택한 개체에 작용합니다. 나머지는 현재 보고 있는 페이지에서 수행됩니다.', + colCommand: '명령', + colDesc: '기능', + }, + revealing: { + heading: '공개 작동 방식', + points: [ + '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', + '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', + 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', + 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + ], + }, + locations: { + heading: '명명된 육각형 및 위치', + points: [ + 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', + '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', + 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', + '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + ], + }, + settings: { + heading: '설정', + intro: + '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + colKey: '열쇠', + colName: '환경', + colDesc: '설명', + perPage: '(페이지별로 설정 가능합니다.)', + }, + jumpgate: { + heading: '점프게이트와 레거시', + points: [ + 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', + 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', + 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', + ], + }, + upgrading: { + heading: '버전 1에서 업그레이드', + points: [ + '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', + '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', + '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + ], + colV1: '버전 1 명령', + colV2: '버전 2 명령', + }, + troubleshooting: { + heading: '문제 해결', + points: [ + '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', + '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', + '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', + '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', + ], + }, + languages: { + heading: '언어', + body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + }, + credits: { + heading: '크레딧', + original: '원본 모드 작성자:', + maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', + marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', + support: + '버그를 발견하거나 아이디어가 있는 경우 Roll20 Mod 포럼에 게시하거나 GitHub에서 문제를 열고 API 콘솔 로그의 메시지를 포함하세요.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index ff8b4c5632..a709842900 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -1 +1,375 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Hexploratie is klaar.', + settings: 'Hexploratie-instellingen', + languages: 'Kies een taal', + pageSettings: 'Pagina-instellingen: {page}', + status: 'Hverkenningsstatus: {page}', + help: 'Hexploratie-opdrachten', + confirm: 'Bevestig alstublieft', + }, + discovery: { + title: 'Locatie ontdekt', + }, + menu: { + draw: 'Tekenen', + reveal: 'Onthullen en verbergen', + locations: 'Locaties', + tools: 'Hulpmiddelen', + layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + pageSettingsHelp: + 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', + }, + buttons: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + undo: 'Vulling ongedaan maken', + reveal: 'Onthullen', + conceal: 'Maskeren', + explore: 'Ontdekken', + revealPage: 'Pagina onthullen', + resetPage: 'Pagina opnieuw instellen', + mark: 'Markeer locatie', + unmark: 'Markering opheffen', + name: 'Naam Hex', + settings: 'Instellingen', + pageSettings: 'Pagina-instellingen', + status: 'Status', + rescan: 'Opnieuw scannen', + calibrate: 'Kalibreren', + calibrateReset: 'Kalibratie opnieuw instellen', + help: 'Hulp', + change: 'Wijziging', + menu: 'Menu', + clearOverrides: 'Wis overschrijvingen', + confirmReset: 'Ja, verwijder alle vakjes', + }, + prompts: { + name: 'Locatienaam (leeg laten om te wissen)', + }, + values: { + on: 'Op', + off: 'Uit', + none: 'Geen', + hexLayer: { + auto: 'Automatisch (voorgrond indien beschikbaar)', + foreground: 'voorgrond laag', + objects: 'token laag', + }, + revealBy: { + players: 'Spelerfiches', + characters: 'Karakterfiches', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Duidelijk', + glimpse: 'Glimp', + }, + announce: { + all: 'Iedereen', + gm: 'Alleen GM', + off: 'Uit', + }, + orientation: { + vertical: 'Zeskant (V)', + horizontal: 'Zeskant (H)', + }, + fillKind: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + conceal: 'Maskeren', + }, + }, + settings: { + language: { + label: 'Taal', + desc: "Taal voor menu's, berichten en hand-outs.", + }, + hexLayer: { + label: 'Hex-laag', + desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van de omtrek van nieuwe vakjes.', + }, + labelColor: { + label: 'Etiketkleur', + desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + }, + glimpseColor: { + label: 'Glimp kleur', + desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + }, + strokeWidth: { + label: 'Randbreedte', + desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Hex onthullen afstand', + desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', + }, + revealDistance: { + label: 'Zicht afstand', + desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + }, + lineOfSight: { + label: 'Zichtlijn', + desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', + }, + revealPath: { + label: 'Onthul langs het pad', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + }, + revealBy: { + label: 'Tokens die onthullen', + desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + }, + revealMode: { + label: 'Onthullingsmodus', + desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + }, + announce: { + label: 'Ontdekkingen aankondigen', + desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + }, + pingDiscoveries: { + label: 'Ping-ontdekkingen', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + }, + hideCoveredTokens: { + label: 'Verberg afgedekte tokens', + desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + }, + }, + status: { + engine: 'Game-engine', + grid: 'Rooster', + layer: 'Hex-laag', + hexes: 'Hexen', + named: 'Genoemde hexen', + icons: 'Locatiefiches', + glimpsed: 'Glimp van hexen', + pending: 'Locaties die wachten op vulling', + calibrated: 'Gekalibreerd', + overrides: 'Pagina-overschrijvingen', + undo: 'Ongedaan maken beschikbaar', + }, + messages: { + filled: + 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Hexen onthuld: {count}.', + revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + confirmReset: + 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Hexes verwijderd van de pagina: {count}.', + undone: + 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', + named: 'Hexen met de naam "{name}": {count}.', + unnamed: 'Namen gewist: {count}.', + marked: + 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + unmarked: 'Tokens die niet langer locaties zijn: {count}.', + settingChanged: '{setting} ingesteld op {value}.', + rescanned: + 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + calibrated: + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + calibrationReset: + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', + migrated: + 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + pruned: + 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + readyHint: + 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + someFailed: + 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + }, + errors: { + noPage: 'Kon de pagina niet vinden om aan te werken.', + notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', + noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', + emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', + tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', + nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + noTokens: 'Selecteer eerst een of meer tokens.', + noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', + unknownCommand: 'Onbekend commando: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellingen die per pagina kunnen worden ingesteld: {keys}', + invalidValue: '"{value}" is geen geldige waarde voor {key}.', + calibrateNeedsTokens: + 'Selecteer een of twee tokens die op de middelpunten van de zeshoeken zijn vastgemaakt.', + calibrateFailed: 'Deze tokens kunnen niet worden gebruikt om te kalibreren.', + unexpected: 'Er is iets misgegaan: {message}', + }, + hints: { + noPage: 'Open de pagina waaraan u wilt werken of selecteer er iets op.', + notHex: 'Stel het paginaraster in op Hex (V) of Hex (H) in Pagina-instellingen.', + noPolygons: + 'Teken een veelhoek, rechthoek, ellips of vorm uit de vrije hand rond het gebied, selecteer het en probeer het opnieuw.', + emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', + tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', + noHexes: + 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', + unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', + calibrateNeedsTokens: + 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + calibrateFailed: + 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', + unexpected: 'Details staan ​​in het API-consolelogboek.', + }, + help: { + menu: 'Laat de menukaart zien.', + fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', + undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + reveal: 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', + revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', + explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', + resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', + name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + mark: 'Verander de geselecteerde tokens in verborgen locaties.', + unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', + set: 'Wijzig een instelling of toon alle instellingen.', + pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', + pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', + rescan: + 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + calibrate: + 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', + status: 'Laat zien wat Hexploration weet over de huidige pagina.', + journal: 'Herbouw de Help- en Command Deck-hand-outs.', + help: 'Laat deze lijst zien.', + handout: 'Volledige instructies vindt u in de hand-out "{name}".', + }, + deck: { + subtitle: 'Commandodek', + drawDesc: + 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + revealDesc: + 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + locationsDesc: + 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + toolsDesc: + "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", + footer: 'Zie de hand-out "{help}" voor volledige instructies.', + }, + handout: { + versionLabel: 'Versie', + subtitle: 'Hex-voor-hex verkenning voor Roll20', + footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', + overview: { + heading: 'Overzicht', + body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + demo: 'Bekijk een korte demo (vanaf versie 1)', + }, + quickStart: { + heading: 'Snel beginnen', + steps: [ + 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', + 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', + 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + ], + }, + commands: { + heading: "Commando's", + intro: + "Alleen GM's kunnen deze commando's gebruiken. De meeste werken op de geselecteerde objecten; de rest handelt op de pagina die u bekijkt.", + colCommand: 'Commando', + colDesc: 'Wat het doet', + }, + revealing: { + heading: 'Hoe onthullen werkt', + points: [ + 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", + 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', + 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', + 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + ], + }, + locations: { + heading: 'Genoemde velden en locaties', + points: [ + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', + 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', + 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + ], + }, + settings: { + heading: 'Instellingen', + intro: + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beschrijving', + perPage: '(Kan per pagina worden ingesteld.)', + }, + jumpgate: { + heading: 'Jumpgate en erfenis', + points: [ + 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', + 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', + "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + ], + }, + upgrading: { + heading: 'Upgraden vanaf versie 1', + points: [ + 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', + 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', + 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + ], + colV1: 'Versie 1-opdracht', + colV2: 'Versie 2-opdracht', + }, + troubleshooting: { + heading: 'Problemen oplossen', + points: [ + 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', + 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', + 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', + 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', + ], + }, + languages: { + heading: 'Talen', + body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + }, + credits: { + heading: 'Kredieten', + original: 'Originele mod door', + maintainer: 'Versie 2 onderhouden door', + marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", + support: + 'Als je een bug vindt of een idee hebt, plaats dan een bericht op het Roll20 Mod-forum of open een probleem op GitHub, en voeg eventuele berichten uit het API-consolelogboek toe.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index ff8b4c5632..4d04e3e8ce 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -1 +1,373 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Heksploracja jest gotowa.', + settings: 'Ustawienia Heksploracji', + languages: 'Wybierz język', + pageSettings: 'Ustawienia strony: {page}', + status: 'Stan heksploracji: {page}', + help: 'Komendy Heksploracji', + confirm: 'Proszę potwierdzić', + }, + discovery: { + title: 'Lokalizacja odkryta', + }, + menu: { + draw: 'Rysować', + reveal: 'Odkryj i ukryj', + locations: 'Lokalizacje', + tools: 'Narzędzia', + layerInUse: 'Nowe heksy są rysowane na {layer}.', + pageSettingsHelp: + 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', + }, + buttons: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + undo: 'Cofnij wypełnienie', + reveal: 'Ujawnić', + conceal: 'Ukryć', + explore: 'Badać', + revealPage: 'Odkryj stronę', + resetPage: 'Zresetuj stronę', + mark: 'Zaznacz lokalizację', + unmark: 'Odznacz', + name: 'Imię Hex', + settings: 'Ustawienia', + pageSettings: 'Ustawienia strony', + status: 'Status', + rescan: 'Skanuj ponownie', + calibrate: 'Kalibrować', + calibrateReset: 'Zresetuj kalibrację', + help: 'Pomoc', + change: 'Zmiana', + menu: 'Menu', + clearOverrides: 'Wyczyść zastąpienia', + confirmReset: 'Tak, usuń wszystkie heksy', + }, + prompts: { + name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', + }, + values: { + on: 'NA', + off: 'Wyłączony', + none: 'Nic', + hexLayer: { + auto: 'Auto (pierwszy plan, jeśli jest dostępny)', + foreground: 'warstwa pierwszego planu', + objects: 'warstwa tokenów', + }, + revealBy: { + players: 'Żetony graczy', + characters: 'Żetony postaci', + all: 'Wszystkie tokeny', + }, + revealMode: { + clear: 'Jasne', + glimpse: 'Dojrzeć', + }, + announce: { + all: 'Wszyscy', + gm: "Tylko GM'a", + off: 'Wyłączony', + }, + orientation: { + vertical: 'Sześciokąt (V)', + horizontal: 'Sześciokąt (H)', + }, + fillKind: { + fill: 'Wypełnić', + fillInverse: 'Odwrotne wypełnienie', + conceal: 'Ukryć', + }, + }, + settings: { + language: { + label: 'Język', + desc: 'Język menu, komunikatów i materiałów informacyjnych.', + }, + hexLayer: { + label: 'Warstwa szesnastkowa', + desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + }, + fillColor: { + label: 'Kolor wypełnienia', + desc: 'Kolor nowych heksów. Użyj rgba() dla przezroczystych heksów, na przykład rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kolor obramowania', + desc: 'Kolor konturu nowych heksów.', + }, + labelColor: { + label: 'Kolor etykiety', + desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + }, + glimpseColor: { + label: 'Kolor przebłysku', + desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + }, + strokeWidth: { + label: 'Szerokość obramowania', + desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', + }, + maxDistance: { + label: 'Odległość ujawnienia heksadecymalnego', + desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', + }, + revealDistance: { + label: 'Odległość wzroku', + desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', + }, + lineOfSight: { + label: 'Linia wzroku', + desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', + }, + revealPath: { + label: 'Odkryj wzdłuż ścieżki', + desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + }, + revealBy: { + label: 'Żetony, które ujawniają', + desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', + }, + revealMode: { + label: 'Tryb ujawnienia', + desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + }, + announce: { + label: 'Ogłoś odkrycia', + desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', + }, + pingDiscoveries: { + label: 'Odkrycia pingowe', + desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', + }, + hideCoveredTokens: { + label: 'Ukryj zakryte tokeny', + desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', + }, + }, + status: { + engine: 'Silnik gry', + grid: 'Siatka', + layer: 'Warstwa sześciokątna', + hexes: 'Heksy', + named: 'Nazwane heksy', + icons: 'Żetony lokalizacji', + glimpsed: 'Prześwietlone heksy', + pending: 'Lokalizacje oczekujące na zapełnienie', + calibrated: 'Kalibrowane', + overrides: 'Zastąpienia strony', + undo: 'Cofnij dostępne', + }, + messages: { + filled: + 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + revealed: 'Ujawnione heksy: {count}.', + revealedPage: 'Każdy odkryty heks na stronie ({count}).', + confirmReset: + 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', + resetPage: 'Heksy usunięte ze strony: {count}.', + undone: + 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + named: 'Heksy o nazwie „{name}”: {count}.', + unnamed: 'Nazwy zostały usunięte: {count}.', + marked: + 'Lokalizacje ukryte na istniejących heksach: {attached}. Czekam na następne wypełnienie, które je obejmuje: {pending}.', + unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', + settingChanged: '{setting} ustawiony na {value}.', + rescanned: + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + calibrated: + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + calibrationReset: + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', + migrated: + 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + pruned: + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', + readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + }, + warnings: { + foregroundUnavailable: + 'Ta gra nie obsługuje rysowania na warstwie pierwszego planu, więc heksy zostały narysowane na warstwie żetonów.', + someFailed: + 'Heksy, których nie można narysować: {count}. Aby uzyskać szczegółowe informacje, sprawdź konsolę API.', + }, + errors: { + noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', + notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', + emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', + nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', + nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', + noTokens: 'Najpierw wybierz jeden lub więcej tokenów.', + noHexes: 'Najpierw wybierz jeden lub więcej heksów (lub żetonów stojących na heksach).', + nothingToUndo: 'Nie ma wypełnienia, które można cofnąć.', + unknownCommand: 'Nieznane polecenie: {command}', + unknownSetting: 'Nieznane ustawienie: {key}', + unknownPageSetting: 'Ustawienia, które można ustawić na stronie: {keys}', + invalidValue: '„{value}” nie jest prawidłową wartością dla {key}.', + calibrateNeedsTokens: 'Wybierz jeden lub dwa żetony przyciągnięte do środków heksów.', + calibrateFailed: 'Tych tokenów nie można używać do kalibracji.', + unexpected: 'Coś poszło nie tak: {message}', + }, + hints: { + noPage: 'Otwórz stronę, nad którą chcesz pracować, lub wybierz coś na niej.', + notHex: 'Ustaw siatkę strony na Hex (V) lub Hex (H) w Ustawieniach strony.', + noPolygons: + 'Narysuj wielokąt, prostokąt, elipsę lub odręczny kształt wokół obszaru, zaznacz go i spróbuj ponownie.', + emptyArea: 'Narysuj większy kształt lub sprawdź ustawienia siatki strony.', + tooMany: 'Wypełnij mniejszy obszar lub podziel obszar na kilka kształtów.', + noHexes: + 'Heksy znajdują się na pierwszym planie lub w warstwie żetonów; przejdź do tej warstwy, aby je wybrać.', + unknownCommand: 'Wpisz !hexploration help, aby wyświetlić listę poleceń.', + unknownSetting: 'Wpisz !hexploration set, aby zobaczyć wszystkie ustawienia.', + calibrateNeedsTokens: + 'Przyciągnij żeton do środka heksa i wybierz go. Wybierz drugi żeton przyciągnięty do sąsiedniego heksu w tym samym rzędzie (Hex V) lub kolumnie (Hex H), aby również skorygować rozmiar heksa.', + calibrateFailed: + 'Dwa żetony muszą znajdować się w tym samym rzędzie (Hex V) lub w tej samej kolumnie (Hex H), w odległości co najmniej jednego heksa od siebie.', + unexpected: 'Szczegóły znajdują się w dzienniku konsoli API.', + }, + help: { + menu: 'Pokaż menu.', + fill: 'Zakryj wybrane narysowane kształty heksami.', + fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', + undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', + revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', + conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', + explore: 'Odsłoń wokół wybranych żetonów tak, jakby właśnie się tam przesunęły.', + resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', + name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', + mark: 'Zamień wybrane żetony w ukryte lokalizacje.', + unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', + pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', + pageClear: 'Usuń zastąpienia bieżącej strony.', + rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + calibrate: + 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', + calibrateReset: 'Usuń kalibrację bieżącej strony.', + status: 'Pokaż, co Heexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + help: 'Pokaż tę listę.', + handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', + }, + deck: { + subtitle: 'Pokład dowodzenia', + drawDesc: + 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', + revealDesc: + 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + locationsDesc: + 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', + toolsDesc: + 'Ustawienia, nadpisania stron, status, ponowne skanowanie skopiowanych stron i kalibracja siatki.', + footer: 'Pełne instrukcje znajdziesz w ulotce „{help}”.', + }, + handout: { + versionLabel: 'Wersja', + subtitle: 'Eksploracja heks po heksie dla Roll20', + footer: + 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + overview: { + heading: 'Przegląd', + body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (od wersji 1)', + }, + quickStart: { + heading: 'Szybki start', + steps: [ + 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', + 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', + 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', + 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + ], + }, + commands: { + heading: 'Polecenia', + intro: + 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', + colCommand: 'Rozkaz', + colDesc: 'Co to robi', + }, + revealing: { + heading: 'Jak działa odkrywanie', + points: [ + 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', + 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', + 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', + 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + ], + }, + locations: { + heading: 'Nazwane heksy i lokalizacje', + points: [ + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', + 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', + 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + ], + }, + settings: { + heading: 'Ustawienia', + intro: + 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', + colKey: 'Klawisz', + colName: 'Ustawienie', + colDesc: 'Opis', + perPage: '(Można ustawić na stronę.)', + }, + jumpgate: { + heading: 'Jumpgate i Dziedzictwo', + points: [ + 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', + 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + ], + }, + upgrading: { + heading: 'Aktualizacja z wersji 1', + points: [ + 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', + 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', + 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', + 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + ], + colV1: 'Polecenie wersji 1', + colV2: 'Polecenie wersji 2', + }, + troubleshooting: { + heading: 'Rozwiązywanie problemów', + points: [ + 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', + 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', + 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', + ], + }, + languages: { + heading: 'Języki', + body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + }, + credits: { + heading: 'Kredyty', + original: 'Oryginalny mod autorstwa', + maintainer: 'Wersja 2 obsługiwana przez', + marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', + support: + 'Jeśli znajdziesz błąd lub masz pomysł, opublikuj post na forum Roll20 Mod lub otwórz problem w GitHub i dołącz wszelkie komunikaty z dziennika konsoli API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index ff8b4c5632..6b0247dc2c 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -1 +1,373 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Configurações da página: {page}', + status: 'Status de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Empate', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + pageSettingsHelp: + 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Status', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixe em branco para limpar)', + }, + values: { + on: 'Sobre', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Todos', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Linguagem', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Use rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do caminho', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras acima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm seu nome, barras e auras visíveis ao jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grade', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Tokens de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais aguardando preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos chamados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + unmarked: 'Tokens que não são mais locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + calibrated: + 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não usa uma grade hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione um ou mais tokens primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + nothingToUndo: 'Não há preenchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + unexpected: 'Algo deu errado: {message}', + }, + hints: { + noPage: 'Abra a página na qual deseja trabalhar ou selecione algo nela.', + notHex: 'Defina a grade da página como Hex (V) ou Hex (H) nas Configurações da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre ao redor da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', + tooMany: 'Preencha uma área menor ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + unknownCommand: 'Digite !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as configurações.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log do console da API.', + }, + help: { + menu: 'Mostre o cardápio.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma configuração ou mostre todas as configurações.', + pageSet: 'Substituir uma configuração de revelação somente na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + locationsDesc: + 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + footer: 'Consulte o folheto "{help}" para obter instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Use o folheto "{deck}" para controles de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Somente GMs podem usar esses comandos. A maioria atua nos objetos selecionados; o resto atua na página que você está visualizando.', + colCommand: 'Comando', + colDesc: 'O que isso faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + colKey: 'Chave', + colName: 'Contexto', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualizando da versão 1', + points: [ + 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', + 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original por', + maintainer: 'Versão 2 mantida por', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se você encontrar um bug ou tiver uma ideia, poste no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do log do console da API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index ff8b4c5632..a4f9686946 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -1 +1,373 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'A Hexploração está pronta.', + settings: 'Configurações de exploração', + languages: 'Escolha um idioma', + pageSettings: 'Definições da página: {page}', + status: 'Estado de exploração: {page}', + help: 'Comandos de Hexploração', + confirm: 'Por favor confirme', + }, + discovery: { + title: 'Localização descoberta', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + pageSettingsHelp: + 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Esconder', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar localização', + unmark: 'Desmarcar', + name: 'Nome hexadecimal', + settings: 'Configurações', + pageSettings: 'Configurações de página', + status: 'Estatuto', + rescan: 'Digitalizar novamente', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Mudar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixar em branco para limpar)', + }, + values: { + on: 'Em', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de token', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Fichas de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Claro', + glimpse: 'Relance', + }, + announce: { + all: 'Toda a gente', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento Inverso', + conceal: 'Esconder', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada hexadecimal', + desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Utilize rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Vislumbre de cor', + desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação hexadecimal', + desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + }, + revealPath: { + label: 'Revelar ao longo do percurso', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + }, + announce: { + label: 'Anuncie descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Descobertas de ping', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Rede', + layer: 'Camada hexadecimal', + hexes: 'Feitiços', + named: 'Hexágonos nomeados', + icons: 'Fichas de localização', + glimpsed: 'Feitiços vislumbrados', + pending: 'Locais a aguardar preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições de página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', + unmarked: 'Tokens que já não são locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + calibrated: + 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + pruned: + 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', + readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não utiliza uma grelha hexadecimal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém centros hexadecimais.', + tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione primeiro um ou mais tokens.', + noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', + nothingToUndo: 'Não há enchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + unexpected: 'Algo correu mal: {message}', + }, + hints: { + noPage: 'Abra a página na qual pretende trabalhar ou selecione algo da mesma.', + notHex: 'Defina a grelha da página para Hex (V) ou Hex (H) nas Definições da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre à volta da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', + tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + unknownCommand: 'Introduza !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as definições.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + calibrateFailed: + 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + unexpected: 'Os detalhes estão no log da consola da API.', + }, + help: { + menu: 'Mostre o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', + resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma definição ou mostre todas as definições.', + pageSet: 'Substituir uma configuração de revelação apenas na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + calibrate: + 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + subtitle: 'Convés de Comando', + drawDesc: + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + locationsDesc: + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + footer: 'Consulte o folheto "{help}" para obter as instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexadecimal para Roll20', + footer: 'Utilize o folheto "{deck}" para controlos de um clique.', + overview: { + heading: 'Visão geral', + body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', + 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', + 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Apenas os GMs podem usar estes comandos. A maioria atua sobre os objetos selecionados; o resto atua na página que está a visualizar.', + colCommand: 'Comando', + colDesc: 'O que faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', + 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + colKey: 'Chave', + colName: 'Definição', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', + 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + ], + }, + upgrading: { + heading: 'Atualização da versão 1', + points: [ + 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', + 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', + 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', + 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versão 2 mantida pela', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index ff8b4c5632..c68cdcb5c5 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -1 +1,374 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Геразведка готова.', + settings: 'Настройки Hexploration', + languages: 'Выберите язык', + pageSettings: 'Настройки страницы: {page}', + status: 'Статус гексоразведки: {page}', + help: 'Команды гексоразведки', + confirm: 'Пожалуйста, подтвердите', + }, + discovery: { + title: 'Местоположение обнаружено', + }, + menu: { + draw: 'Рисовать', + reveal: 'Показать и скрыть', + locations: 'Локации', + tools: 'Инструменты', + layerInUse: 'Новые гексы рисуются на {layer}.', + pageSettingsHelp: + 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', + }, + buttons: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + undo: 'Отменить заливку', + reveal: 'Раскрывать', + conceal: 'Скрыть', + explore: 'Исследовать', + revealPage: 'Открыть страницу', + resetPage: 'Сбросить страницу', + mark: 'Отметить местоположение', + unmark: 'Снять отметку', + name: 'Шестнадцатеричное имя', + settings: 'Настройки', + pageSettings: 'Настройки страницы', + status: 'Статус', + rescan: 'Повторное сканирование', + calibrate: 'Калибровка', + calibrateReset: 'Сброс калибровки', + help: 'Помощь', + change: 'Изменять', + menu: 'Меню', + clearOverrides: 'Очистить переопределения', + confirmReset: 'Да, удалить все шестигранники', + }, + prompts: { + name: 'Название местоположения (оставьте пустым, чтобы очистить)', + }, + values: { + on: 'На', + off: 'Выключенный', + none: 'Никто', + hexLayer: { + auto: 'Авто (на переднем плане, если доступно)', + foreground: 'передний слой', + objects: 'слой токенов', + }, + revealBy: { + players: 'Жетоны игроков', + characters: 'Жетоны персонажей', + all: 'Все токены', + }, + revealMode: { + clear: 'Прозрачный', + glimpse: 'Случайно заметить', + }, + announce: { + all: 'Каждый', + gm: 'только ГМ', + off: 'Выключенный', + }, + orientation: { + vertical: 'Шестигранник (В)', + horizontal: 'Шестигранник (H)', + }, + fillKind: { + fill: 'Наполнять', + fillInverse: 'Обратная заливка', + conceal: 'Скрыть', + }, + }, + settings: { + language: { + label: 'Язык', + desc: 'Язык меню, сообщений и раздаточных материалов.', + }, + hexLayer: { + label: 'Шестнадцатеричный слой', + desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + }, + fillColor: { + label: 'Цвет заливки', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Цвет границы', + desc: 'Цвет контура новых гексов.', + }, + labelColor: { + label: 'Цвет этикетки', + desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + }, + glimpseColor: { + label: 'Взгляд цвета', + desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + }, + strokeWidth: { + label: 'Ширина границы', + desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + }, + maxDistance: { + label: 'Расстояние раскрытия шестигранника', + desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', + }, + revealDistance: { + label: 'Расстояние обзора', + desc: 'Сколько гексов вокруг движущегося жетона обнаружено (от 0 до 20). 0 показывает только те гексы, через которые проходит фишка.', + }, + lineOfSight: { + label: 'Линия видимости', + desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', + }, + revealPath: { + label: 'Показать вдоль пути', + desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', + }, + revealBy: { + label: 'Жетоны, которые раскрывают', + desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', + }, + revealMode: { + label: 'Режим раскрытия', + desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + }, + announce: { + label: 'Объявлять об открытиях', + desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', + }, + pingDiscoveries: { + label: 'Пинг-открытия', + desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + }, + hideCoveredTokens: { + label: 'Скрыть покрытые токены', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + }, + }, + status: { + engine: 'Игровой движок', + grid: 'Сетка', + layer: 'Шестнадцатеричный слой', + hexes: 'шестиугольники', + named: 'Именованные шестигранники', + icons: 'Жетоны местоположения', + glimpsed: 'Замеченные гексы', + pending: 'Места, ожидающие заполнения', + calibrated: 'Калиброванный', + overrides: 'Переопределения страниц', + undo: 'Отмена доступна', + }, + messages: { + filled: + 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', + revealed: 'Обнаружены гексы: {count}.', + revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + confirmReset: + 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + resetPage: 'Со страницы удалены шестигранники: {count}.', + undone: + 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Шестигранники с именем "{name}": {count}.', + unnamed: 'Имена удалены: {count}.', + marked: + 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', + unmarked: 'Токены, которые больше не являются локациями: {count}.', + settingChanged: 'Для {setting} установлено значение {value}.', + rescanned: + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + calibrated: + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + calibrationReset: + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', + migrated: + 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + pruned: + 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + readyHint: + 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + }, + warnings: { + foregroundUnavailable: + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + someFailed: + 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', + }, + errors: { + noPage: 'Не удалось найти страницу для работы.', + notHex: 'На этой странице не используется шестигранная сетка.', + noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', + emptyArea: 'Выбранная область не содержит шестигранных центров.', + tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', + nothingToReveal: 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + noTokens: 'Сначала выберите один или несколько жетонов.', + noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', + nothingToUndo: 'Нет заливки, которую можно было бы отменить.', + unknownCommand: 'Неизвестная команда: {command}', + unknownSetting: 'Неизвестная настройка: {key}.', + unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', + invalidValue: '«{value}» не является допустимым значением для {key}.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', + unexpected: 'Что-то пошло не так: {message}', + }, + hints: { + noPage: 'Откройте страницу, над которой хотите работать, или выберите что-нибудь на ней.', + notHex: 'Установите сетку страницы на Hex (V) или Hex (H) в настройках страницы.', + noPolygons: + 'Нарисуйте многоугольник, прямоугольник, эллипс или фигуру от руки вокруг области, выберите ее и повторите попытку.', + emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', + tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', + noHexes: + 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', + unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', + calibrateNeedsTokens: + 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + calibrateFailed: + 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + unexpected: 'Подробности в журнале консоли API.', + }, + help: { + menu: 'Покажите меню.', + fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', + undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', + revealPage: 'Раскройте каждый гекс на странице без объявлений.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', + explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', + mark: 'Превратите выбранные жетоны в скрытые локации.', + unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', + set: 'Измените настройку или отобразите все настройки.', + pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageClear: 'Удалить переопределения текущей страницы.', + rescan: + 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + calibrate: + 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + calibrateReset: 'Удалить калибровку текущей страницы.', + status: 'Покажите, что Hexploration знает о текущей странице.', + journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + help: 'Покажите этот список.', + handout: 'Полные инструкции приведены в раздаточном материале «{name}».', + }, + deck: { + subtitle: 'Командная колода', + drawDesc: + 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + revealDesc: + 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + locationsDesc: + 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', + toolsDesc: + 'Настройки, переопределение страниц, статус, повторное сканирование скопированных страниц и калибровка сетки.', + footer: 'Подробные инструкции см. в раздаточном материале «{help}».', + }, + handout: { + versionLabel: 'Версия', + subtitle: 'Шестнадцатеричное исследование для Roll20', + footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', + overview: { + heading: 'Обзор', + body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + demo: 'Посмотрите короткую демонстрацию (из версии 1)', + }, + quickStart: { + heading: 'Быстрый старт', + steps: [ + 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', + 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', + 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', + 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', + 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + ], + }, + commands: { + heading: 'Команды', + intro: + 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + colCommand: 'Команда', + colDesc: 'Что он делает', + }, + revealing: { + heading: 'Как работает выявление', + points: [ + 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', + 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', + 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', + 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', + 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + ], + }, + locations: { + heading: 'Именованные гексы и локации', + points: [ + 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', + 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', + 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', + 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + ], + }, + settings: { + heading: 'Настройки', + intro: + 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + colKey: 'Ключ', + colName: 'Параметр', + colDesc: 'Описание', + perPage: '(Можно установить для каждой страницы.)', + }, + jumpgate: { + heading: 'Джампгейт и Наследие', + points: [ + 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', + 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + ], + }, + upgrading: { + heading: 'Обновление с версии 1', + points: [ + 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', + 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', + 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + ], + colV1: 'Команда версии 1', + colV2: 'Команда версии 2', + }, + troubleshooting: { + heading: 'Поиск неисправностей', + points: [ + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', + 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', + 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', + 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', + ], + }, + languages: { + heading: 'Языки', + body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + }, + credits: { + heading: 'Кредиты', + original: 'Оригинальный мод от', + maintainer: 'Версия 2 поддерживается', + marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', + support: + 'Если вы обнаружили ошибку или у вас есть идея, напишите сообщение на форуме Roll20 Mod или откройте проблему на GitHub и включите все сообщения из журнала консоли API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index ff8b4c5632..71fdc90c2c 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -1 +1,369 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Hexploration är redo.', + settings: 'Heexploration Inställningar', + languages: 'Välj ett språk', + pageSettings: 'Sidinställningar: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration kommandon', + confirm: 'Vänligen bekräfta', + }, + discovery: { + title: 'Plats upptäckt', + }, + menu: { + draw: 'Dra', + reveal: 'Avslöja och göm', + locations: 'Platser', + tools: 'Verktyg', + layerInUse: 'Nya sexkanter ritas på {layer}.', + pageSettingsHelp: + 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', + }, + buttons: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + undo: 'Ångra Fyll', + reveal: 'Avslöja', + conceal: 'Dölja', + explore: 'Utforska', + revealPage: 'Avslöja sidan', + resetPage: 'Återställ sida', + mark: 'Markera plats', + unmark: 'Avmarkera', + name: 'Namn Hex', + settings: 'Inställningar', + pageSettings: 'Sidinställningar', + status: 'Status', + rescan: 'Skanna igen', + calibrate: 'Kalibrera', + calibrateReset: 'Återställ kalibrering', + help: 'Hjälp', + change: 'Ändra', + menu: 'Meny', + clearOverrides: 'Rensa åsidosättningar', + confirmReset: 'Ja, ta bort alla hexar', + }, + prompts: { + name: 'Platsnamn (låt vara tomt för att rensa)', + }, + values: { + on: 'På', + off: 'Av', + none: 'Ingen', + hexLayer: { + auto: 'Auto (förgrund om tillgängligt)', + foreground: 'förgrundsskikt', + objects: 'symbollager', + }, + revealBy: { + players: 'Spelarpoletter', + characters: 'Karaktärspoletter', + all: 'Alla tokens', + }, + revealMode: { + clear: 'Rensa', + glimpse: 'Glimt', + }, + announce: { + all: 'Alla', + gm: 'Endast GM', + off: 'Av', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fylla', + fillInverse: 'Omvänd fyllning', + conceal: 'Dölja', + }, + }, + settings: { + language: { + label: 'Språk', + desc: 'Språk för menyer, meddelanden och åhörarkopior.', + }, + hexLayer: { + label: 'Hexlager', + desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + }, + fillColor: { + label: 'Fyllningsfärg', + desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfärg', + desc: 'Färg på konturerna av nya sexkanter.', + }, + labelColor: { + label: 'Etikettfärg', + desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + }, + glimpseColor: { + label: 'Glimt färg', + desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + }, + strokeWidth: { + label: 'Kantbredd', + desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + }, + maxDistance: { + label: 'Hexavslöjande avstånd', + desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', + }, + revealDistance: { + label: 'Siktavstånd', + desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', + }, + lineOfSight: { + label: 'Synlinje', + desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', + }, + revealPath: { + label: 'Avslöja längs vägen', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + }, + revealBy: { + label: 'Tokens som avslöjar', + desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + }, + revealMode: { + label: 'Avslöjande läge', + desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + }, + announce: { + label: 'Tillkännage upptäckter', + desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', + }, + pingDiscoveries: { + label: 'Ping upptäckter', + desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', + }, + hideCoveredTokens: { + label: 'Dölj täckta polletter', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + }, + }, + status: { + engine: 'Spelmotor', + grid: 'Rutnät', + layer: 'Hexskikt', + hexes: 'Hex', + named: 'Namngivna hexar', + icons: 'Platsskyltar', + glimpsed: 'Glimmade hexar', + pending: 'Platser som väntar på fyllning', + calibrated: 'Kalibrerad', + overrides: 'Sida åsidosätter', + undo: 'Ångra tillgängligt', + }, + messages: { + filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', + revealed: 'Hexen avslöjade: {count}.', + revealedPage: 'Varje hex på sidan avslöjas ({count}).', + confirmReset: + 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexen har tagits bort från sidan: {count}.', + undone: + 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + named: 'Hex med namnet "{name}": {count}.', + unnamed: 'Namn raderade: {count}.', + marked: + 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + unmarked: 'Tokens som inte längre är platser: {count}.', + settingChanged: '{setting} inställd på {value}.', + rescanned: + 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + calibrated: + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + calibrationReset: + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + journalRebuilt: '"{help}" och "{deck}" har byggts om.', + migrated: + 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + pruned: + 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + readyHint: + 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', + someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + }, + errors: { + noPage: 'Kunde inte hitta sidan att arbeta på.', + notHex: 'Den här sidan använder inte ett hex-rutnät.', + noPolygons: 'Välj en eller flera ritade former att fylla.', + emptyArea: 'Det valda området innehåller inga hexa-center.', + tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', + nothingToConceal: 'Välj ritade former eller tokens att dölja.', + nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + noTokens: 'Välj först en eller flera tokens.', + noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + nothingToUndo: 'Det finns ingen fyllning att ångra.', + unknownCommand: 'Okänt kommando: {command}', + unknownSetting: 'Okänd inställning: {key}', + unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', + invalidValue: '"{value}" är inte ett giltigt värde för {key}.', + calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', + unexpected: 'Något gick fel: {message}', + }, + hints: { + noPage: 'Öppna sidan du vill arbeta på eller välj något på den.', + notHex: 'Ställ in sidrutnätet på Hex (V) eller Hex (H) i Sidinställningar.', + noPolygons: + 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', + emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', + tooMany: 'Fyll ett mindre område, eller dela området i flera former.', + noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + unknownCommand: 'Skriv !hexploration help för att lista kommandona.', + unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', + calibrateNeedsTokens: + 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', + calibrateFailed: + 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + unexpected: 'Detaljer finns i API-konsolloggen.', + }, + help: { + menu: 'Visa menyn.', + fill: 'Täck de utvalda ritade formerna med hex.', + fillInverse: 'Täck hela sidan utom inuti de valda formerna.', + undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', + reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', + revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', + resetPage: 'Ta bort varje hex på sidan (frågar först).', + name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + mark: 'Förvandla de valda tokens till dolda platser.', + unmark: 'Stoppa de valda tokens från att vara dolda platser.', + set: 'Ändra en inställning eller visa alla inställningar.', + pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', + pageClear: 'Ta bort den aktuella sidans åsidosättningar.', + rescan: 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', + calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrateReset: 'Ta bort den aktuella sidans kalibrering.', + status: 'Visa vad Hexploration vet om den aktuella sidan.', + journal: 'Bygg om hjälp- och kommandodäcken.', + help: 'Visa den här listan.', + handout: 'Fullständiga instruktioner finns i "{name}" handout.', + }, + deck: { + subtitle: 'Kommandodäck', + drawDesc: + 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + revealDesc: + 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + locationsDesc: + 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + toolsDesc: + 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', + footer: 'Se "{help}"-handouten för fullständiga instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-utforskning för Roll20', + footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', + overview: { + heading: 'Översikt', + body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + demo: 'Se en kort demo (från version 1)', + }, + quickStart: { + heading: 'Snabbstart', + steps: [ + 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', + 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', + 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + ], + }, + commands: { + heading: 'Kommandon', + intro: + 'Endast GM:er kan använda dessa kommandon. De flesta agerar på de valda objekten; resten agerar på sidan du tittar på.', + colCommand: 'Kommando', + colDesc: 'Vad den gör', + }, + revealing: { + heading: 'Hur avslöjande fungerar', + points: [ + 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', + 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', + 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', + 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + ], + }, + locations: { + heading: 'Namngivna Hex och platser', + points: [ + 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', + 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', + 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', + 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + ], + }, + settings: { + heading: 'Inställningar', + intro: + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + colKey: 'Nyckel', + colName: 'Miljö', + colDesc: 'Beskrivning', + perPage: '(Kan ställas in per sida.)', + }, + jumpgate: { + heading: 'Jumpgate och Legacy', + points: [ + 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', + 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', + 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + ], + }, + upgrading: { + heading: 'Uppgraderar från version 1', + points: [ + 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', + 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', + 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + ], + colV1: 'Kommandot version 1', + colV2: 'Kommandot version 2', + }, + troubleshooting: { + heading: 'Felsökning', + points: [ + 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', + 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', + ], + }, + languages: { + heading: 'Språk', + body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + }, + credits: { + heading: 'Krediter', + original: 'Originalmod av', + maintainer: 'Version 2 underhålls av', + marketplace: 'Adas konstpaket på Roll20 Marketplace', + support: + 'Om du hittar en bugg eller har en idé, posta i Roll20 Mod-forumet eller öppna ett problem på GitHub och inkludera eventuella meddelanden från API-konsolloggen.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index ff8b4c5632..2a0a859596 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -1 +1,372 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Keşif hazır.', + settings: 'Keşif Ayarları', + languages: 'Bir Dil Seçin', + pageSettings: 'Sayfa Ayarları: {page}', + status: 'Keşif Durumu: {page}', + help: 'Keşif Komutları', + confirm: 'Lütfen Onaylayın', + }, + discovery: { + title: 'Konum Keşfedildi', + }, + menu: { + draw: 'Çizmek', + reveal: 'Göster ve Gizle', + locations: 'Konumlar', + tools: 'Aletler', + layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + pageSettingsHelp: + 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', + }, + buttons: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + undo: 'Doldurmayı Geri Al', + reveal: 'Ortaya çıkarmak', + conceal: 'Gizle', + explore: 'Keşfetmek', + revealPage: 'Sayfayı Göster', + resetPage: 'Sayfayı Sıfırla', + mark: 'Konumu İşaretle', + unmark: 'İşareti kaldır', + name: 'Ad Hex', + settings: 'Ayarlar', + pageSettings: 'Sayfa Ayarları', + status: 'Durum', + rescan: 'Yeniden tara', + calibrate: 'Kalibre et', + calibrateReset: 'Kalibrasyonu Sıfırla', + help: 'Yardım', + change: 'Değiştirmek', + menu: 'Menü', + clearOverrides: 'Geçersiz Kılmaları Temizle', + confirmReset: 'Evet, Tüm Altıgenleri Kaldır', + }, + prompts: { + name: 'Konum adı (temizlemek için boş bırakın)', + }, + values: { + on: 'Açık', + off: 'Kapalı', + none: 'Hiçbiri', + hexLayer: { + auto: 'Otomatik (varsa ön planda)', + foreground: 'ön plan katmanı', + objects: 'belirteç katmanı', + }, + revealBy: { + players: 'Oyuncu jetonları', + characters: 'Karakter belirteçleri', + all: 'Tüm jetonlar', + }, + revealMode: { + clear: 'Temizlemek', + glimpse: 'Kısa bakış', + }, + announce: { + all: 'Herkes', + gm: 'Yalnızca GM', + off: 'Kapalı', + }, + orientation: { + vertical: 'Altıgen (V)', + horizontal: 'Altıgen (H)', + }, + fillKind: { + fill: 'Doldurmak', + fillInverse: 'Ters Doldurma', + conceal: 'Gizle', + }, + }, + settings: { + language: { + label: 'Dil', + desc: 'Menüler, mesajlar ve bildiriler için dil.', + }, + hexLayer: { + label: 'Altıgen Katman', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + }, + fillColor: { + label: 'Dolgu Rengi', + desc: 'Yeni altıgenlerin rengi. Şeffaf altıgenler için rgba() kullanın; örneğin rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kenarlık Rengi', + desc: 'Yeni altıgenlerin ana hatlarının rengi.', + }, + labelColor: { + label: 'Etiket Rengi', + desc: 'Adlandırılmış altıgenlerdeki yalnızca GM ad etiketlerinin rengi.', + }, + glimpseColor: { + label: 'Bakış Rengi', + desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + }, + strokeWidth: { + label: 'Kenar Genişliği', + desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', + }, + maxDistance: { + label: 'Hex Ortaya Çıkma Mesafesi', + desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', + }, + revealDistance: { + label: 'Görüş Mesafesi', + desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + }, + lineOfSight: { + label: 'Görüş Hattı', + desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', + }, + revealPath: { + label: 'Yol Boyunca Ortaya Çıkar', + desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + }, + revealBy: { + label: 'Ortaya Çıkan Tokenlar', + desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', + }, + revealMode: { + label: 'Ortaya Çıkarma Modu', + desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + }, + announce: { + label: 'Keşifleri Duyurun', + desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', + }, + pingDiscoveries: { + label: 'Ping Keşifleri', + desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + }, + hideCoveredTokens: { + label: 'Kapalı Jetonları Gizle', + desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + }, + }, + status: { + engine: 'Oyun motoru', + grid: 'Izgara', + layer: 'Altıgen katman', + hexes: 'Altıgenler', + named: 'Adlandırılmış altıgenler', + icons: 'Konum belirteçleri', + glimpsed: 'Kısa bir bakış altıgenler', + pending: 'Doldurulmayı bekleyen yerler', + calibrated: 'Kalibre edildi', + overrides: 'Sayfa geçersiz kılmaları', + undo: 'Geri alma seçeneği mevcut', + }, + messages: { + filled: + 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', + revealed: 'Büyüler ortaya çıktı: {count}.', + revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', + confirmReset: + '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + undone: + 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', + named: '"{name}" adlı altıgenler: {count}.', + unnamed: 'İsimler temizlendi: {count}.', + marked: + 'Mevcut altıgenlerde gizli konumlar: {attached}. Bunları kapsayan bir sonraki dolgu bekleniyor: {pending}.', + unmarked: 'Artık konum olmayan jetonlar: {count}.', + settingChanged: '{setting}, {value} olarak ayarlandı.', + rescanned: + 'Yeniden tarama tamamlandı. Tutulan: {kept}. Kabul edildi: {adopted}. Yeniden dosyalandı: {moved}. Eksik ve unutulmuş: {dropped}. Etiketler yeniden bağlandı: {labels}. Konum jetonları yeniden bağlandı: {icons}.', + calibrated: + 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + calibrationReset: + 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + migrated: + 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + pruned: + "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", + readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + }, + warnings: { + foregroundUnavailable: + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', + }, + errors: { + noPage: 'Üzerinde çalışılacak sayfa bulunamadı.', + notHex: 'Bu sayfada altıgen ızgara kullanılmamaktadır.', + noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', + emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', + tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', + noTokens: 'Önce bir veya daha fazla jeton seçin.', + noHexes: 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', + nothingToUndo: 'Geri alınacak bir dolgu yok.', + unknownCommand: 'Bilinmeyen komut: {command}', + unknownSetting: 'Bilinmeyen ayar: {key}', + unknownPageSetting: 'Sayfa başına ayarlanabilen ayarlar: {keys}', + invalidValue: '"{value}", {key} için geçerli bir değer değil.', + calibrateNeedsTokens: 'Altıgen merkezlere tutturulmuş bir veya iki jeton seçin.', + calibrateFailed: 'Bu jetonlar kalibrasyon için kullanılamaz.', + unexpected: 'Bir şeyler ters gitti: {message}', + }, + hints: { + noPage: 'Üzerinde çalışmak istediğiniz sayfayı açın veya üzerinde bir şey seçin.', + notHex: "Sayfa Ayarları'nda sayfa ızgarasını Hex (V) veya Hex (H) olarak ayarlayın.", + noPolygons: + 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', + emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', + tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', + noHexes: 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + unknownCommand: 'Komutları listelemek için !hexploration help yazın.', + unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', + calibrateNeedsTokens: + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + calibrateFailed: + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + unexpected: 'Ayrıntılar API konsolu günlüğündedir.', + }, + help: { + menu: 'Menüyü göster.', + fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', + fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', + undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + reveal: + 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', + conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', + explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', + resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', + name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + mark: 'Seçilen jetonları gizli konumlara dönüştürün.', + unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', + pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', + rescan: + 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + calibrate: + 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', + calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', + status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + help: 'Bu listeyi göster.', + handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', + }, + deck: { + subtitle: 'Komut Güvertesi', + drawDesc: + 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + revealDesc: + 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + locationsDesc: + 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + toolsDesc: + 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', + footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', + }, + handout: { + versionLabel: 'Sürüm', + subtitle: 'Roll20 için hex-hex keşif', + footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', + overview: { + heading: 'Genel Bakış', + body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + demo: "Kısa bir demo izleyin (versiyon 1'den)", + }, + quickStart: { + heading: 'Hızlı Başlangıç', + steps: [ + 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', + 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', + "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", + 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', + ], + }, + commands: { + heading: 'Komutlar', + intro: + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", + colCommand: 'Emretmek', + colDesc: 'Ne işe yarar', + }, + revealing: { + heading: 'Açığa Çıkarma Nasıl Çalışır?', + points: [ + 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', + 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', + 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + ], + }, + locations: { + heading: 'Adlandırılmış Altıgenler ve Konumlar', + points: [ + 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', + "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", + 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", + "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + ], + }, + settings: { + heading: 'Ayarlar', + intro: + '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + colKey: 'Anahtar', + colName: 'Ayar', + colDesc: 'Tanım', + perPage: '(Sayfa başına ayarlanabilir.)', + }, + jumpgate: { + heading: 'Jumpgate ve Eski', + points: [ + 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', + 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', + "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + ], + }, + upgrading: { + heading: "Sürüm 1'den yükseltme", + points: [ + "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", + 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', + 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + ], + colV1: 'Sürüm 1 komutu', + colV2: 'Sürüm 2 komutu', + }, + troubleshooting: { + heading: 'Sorun giderme', + points: [ + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', + "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", + 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', + ], + }, + languages: { + heading: 'Diller', + body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + }, + credits: { + heading: 'Kredi', + original: 'Orijinal mod', + maintainer: 'Versiyon 2 tarafından sürdürülen', + marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", + support: + "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index ff8b4c5632..bd25017ef6 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -1 +1,375 @@ -export default {}; +const TRANSLATION = { + titles: { + ready: 'Hexploration готовий.', + settings: 'Налаштування Hexploration', + languages: 'Виберіть мову', + pageSettings: 'Параметри сторінки: {page}', + status: 'Статус дослідження: {page}', + help: 'Команди Hexploration', + confirm: 'Будь ласка, підтвердьте', + }, + discovery: { + title: 'Розташування виявлено', + }, + menu: { + draw: 'малювати', + reveal: 'Відкрити і приховати', + locations: 'Розташування', + tools: 'Інструменти', + layerInUse: 'Нові гекси малюються на {layer}.', + pageSettingsHelp: + 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', + }, + buttons: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + undo: 'Скасувати заповнення', + reveal: 'Розкрити', + conceal: 'Приховати', + explore: 'Досліджуйте', + revealPage: 'Відкрити сторінку', + resetPage: 'Скинути сторінку', + mark: 'Позначте розташування', + unmark: 'Зняти позначку', + name: "Ім'я Hex", + settings: 'Налаштування', + pageSettings: 'Параметри сторінки', + status: 'Статус', + rescan: 'Повторне сканування', + calibrate: 'Відкалібрувати', + calibrateReset: 'Скинути калібрування', + help: 'Довідка', + change: 'Зміна', + menu: 'Меню', + clearOverrides: 'Очистити перевизначення', + confirmReset: 'Так, видалити всі гекси', + }, + prompts: { + name: 'Назва місця (залиште порожнім, щоб очистити)', + }, + values: { + on: 'Увімкнено', + off: 'Вимкнено', + none: 'Жодного', + hexLayer: { + auto: 'Автоматично (на передньому плані, якщо доступно)', + foreground: 'шар переднього плану', + objects: 'маркерний шар', + }, + revealBy: { + players: 'Жетони гравців', + characters: 'Символьні маркери', + all: 'Усі жетони', + }, + revealMode: { + clear: 'ясно', + glimpse: 'Поблиск', + }, + announce: { + all: 'Всі', + gm: 'Тільки GM', + off: 'Вимкнено', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + conceal: 'Приховати', + }, + }, + settings: { + language: { + label: 'Мова', + desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', + }, + hexLayer: { + label: 'Шістнадцятковий шар', + desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + }, + fillColor: { + label: 'Колір заливки', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Колір рамки', + desc: 'Колір контуру нових гексів.', + }, + labelColor: { + label: 'Колір етикетки', + desc: 'Колір написів імен лише для GM на іменованих гексах.', + }, + glimpseColor: { + label: 'Glimpse Color', + desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + }, + strokeWidth: { + label: 'Ширина кордону', + desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', + }, + maxDistance: { + label: 'Шестигранна відстань розкриття', + desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', + }, + revealDistance: { + label: 'Дистанція огляду', + desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', + }, + lineOfSight: { + label: 'Пряма видимість', + desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', + }, + revealPath: { + label: 'Показати уздовж шляху', + desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', + }, + revealBy: { + label: 'Жетони, які розкривають', + desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', + }, + revealMode: { + label: 'Режим виявлення', + desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + }, + announce: { + label: 'Оголосити відкриття', + desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + }, + pingDiscoveries: { + label: 'Ping відкриття', + desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + }, + hideCoveredTokens: { + label: 'Приховати закриті токени', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + }, + }, + status: { + engine: 'Ігровий двигун', + grid: 'Сітка', + layer: 'Шестигранний шар', + hexes: 'Гекси', + named: 'Іменовані гекси', + icons: 'Жетони розташування', + glimpsed: 'Помітені прокляття', + pending: 'Локації очікують на заповнення', + calibrated: 'Відкалібрований', + overrides: 'Перевизначення сторінок', + undo: 'Доступне скасування', + }, + messages: { + filled: + 'Заповнення завершено. Намальовані гекси: {created}. Рестайлінг: {restyled}. Приховані місця: {icons}.', + revealed: 'Розкрито гекси: {count}.', + revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', + confirmReset: + 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + resetPage: 'Зі сторінки видалено шестигранники: {count}.', + undone: + 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', + named: 'Гекси з назвою "{name}": {count}.', + unnamed: 'Імена видалено: {count}.', + marked: + 'Місця, приховані в існуючих гексах: {attached}. Очікування наступного заповнення, яке охопить їх: {pending}.', + unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', + settingChanged: '{setting} встановлено на {value}.', + rescanned: + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + calibrated: + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + calibrationReset: + 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', + migrated: + 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + pruned: + 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + readyHint: + 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + }, + warnings: { + foregroundUnavailable: + 'Ця гра не підтримує малювання на передньому шарі, тому гекси були намальовані на шарі жетонів.', + someFailed: + 'Гекси, які не вдалося намалювати: {count}. Перевірте консоль API для отримання деталей.', + }, + errors: { + noPage: 'Не вдалося знайти сторінку для роботи.', + notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', + emptyArea: 'Вибрана область не містить шестигранних центрів.', + tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', + nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', + nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + noTokens: 'Спочатку виберіть один або кілька токенів.', + noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', + nothingToUndo: 'Немає заповнення, яке можна скасувати.', + unknownCommand: 'Невідома команда: {command}', + unknownSetting: 'Невідоме налаштування: {key}', + unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', + invalidValue: '"{value}" не є дійсним значенням для {key}.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', + unexpected: 'Щось пішло не так: {message}', + }, + hints: { + noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', + notHex: + 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + noPolygons: + 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', + emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', + tooMany: 'Заповніть меншу область або розділіть її на кілька фігур.', + noHexes: + 'Гекси знаходяться на передньому плані або шарі жетонів; перейдіть на цей шар, щоб вибрати їх.', + unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', + unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', + calibrateNeedsTokens: + 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + calibrateFailed: + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + unexpected: 'Подробиці в журналі консолі API.', + }, + help: { + menu: 'Показати меню.', + fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', + undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', + reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', + revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', + resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', + name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', + mark: 'Перетворіть вибрані жетони на приховані місця.', + unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + set: 'Змінити налаштування або показати всі налаштування.', + pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageClear: 'Видаліть перевизначення поточної сторінки.', + rescan: + 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + calibrate: + 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + calibrateReset: 'Видалити калібрування поточної сторінки.', + status: 'Покажіть, що Hexploration знає про поточну сторінку.', + journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + help: 'Покажіть цей список.', + handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', + }, + deck: { + subtitle: 'Командна колода', + drawDesc: + 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + revealDesc: + 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + locationsDesc: + 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', + toolsDesc: + 'Налаштування, перевизначення сторінок, статус, повторне сканування скопійованих сторінок і калібрування сітки.', + footer: 'Перегляньте роздатковий матеріал "{help}", щоб отримати повні інструкції.', + }, + handout: { + versionLabel: 'Версія', + subtitle: 'Шістнадцяткове дослідження для Roll20', + footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', + overview: { + heading: 'Огляд', + body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + demo: 'Перегляньте коротку демонстрацію (з версії 1)', + }, + quickStart: { + heading: 'Швидкий старт', + steps: [ + 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', + 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', + 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', + 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', + 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + ], + }, + commands: { + heading: 'Команди', + intro: + "Тільки GM можуть використовувати ці команди. Більшість діють на обрані об'єкти; решта діють на сторінці, яку ви переглядаєте.", + colCommand: 'Команда', + colDesc: 'Що воно робить', + }, + revealing: { + heading: 'Як працює розкриття', + points: [ + 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', + 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', + 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', + 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', + 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + ], + }, + locations: { + heading: 'Іменовані гекси та локації', + points: [ + 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', + 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', + 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', + 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + ], + }, + settings: { + heading: 'Налаштування', + intro: + 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + colKey: 'ключ', + colName: 'Налаштування', + colDesc: 'опис', + perPage: '(Можна встановити на сторінку.)', + }, + jumpgate: { + heading: 'Jumpgate і Legacy', + points: [ + 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', + 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', + 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + ], + }, + upgrading: { + heading: 'Оновлення з версії 1', + points: [ + 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', + 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', + 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + ], + colV1: 'Команда версії 1', + colV2: 'Команда версії 2', + }, + troubleshooting: { + heading: 'Усунення несправностей', + points: [ + 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', + 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', + 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', + 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', + ], + }, + languages: { + heading: 'Мови', + body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + }, + credits: { + heading: 'Кредити', + original: 'Оригінальний мод від', + maintainer: 'Версія 2 підтримується', + marketplace: 'Художні набори Ади на Roll20 Marketplace', + support: + 'Якщо ви знайшли помилку або маєте ідею, опублікуйте на форумі Roll20 Mod або відкрийте проблему на GitHub і додайте будь-які повідомлення з журналу консолі API.', + }, + }, +}; + +export default TRANSLATION; diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index 4da711f792..606113db1f 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -1,361 +1,356 @@ const TRANSLATION = { titles: { - ready: "H探索已準備就緒。", - settings: "H探索設置", - languages: "選擇語言", - pageSettings: "頁面設定：{page}", - status: "H探索狀態：{page}", - help: "探索命令", - confirm: "請確認", + ready: 'H探索已準備就緒。', + settings: 'H探索設置', + languages: '選擇語言', + pageSettings: '頁面設定：{page}', + status: 'H探索狀態：{page}', + help: '探索命令', + confirm: '請確認', }, discovery: { - title: "發現地點", + title: '發現地點', }, menu: { - draw: "畫", - reveal: "顯示和隱藏", - locations: "地點", - tools: "工具", - layerInUse: "正在 {layer} 上繪製新的六角形。", - pageSettingsHelp: "這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。", + draw: '畫', + reveal: '顯示和隱藏', + locations: '地點', + tools: '工具', + layerInUse: '正在 {layer} 上繪製新的六角形。', + pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { - fill: "充滿", - fillInverse: "反向填充", - undo: "撤銷填充", - reveal: "揭示", - conceal: "隱藏", - explore: "探索", - revealPage: "顯示頁面", - resetPage: "重置頁面", - mark: "標記位置", - unmark: "取消標記", - name: "名稱十六進位", - settings: "設定", - pageSettings: "頁面設定", - status: "地位", - rescan: "重新掃描", - calibrate: "校準", - calibrateReset: "重置校準", - help: "幫助", - change: "改變", - menu: "選單", - clearOverrides: "清除覆蓋", - confirmReset: "是的，刪除所有六角形", + fill: '充滿', + fillInverse: '反向填充', + undo: '撤銷填充', + reveal: '揭示', + conceal: '隱藏', + explore: '探索', + revealPage: '顯示頁面', + resetPage: '重置頁面', + mark: '標記位置', + unmark: '取消標記', + name: '名稱十六進位', + settings: '設定', + pageSettings: '頁面設定', + status: '地位', + rescan: '重新掃描', + calibrate: '校準', + calibrateReset: '重置校準', + help: '幫助', + change: '改變', + menu: '選單', + clearOverrides: '清除覆蓋', + confirmReset: '是的，刪除所有六角形', }, prompts: { - name: "地點名稱（留空以清除）", + name: '地點名稱（留空以清除）', }, values: { - on: "在", - off: "離開", - none: "沒有任何", + on: '在', + off: '離開', + none: '沒有任何', hexLayer: { - auto: "自動（前景，如果可用）", - foreground: "前景層", - objects: "令牌層", + auto: '自動（前景，如果可用）', + foreground: '前景層', + objects: '令牌層', }, revealBy: { - players: "玩家代幣", - characters: "Character tokens", - all: "所有代幣", + players: '玩家代幣', + characters: '字元標記', + all: '所有代幣', }, revealMode: { - clear: "清除", - glimpse: "一瞥", + clear: '清除', + glimpse: '一瞥', }, announce: { - all: "每個人", - gm: "限通用汽車", - off: "離開", + all: '每個人', + gm: '限通用汽車', + off: '離開', }, orientation: { - vertical: "六角 (V)", - horizontal: "六角 (H)", + vertical: '六角 (V)', + horizontal: '六角 (H)', }, fillKind: { - fill: "充滿", - fillInverse: "反向填充", - conceal: "隱藏", + fill: '充滿', + fillInverse: '反向填充', + conceal: '隱藏', }, }, settings: { language: { - label: "語言", - desc: "選單、訊息和講義的語言。", + label: '語言', + desc: '選單、訊息和講義的語言。', }, hexLayer: { - label: "六角層", - desc: "繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。", + label: '六角層', + desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', }, fillColor: { - label: "填充顏色", - desc: "新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。", + label: '填充顏色', + desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', }, strokeColor: { - label: "邊框顏色", - desc: "新六邊形輪廓的顏色。", + label: '邊框顏色', + desc: '新六邊形輪廓的顏色。', }, labelColor: { - label: "標籤顏色", - desc: "命名六角形上僅限 GM 的名稱標籤的顏色。", + label: '標籤顏色', + desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', }, glimpseColor: { - label: "瞥見顏色", - desc: "瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。", + label: '瞥見顏色', + desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', }, strokeWidth: { - label: "邊框寬度", - desc: "新六邊形輪廓的寬度，以像素為單位（0 到 20）。", + label: '邊框寬度', + desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { - label: "十六進位顯示距離", - desc: "應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。", + label: '十六進位顯示距離', + desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', }, revealDistance: { - label: "視距", - desc: "顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。", + label: '視距', + desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', }, lineOfSight: { - label: "視線", - desc: "啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。", + label: '視線', + desc: '啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。', }, revealPath: { - label: "沿路徑顯示", - desc: "啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。", + label: '沿路徑顯示', + desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', }, revealBy: { - label: "揭示的代幣", - desc: "令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。", + label: '揭示的代幣', + desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', }, revealMode: { - label: "揭示模式", - desc: "清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。", + label: '揭示模式', + desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', }, announce: { - label: "宣布發現", - desc: "當發現指定位置時誰會看到聊天訊息。", + label: '宣布發現', + desc: '當發現指定位置時誰會看到聊天訊息。', }, pingDiscoveries: { - label: "平發現", - desc: "啟用後，當發現指定位置時，玩家會被 ping 到該位置。", + label: '平發現', + desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + }, + hideCoveredTokens: { + label: '隱藏覆蓋的令牌', + desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', }, }, status: { - engine: "遊戲引擎", - grid: "網格", - layer: "六角層", - hexes: "六角形", - named: "命名六角形", - icons: "位置標記", - glimpsed: "瞥見的六角形", - pending: "等待填補的地點", - calibrated: "已校準", - overrides: "頁面覆蓋", - undo: "可以撤銷", + engine: '遊戲引擎', + grid: '網格', + layer: '六角層', + hexes: '六角形', + named: '命名六角形', + icons: '位置標記', + glimpsed: '瞥見的六角形', + pending: '等待填補的地點', + calibrated: '已校準', + overrides: '頁面覆蓋', + undo: '可以撤銷', }, messages: { - filled: - "填入完成：繪製 {created} 六角形，重新設計 {restyled} 樣式，隱藏 {icons} 位置。", - revealed: "{count} 十六進位顯示。", - revealedPage: "顯示頁面上的所有 {count} 十六進位。", + filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', + revealed: '六角形顯示：{count}。', + revealedPage: '顯示頁面上的每個十六進位 ({count})。', confirmReset: - "從“{page}”中刪除所有 {count} 十六進位嗎？位置令牌返回令牌層。撤銷無法逆轉此情況。", - resetPage: "從頁面中刪除了 {count} 十六進位。", - undone: - "上次填入撤銷：刪除了 {removed} 六角形，恢復了 {restored} 重新設計的六角形。", - named: "{count} 名為「{name}」的十六進位。", - unnamed: "從 {count} 十六進位清除名稱。", - marked: - "{attached} 隱藏在現有六角形中的位置； {pending} 將被覆蓋它們的下一個填充隱藏。", - unmarked: "{count} 標記不再是位置。", - settingChanged: "{setting} 設定為 {value}。", + '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', + resetPage: '從頁面中刪除的十六進位：{count}。', + undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', + named: '名為「{name}」的六角形：{count}。', + unnamed: '已清除的名稱：{count}。', + marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', + unmarked: '不再是位置的標記：{count}。', + settingChanged: '{setting} 設定為 {value}。', rescanned: - "重新掃描完成：保留 {kept} 十六進制，採用 {adopted}，重新歸檔 {moved}，忘記 {dropped} 缺失的十六進位，重新連結 __HEX_PLACEHOLDER_4%__HOLDER 41_ACE__HOL _HEX_", + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', calibrated: - "網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。", - calibrationReset: - "校準已刪除。重新掃描：{kept} 保留，{moved} 重新歸檔，{adopted} 採用。", - journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - "您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。", + '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', pruned: - "{dropped} 保存的十六進位不再存在並被遺忘。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。", - readyHint: - "在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。", + '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', + readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', }, warnings: { - foregroundUnavailable: - "遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。", - someFailed: "無法繪製 {count} 六角形。檢查 API 控制台以了解詳細資訊。", + foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', + someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', }, errors: { - noPage: "找不到要處理的頁面。", - notHex: "此頁面不使用六角網格。", - noPolygons: "選擇一個或多個要填滿的繪製形狀。", - emptyArea: "所選區域不包含任何六角形中心。", - tooMany: "這會建立 {count} 六角形，一次性就太多了。", - nothingToConceal: "選擇要隱藏的繪製形狀或標記。", - nothingToReveal: "選擇要顯示的六角形、繪製的形狀或標記。", - noTokens: "首先選擇一個或多個令牌。", - noHexes: "首先選擇一個或多個六角形（或站在六角形上的標記）。", - nothingToUndo: "沒有可撤消的填充。", - unknownCommand: "未知指令：{command}", - unknownSetting: "未知設定：{key}", - unknownPageSetting: "每頁可設定的設定：{keys}", - invalidValue: "“{value}”對於 {key} 不是有效值。", - calibrateNeedsTokens: "選擇一或兩個吸附到六角形中心的標記。", - calibrateFailed: "這些令牌不能用於校準。", - unexpected: "出了點問題：{message}", + noPage: '找不到要處理的頁面。', + notHex: '此頁面不使用六角網格。', + noPolygons: '選擇一個或多個要填滿的繪製形狀。', + emptyArea: '所選區域不包含任何六角形中心。', + tooMany: '這會一次建立太多的六角形 ({count})。', + nothingToConceal: '選擇要隱藏的繪製形狀或標記。', + nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + noTokens: '首先選擇一個或多個令牌。', + noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + nothingToUndo: '沒有可撤消的填充。', + unknownCommand: '未知指令：{command}', + unknownSetting: '未知設定：{key}', + unknownPageSetting: '每頁可設定的設定：{keys}', + invalidValue: '“{value}”對於 {key} 不是有效值。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateFailed: '這些令牌不能用於校準。', + unexpected: '出了點問題：{message}', }, hints: { - noPage: "開啟您要處理的頁面，或選擇其中的某些內容。", - notHex: "在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。", - noPolygons: - "圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。", - emptyArea: "繪製更大的形狀，或檢查頁面網格設定。", - tooMany: "填滿較小的區域，或將該區域分割成多個形狀。", - noHexes: "六角形位於前景或令牌層；切換到該層以選擇它們。", - unknownCommand: "鍵入 !hexploration help 以列出指令。", - unknownSetting: "輸入 !hexploration set 查看每個設定。", + noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', + notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', + emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', + tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', + noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + unknownCommand: '鍵入 !hexploration help 以列出指令。', + unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: - "將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。", - calibrateFailed: - "兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。", - unexpected: "詳細資訊位於 API 控制台日誌中。", + '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { - menu: "顯示選單。", - fill: "用六角形覆蓋選定的繪製形狀。", - fillInverse: "覆蓋除所選形狀內部之外的整個頁面。", - undo: "Undo the last fill, inverse fill or conceal, and restore the shapes it used.", - reveal: "顯示選定的六角形以及選定形狀和標記下的六角形。", - revealPage: "顯示頁面上的每個十六進制，無需公告。", - conceal: "再次用六角形覆蓋所選形狀和標記下方的區域。", - explore: "顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。", - resetPage: "刪除頁面上的每個十六進制（首先詢問）。", - name: "命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。", - mark: "將選取的標記變成隱藏位置。", - unmark: "停止將選定的標記隱藏在位置。", - set: "更改設定或顯示所有設定。", - pageSet: "僅覆蓋目前頁面上的顯示設定。", - pageClear: "刪除目前頁面的覆蓋。", - rescan: "重建頁面的十六進位列表，例如複製頁面或遊戲後。", - calibrate: "將六角形網格與對齊到六角形中心的一兩個選定標記對齊。", - calibrateReset: "刪除目前頁面的校準。", - status: "顯示 Hexploration 對目前頁面的了解。", - journal: "重建幫助和命令平台講義。", - help: "顯示此清單。", - handout: "完整說明位於「{name}」講義。", + menu: '顯示選單。', + fill: '用六角形覆蓋選定的繪製形狀。', + fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', + undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', + reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + revealPage: '顯示頁面上的每個十六進制，無需公告。', + conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', + explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', + mark: '將選取的標記變成隱藏位置。', + unmark: '停止將選定的標記隱藏在位置。', + set: '更改設定或顯示所有設定。', + pageSet: '僅覆蓋目前頁面上的顯示設定。', + pageClear: '刪除目前頁面的覆蓋。', + rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrateReset: '刪除目前頁面的校準。', + status: '顯示 Hexploration 對目前頁面的了解。', + journal: '重建幫助和命令平台講義。', + help: '顯示此清單。', + handout: '完整說明位於「{name}」講義。', }, deck: { - subtitle: "指揮台", - drawDesc: - "在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。", + subtitle: '指揮台', + drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', revealDesc: - "選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。", - locationsDesc: - "選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。", - toolsDesc: "設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。", - footer: "有關完整說明，請參閱“{help}”講義。", + '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', + footer: '有關完整說明，請參閱“{help}”講義。', }, handout: { - versionLabel: "版本", - subtitle: "Roll20 的逐十六進位探索", - footer: "使用“{deck}”講義進行一鍵式控制項。", + versionLabel: '版本', + subtitle: 'Roll20 的逐十六進位探索', + footer: '使用“{deck}”講義進行一鍵式控制項。', overview: { - heading: "概述", - body: "Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。", - demo: "觀看簡短的演示（來自版本 1）", + heading: '概述', + body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + demo: '觀看簡短的演示（來自版本 1）', }, quickStart: { - heading: "快速入門", + heading: '快速入門', steps: [ - "開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。", - "在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。", - "選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。", - "可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。", - "移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。", + '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', + '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', + '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', ], }, commands: { - heading: "命令", + heading: '命令', intro: - "只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。", - colCommand: "命令", - colDesc: "它的作用", + '只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。', + colCommand: '命令', + colDesc: '它的作用', }, revealing: { - heading: "揭示如何運作", + heading: '揭示如何運作', points: [ - "只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。", - "標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。", - "視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。", - "六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。", - "在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。", - "API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。", + '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', + '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', + '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', ], }, locations: { - heading: "命名六角形和位置", + heading: '命名六角形和位置', points: [ - "標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。", - "與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。", - "隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。", - "Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。", - "宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。", + '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', + 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', + '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', ], }, settings: { - heading: "設定", + heading: '設定', intro: - "使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。", - colKey: "鑰匙", - colName: "環境", - colDesc: "描述", - perPage: "（可按頁設定。）", + '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + colKey: '鑰匙', + colName: '環境', + colDesc: '描述', + perPage: '（可按頁設定。）', }, jumpgate: { - heading: "跳躍門和遺產", + heading: '跳躍門和遺產', points: [ - "Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。", - "將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。", - "Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。", - "當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。", + 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', + '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', + 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', ], }, upgrading: { - heading: "從版本 1 升級", + heading: '從版本 1 升級', points: [ - "版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。", - "現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。", - "版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。", - "版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。", + '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', + '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', + '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', + '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', ], - colV1: "版本 1 指令", - colV2: "版本 2 指令", + colV1: '版本 1 指令', + colV2: '版本 2 指令', }, troubleshooting: { - heading: "故障排除", + heading: '故障排除', points: [ - "令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。", - "六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。", - "複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。", - "Fill says the area has no hex centres: the shape must contain the centre of at least one hex.", - "For anything else, check the API console log and include its messages when asking for help.", + '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', + 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { - heading: "語言", - body: "透過 !hexploration 設定語言來選擇語言。可用語言：", + heading: '語言', + body: '透過 !hexploration 設定語言來選擇語言。可用語言：', }, credits: { - heading: "製作人員", - original: "原始模組由", - maintainer: "版本 2 維護者", - marketplace: "Roll20 Marketplace 上的 Ada 藝術包", + heading: '製作人員', + original: '原始模組由', + maintainer: '版本 2 維護者', + marketplace: 'Roll20 Marketplace 上的 Ada 藝術包', support: - "如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。", + '如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。', }, }, }; From f9e1f71f7a14feef1ccb99ae2215088b3f6ee732 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 14:19:56 +0000 Subject: [PATCH 07/24] docs(Hexploration): Date the changelog releases The changelog listed versions without saying when they were released, which made it hard to tell how old the version 1 releases are. Add a date to each version heading, matching ConditionTracker's style. The version 1 dates are the last change to each version folder on master; 2.0.0 carries the build date and should be updated on submission. Signed-off-by: Steve Roberts --- Hexploration/CHANGELOG.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Hexploration/CHANGELOG.md b/Hexploration/CHANGELOG.md index 97fa1bc971..9a7940a393 100644 --- a/Hexploration/CHANGELOG.md +++ b/Hexploration/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 2.0.0 +## 2.0.0 - 2026-10-29 A full rewrite by MidNiteShadow7 of Ada Lindberg's Hexploration, which no longer worked in Jumpgate games. @@ -49,18 +49,18 @@ A full rewrite by MidNiteShadow7 of Ada Lindberg's Hexploration, which no longer - Version 1 state is migrated automatically; hexes whose paths no longer exist are forgotten on startup. - Rebuilt with Rollup and Prettier; source split into ES modules with unit and end-to-end tests. -## 1.3 +## 1.3 - 2019-03-19 - Fixed a couple of state bugs. -## 1.2 +## 1.2 - 2018-10-26 - Maximum reveal distance, line-of-sight enforcement and icons for hexes. -## 1.1 +## 1.1 - 2018-04-05 - Chat menu, hex colours, reveal distance, named hexes and inverse fill. -## 1.0 +## 1.0 - 2018-03-13 - Initial release. From 617e0e82e8bb9bbff1196ca45509747d5fba6dec Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 14:38:32 +0000 Subject: [PATCH 08/24] feat(Hexploration): Show the handout languages as a table The Help handout listed all 24 languages as one comma-separated line, which was hard to scan and did not make clear which code to type. Show them as a table with the English name and flag, the native name, and the code to use with !hexploration set language. Add the three column headings to every locale, and rebuild the script and the 2.0.0 snapshot. Signed-off-by: Steve Roberts --- Hexploration/2.0.0/Hexploration.js | 84 ++++++++++++++++++++++-- Hexploration/Hexploration.js | 84 ++++++++++++++++++++++-- Hexploration/src/journals.js | 10 ++- Hexploration/src/locales/locale/af.js | 3 + Hexploration/src/locales/locale/ca.js | 3 + Hexploration/src/locales/locale/cs.js | 3 + Hexploration/src/locales/locale/da.js | 3 + Hexploration/src/locales/locale/de.js | 3 + Hexploration/src/locales/locale/el.js | 3 + Hexploration/src/locales/locale/en-US.js | 3 + Hexploration/src/locales/locale/es.js | 3 + Hexploration/src/locales/locale/fi.js | 3 + Hexploration/src/locales/locale/fr.js | 3 + Hexploration/src/locales/locale/he.js | 3 + Hexploration/src/locales/locale/hu.js | 3 + Hexploration/src/locales/locale/it.js | 3 + Hexploration/src/locales/locale/ja.js | 3 + Hexploration/src/locales/locale/ko.js | 3 + Hexploration/src/locales/locale/nl.js | 3 + Hexploration/src/locales/locale/pl.js | 3 + Hexploration/src/locales/locale/pt-BR.js | 3 + Hexploration/src/locales/locale/pt-PT.js | 3 + Hexploration/src/locales/locale/ru.js | 3 + Hexploration/src/locales/locale/sv.js | 3 + Hexploration/src/locales/locale/tr.js | 3 + Hexploration/src/locales/locale/uk.js | 3 + Hexploration/src/locales/locale/zh-TW.js | 3 + 27 files changed, 239 insertions(+), 11 deletions(-) diff --git a/Hexploration/2.0.0/Hexploration.js b/Hexploration/2.0.0/Hexploration.js index 684e4bf2a0..d8d4f47859 100644 --- a/Hexploration/2.0.0/Hexploration.js +++ b/Hexploration/2.0.0/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T08:23:06.249Z + * Built: 2026-10-29T14:33:58.218Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T08:23:06.249Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T14:33:58.218Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1464,6 +1464,9 @@ const HexplorationMod = (() => { languages: { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Kode', }, credits: { heading: 'Krediete', @@ -1840,6 +1843,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + colLanguage: 'Llengua', + colNative: 'Nom nadiu', + colCode: 'Codi', }, credits: { heading: 'Crèdits', @@ -2197,6 +2203,9 @@ const HexplorationMod = (() => { languages: { heading: '語言', body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + colLanguage: '語言', + colNative: '原生名', + colCode: '程式碼', }, credits: { heading: '製作人員', @@ -2568,6 +2577,9 @@ const HexplorationMod = (() => { languages: { heading: 'Jazyky', body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + colLanguage: 'Jazyk', + colNative: 'Rodné jméno', + colCode: 'Kód', }, credits: { heading: 'Kredity', @@ -2939,6 +2951,9 @@ const HexplorationMod = (() => { languages: { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + colLanguage: 'Sprog', + colNative: 'Indfødt navn', + colCode: 'Kode', }, credits: { heading: 'Kreditter', @@ -3314,6 +3329,9 @@ const HexplorationMod = (() => { languages: { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Code', }, credits: { heading: 'Kredieten', @@ -3681,6 +3699,9 @@ const HexplorationMod = (() => { languages: { heading: 'Languages', body: 'Choose a language with !hexploration set language. Available languages:', + colLanguage: 'Language', + colNative: 'Native name', + colCode: 'Code', }, credits: { heading: 'Credits', @@ -4053,6 +4074,9 @@ const HexplorationMod = (() => { languages: { heading: 'Kielet', body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + colLanguage: 'Kieli', + colNative: 'Alkuperäinen nimi', + colCode: 'Koodi', }, credits: { heading: 'Krediitit', @@ -4431,6 +4455,9 @@ const HexplorationMod = (() => { languages: { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + colLanguage: 'Langue', + colNative: 'Nom natif', + colCode: 'Code', }, credits: { heading: 'Crédits', @@ -4815,6 +4842,9 @@ const HexplorationMod = (() => { languages: { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + colLanguage: 'Sprache', + colNative: 'Einheimischer Name', + colCode: 'Code', }, credits: { heading: 'Credits', @@ -5189,6 +5219,9 @@ const HexplorationMod = (() => { languages: { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + colLanguage: 'Γλώσσα', + colNative: 'Εγγενές όνομα', + colCode: 'Κώδικας', }, credits: { heading: 'Πιστώσεις', @@ -5554,6 +5587,9 @@ const HexplorationMod = (() => { languages: { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + colLanguage: 'שָׂפָה', + colNative: 'שם יליד', + colCode: 'קוד', }, credits: { heading: 'קרדיטים', @@ -5929,6 +5965,9 @@ const HexplorationMod = (() => { languages: { heading: 'Nyelvek', body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + colLanguage: 'Nyelv', + colNative: 'Natív név', + colCode: 'Kód', }, credits: { heading: 'Kredit', @@ -6305,6 +6344,9 @@ const HexplorationMod = (() => { languages: { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + colLanguage: 'Lingua', + colNative: 'Nome nativo', + colCode: 'Codice', }, credits: { heading: 'Crediti', @@ -6676,6 +6718,9 @@ const HexplorationMod = (() => { languages: { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', + colLanguage: '言語', + colNative: 'ネイティブネーム', + colCode: 'コード', }, credits: { heading: 'クレジット', @@ -7044,6 +7089,9 @@ const HexplorationMod = (() => { languages: { heading: '언어', body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + colLanguage: '언어', + colNative: '본명', + colCode: '암호', }, credits: { heading: '크레딧', @@ -7416,6 +7464,9 @@ const HexplorationMod = (() => { languages: { heading: 'Języki', body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + colLanguage: 'Język', + colNative: 'Imię rodzime', + colCode: 'Kod', }, credits: { heading: 'Kredyty', @@ -7789,6 +7840,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Idioma', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -8162,6 +8216,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Linguagem', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -8536,6 +8593,9 @@ const HexplorationMod = (() => { languages: { heading: 'Языки', body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + colLanguage: 'Язык', + colNative: 'Родное имя', + colCode: 'Код', }, credits: { heading: 'Кредиты', @@ -8913,6 +8973,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + colLanguage: 'Idioma', + colNative: 'nombre nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -9282,6 +9345,9 @@ const HexplorationMod = (() => { languages: { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + colLanguage: 'Språk', + colNative: 'Inhemskt namn', + colCode: 'Koda', }, credits: { heading: 'Krediter', @@ -9655,6 +9721,9 @@ const HexplorationMod = (() => { languages: { heading: 'Diller', body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + colLanguage: 'Dil', + colNative: 'Yerel ad', + colCode: 'Kod', }, credits: { heading: 'Kredi', @@ -10029,6 +10098,9 @@ const HexplorationMod = (() => { languages: { heading: 'Мови', body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + colLanguage: 'Мова', + colNative: 'Рідна назва', + colCode: 'Код', }, credits: { heading: 'Кредити', @@ -12576,7 +12648,11 @@ const HexplorationMod = (() => { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ + escapeHtml(flag ? `${flag} ${name}` : name), + escapeHtml(nativeName || name), + code(localeCode), + ]); const { original, maintainer } = AUTHOR_LINKS; return `
    @@ -12593,7 +12669,7 @@ const HexplorationMod = (() => { ${section('jumpgate', list(raw('jumpgate.points')))} ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} ${section('troubleshooting', list(raw('troubleshooting.points')))} - ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section('languages', `

    ${h('languages.body')}

    ${table([t('handout.languages.colLanguage', lang), t('handout.languages.colNative', lang), t('handout.languages.colCode', lang)], locales)}`)} ${section( 'credits', `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index 684e4bf2a0..d8d4f47859 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T08:23:06.249Z + * Built: 2026-10-29T14:33:58.218Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T08:23:06.249Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T14:33:58.218Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1464,6 +1464,9 @@ const HexplorationMod = (() => { languages: { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Kode', }, credits: { heading: 'Krediete', @@ -1840,6 +1843,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + colLanguage: 'Llengua', + colNative: 'Nom nadiu', + colCode: 'Codi', }, credits: { heading: 'Crèdits', @@ -2197,6 +2203,9 @@ const HexplorationMod = (() => { languages: { heading: '語言', body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + colLanguage: '語言', + colNative: '原生名', + colCode: '程式碼', }, credits: { heading: '製作人員', @@ -2568,6 +2577,9 @@ const HexplorationMod = (() => { languages: { heading: 'Jazyky', body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + colLanguage: 'Jazyk', + colNative: 'Rodné jméno', + colCode: 'Kód', }, credits: { heading: 'Kredity', @@ -2939,6 +2951,9 @@ const HexplorationMod = (() => { languages: { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + colLanguage: 'Sprog', + colNative: 'Indfødt navn', + colCode: 'Kode', }, credits: { heading: 'Kreditter', @@ -3314,6 +3329,9 @@ const HexplorationMod = (() => { languages: { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Code', }, credits: { heading: 'Kredieten', @@ -3681,6 +3699,9 @@ const HexplorationMod = (() => { languages: { heading: 'Languages', body: 'Choose a language with !hexploration set language. Available languages:', + colLanguage: 'Language', + colNative: 'Native name', + colCode: 'Code', }, credits: { heading: 'Credits', @@ -4053,6 +4074,9 @@ const HexplorationMod = (() => { languages: { heading: 'Kielet', body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + colLanguage: 'Kieli', + colNative: 'Alkuperäinen nimi', + colCode: 'Koodi', }, credits: { heading: 'Krediitit', @@ -4431,6 +4455,9 @@ const HexplorationMod = (() => { languages: { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + colLanguage: 'Langue', + colNative: 'Nom natif', + colCode: 'Code', }, credits: { heading: 'Crédits', @@ -4815,6 +4842,9 @@ const HexplorationMod = (() => { languages: { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + colLanguage: 'Sprache', + colNative: 'Einheimischer Name', + colCode: 'Code', }, credits: { heading: 'Credits', @@ -5189,6 +5219,9 @@ const HexplorationMod = (() => { languages: { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + colLanguage: 'Γλώσσα', + colNative: 'Εγγενές όνομα', + colCode: 'Κώδικας', }, credits: { heading: 'Πιστώσεις', @@ -5554,6 +5587,9 @@ const HexplorationMod = (() => { languages: { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + colLanguage: 'שָׂפָה', + colNative: 'שם יליד', + colCode: 'קוד', }, credits: { heading: 'קרדיטים', @@ -5929,6 +5965,9 @@ const HexplorationMod = (() => { languages: { heading: 'Nyelvek', body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + colLanguage: 'Nyelv', + colNative: 'Natív név', + colCode: 'Kód', }, credits: { heading: 'Kredit', @@ -6305,6 +6344,9 @@ const HexplorationMod = (() => { languages: { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + colLanguage: 'Lingua', + colNative: 'Nome nativo', + colCode: 'Codice', }, credits: { heading: 'Crediti', @@ -6676,6 +6718,9 @@ const HexplorationMod = (() => { languages: { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', + colLanguage: '言語', + colNative: 'ネイティブネーム', + colCode: 'コード', }, credits: { heading: 'クレジット', @@ -7044,6 +7089,9 @@ const HexplorationMod = (() => { languages: { heading: '언어', body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + colLanguage: '언어', + colNative: '본명', + colCode: '암호', }, credits: { heading: '크레딧', @@ -7416,6 +7464,9 @@ const HexplorationMod = (() => { languages: { heading: 'Języki', body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + colLanguage: 'Język', + colNative: 'Imię rodzime', + colCode: 'Kod', }, credits: { heading: 'Kredyty', @@ -7789,6 +7840,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Idioma', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -8162,6 +8216,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Linguagem', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -8536,6 +8593,9 @@ const HexplorationMod = (() => { languages: { heading: 'Языки', body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + colLanguage: 'Язык', + colNative: 'Родное имя', + colCode: 'Код', }, credits: { heading: 'Кредиты', @@ -8913,6 +8973,9 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + colLanguage: 'Idioma', + colNative: 'nombre nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', @@ -9282,6 +9345,9 @@ const HexplorationMod = (() => { languages: { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + colLanguage: 'Språk', + colNative: 'Inhemskt namn', + colCode: 'Koda', }, credits: { heading: 'Krediter', @@ -9655,6 +9721,9 @@ const HexplorationMod = (() => { languages: { heading: 'Diller', body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + colLanguage: 'Dil', + colNative: 'Yerel ad', + colCode: 'Kod', }, credits: { heading: 'Kredi', @@ -10029,6 +10098,9 @@ const HexplorationMod = (() => { languages: { heading: 'Мови', body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + colLanguage: 'Мова', + colNative: 'Рідна назва', + colCode: 'Код', }, credits: { heading: 'Кредити', @@ -12576,7 +12648,11 @@ const HexplorationMod = (() => { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ + escapeHtml(flag ? `${flag} ${name}` : name), + escapeHtml(nativeName || name), + code(localeCode), + ]); const { original, maintainer } = AUTHOR_LINKS; return `
    @@ -12593,7 +12669,7 @@ const HexplorationMod = (() => { ${section('jumpgate', list(raw('jumpgate.points')))} ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} ${section('troubleshooting', list(raw('troubleshooting.points')))} - ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section('languages', `

    ${h('languages.body')}

    ${table([t('handout.languages.colLanguage', lang), t('handout.languages.colNative', lang), t('handout.languages.colCode', lang)], locales)}`)} ${section( 'credits', `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    diff --git a/Hexploration/src/journals.js b/Hexploration/src/journals.js index c57fae9832..e04b64c8d3 100644 --- a/Hexploration/src/journals.js +++ b/Hexploration/src/journals.js @@ -20,7 +20,7 @@ import { SCRIPT_NAME, SCRIPT_VERSION, } from './constants.js'; -import { getDirectionStyle, getLocale, LOCALE_LABELS, SUPPORTED_LOCALES, t, tRaw } from './i18n.js'; +import { getDirectionStyle, getLocale, LOCALE_DEFINITIONS, t, tRaw } from './i18n.js'; import { getConfig } from './state.js'; import { escapeHtml } from './utils.js'; @@ -137,7 +137,11 @@ export function buildHelpHtml(locale) { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = SUPPORTED_LOCALES.map((c) => escapeHtml(LOCALE_LABELS[c])).join(', '); + const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ + escapeHtml(flag ? `${flag} ${name}` : name), + escapeHtml(nativeName || name), + code(localeCode), + ]); const { original, maintainer } = AUTHOR_LINKS; return `
    @@ -154,7 +158,7 @@ export function buildHelpHtml(locale) { ${section('jumpgate', list(raw('jumpgate.points')))} ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} ${section('troubleshooting', list(raw('troubleshooting.points')))} - ${section('languages', `

    ${h('languages.body')}

    ${locales}

    `)} + ${section('languages', `

    ${h('languages.body')}

    ${table([t('handout.languages.colLanguage', lang), t('handout.languages.colNative', lang), t('handout.languages.colCode', lang)], locales)}`)} ${section( 'credits', `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index 642b8477ec..b3268090af 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -357,6 +357,9 @@ const TRANSLATION = { languages: { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Kode', }, credits: { heading: 'Krediete', diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index b2b924e306..104617b2fe 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -362,6 +362,9 @@ const TRANSLATION = { languages: { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + colLanguage: 'Llengua', + colNative: 'Nom nadiu', + colCode: 'Codi', }, credits: { heading: 'Crèdits', diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index 3c171e4cfd..9c8ff3c65d 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -357,6 +357,9 @@ const TRANSLATION = { languages: { heading: 'Jazyky', body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + colLanguage: 'Jazyk', + colNative: 'Rodné jméno', + colCode: 'Kód', }, credits: { heading: 'Kredity', diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index e17e753284..08f8791091 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -355,6 +355,9 @@ const TRANSLATION = { languages: { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + colLanguage: 'Sprog', + colNative: 'Indfødt navn', + colCode: 'Kode', }, credits: { heading: 'Kreditter', diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index f16bcf0608..4a57d25a31 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -367,6 +367,9 @@ const TRANSLATION = { languages: { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + colLanguage: 'Sprache', + colNative: 'Einheimischer Name', + colCode: 'Code', }, credits: { heading: 'Credits', diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index af0ebade76..c91b18e17b 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -360,6 +360,9 @@ const TRANSLATION = { languages: { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + colLanguage: 'Γλώσσα', + colNative: 'Εγγενές όνομα', + colCode: 'Κώδικας', }, credits: { heading: 'Πιστώσεις', diff --git a/Hexploration/src/locales/locale/en-US.js b/Hexploration/src/locales/locale/en-US.js index c539e8eafc..cb6b0d08ac 100644 --- a/Hexploration/src/locales/locale/en-US.js +++ b/Hexploration/src/locales/locale/en-US.js @@ -353,6 +353,9 @@ export default { languages: { heading: 'Languages', body: 'Choose a language with !hexploration set language. Available languages:', + colLanguage: 'Language', + colNative: 'Native name', + colCode: 'Code', }, credits: { heading: 'Credits', diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index 71894b75ad..fd20413b5f 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -362,6 +362,9 @@ const TRANSLATION = { languages: { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + colLanguage: 'Idioma', + colNative: 'nombre nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index a919e12f5b..536b18453f 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -358,6 +358,9 @@ const TRANSLATION = { languages: { heading: 'Kielet', body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + colLanguage: 'Kieli', + colNative: 'Alkuperäinen nimi', + colCode: 'Koodi', }, credits: { heading: 'Krediitit', diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index 1e615953aa..3bbb6a95ca 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -363,6 +363,9 @@ const TRANSLATION = { languages: { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + colLanguage: 'Langue', + colNative: 'Nom natif', + colCode: 'Code', }, credits: { heading: 'Crédits', diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index 0ea4d422dc..4ab24ebd12 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -350,6 +350,9 @@ const TRANSLATION = { languages: { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + colLanguage: 'שָׂפָה', + colNative: 'שם יליד', + colCode: 'קוד', }, credits: { heading: 'קרדיטים', diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index 63326b0418..21ab0fa793 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -361,6 +361,9 @@ const TRANSLATION = { languages: { heading: 'Nyelvek', body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + colLanguage: 'Nyelv', + colNative: 'Natív név', + colCode: 'Kód', }, credits: { heading: 'Kredit', diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index d03842b0f4..a8bb9f69c4 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -361,6 +361,9 @@ const TRANSLATION = { languages: { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + colLanguage: 'Lingua', + colNative: 'Nome nativo', + colCode: 'Codice', }, credits: { heading: 'Crediti', diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index ca66a49be7..e113b452ab 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -356,6 +356,9 @@ const TRANSLATION = { languages: { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', + colLanguage: '言語', + colNative: 'ネイティブネーム', + colCode: 'コード', }, credits: { heading: 'クレジット', diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index 12fcece854..bf220ce239 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -354,6 +354,9 @@ const TRANSLATION = { languages: { heading: '언어', body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + colLanguage: '언어', + colNative: '본명', + colCode: '암호', }, credits: { heading: '크레딧', diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index a709842900..844a1aa91e 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -360,6 +360,9 @@ const TRANSLATION = { languages: { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + colLanguage: 'Taal', + colNative: 'Inheemse naam', + colCode: 'Code', }, credits: { heading: 'Kredieten', diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index 4d04e3e8ce..ae6fb85d64 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -358,6 +358,9 @@ const TRANSLATION = { languages: { heading: 'Języki', body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + colLanguage: 'Język', + colNative: 'Imię rodzime', + colCode: 'Kod', }, credits: { heading: 'Kredyty', diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index 6b0247dc2c..94d9450215 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -358,6 +358,9 @@ const TRANSLATION = { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Linguagem', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index a4f9686946..0a025c537d 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -358,6 +358,9 @@ const TRANSLATION = { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Idioma', + colNative: 'Nome nativo', + colCode: 'Código', }, credits: { heading: 'Créditos', diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index c68cdcb5c5..a77b1eb5d6 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -359,6 +359,9 @@ const TRANSLATION = { languages: { heading: 'Языки', body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + colLanguage: 'Язык', + colNative: 'Родное имя', + colCode: 'Код', }, credits: { heading: 'Кредиты', diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index 71fdc90c2c..c8ebddb39c 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -354,6 +354,9 @@ const TRANSLATION = { languages: { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + colLanguage: 'Språk', + colNative: 'Inhemskt namn', + colCode: 'Koda', }, credits: { heading: 'Krediter', diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index 2a0a859596..24612c72ef 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -357,6 +357,9 @@ const TRANSLATION = { languages: { heading: 'Diller', body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + colLanguage: 'Dil', + colNative: 'Yerel ad', + colCode: 'Kod', }, credits: { heading: 'Kredi', diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index bd25017ef6..fb781cbbca 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -360,6 +360,9 @@ const TRANSLATION = { languages: { heading: 'Мови', body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + colLanguage: 'Мова', + colNative: 'Рідна назва', + colCode: 'Код', }, credits: { heading: 'Кредити', diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index 606113db1f..e2bc8c6354 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -343,6 +343,9 @@ const TRANSLATION = { languages: { heading: '語言', body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + colLanguage: '語言', + colNative: '原生名', + colCode: '程式碼', }, credits: { heading: '製作人員', From 8bb0805623cb12374d34d353803a9667df1ba424 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 15:56:43 +0000 Subject: [PATCH 09/24] fix(Hexploration): Track chat.js in lower case Version 1 had src/Chat.js. The rewrite replaced it on a case-insensitive file system, so git kept the capital C while every import names ./chat.js, which would break the build on a case-sensitive checkout. Rename the tracked file to chat.js to match the imports and the other mods. Signed-off-by: Steve Roberts --- Hexploration/src/{Chat.js => chat.js} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Hexploration/src/{Chat.js => chat.js} (100%) diff --git a/Hexploration/src/Chat.js b/Hexploration/src/chat.js similarity index 100% rename from Hexploration/src/Chat.js rename to Hexploration/src/chat.js From 810e9836c546b005f222959dce895b4818c40c32 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 15:56:45 +0000 Subject: [PATCH 10/24] fix(Hexploration): Correct the machine translations Google Translate read "hex" as hexadecimal in 15 languages, as "witches" in Afrikaans, and turned "Command Deck" into a ship's deck. Many button and setting labels were also unnatural, and some help text quoted labels that did not match the buttons. Hand-translate the affected strings, review the labels in every locale, and keep the help text in step with the labels it quotes. Keep "Command Deck" in English everywhere: it is the name of a handout, so the deck subtitle now comes from a DECK_TITLE constant rather than a translation. Signed-off-by: Steve Roberts --- Hexploration/src/constants.js | 4 +- Hexploration/src/journals.js | 3 +- Hexploration/src/locales/locale/af.js | 259 ++++++++++++----------- Hexploration/src/locales/locale/ca.js | 171 ++++++++------- Hexploration/src/locales/locale/cs.js | 155 +++++++------- Hexploration/src/locales/locale/da.js | 151 +++++++------ Hexploration/src/locales/locale/de.js | 137 ++++++------ Hexploration/src/locales/locale/el.js | 145 +++++++------ Hexploration/src/locales/locale/en-US.js | 1 - Hexploration/src/locales/locale/es.js | 117 +++++----- Hexploration/src/locales/locale/fi.js | 168 +++++++-------- Hexploration/src/locales/locale/fr.js | 99 +++++---- Hexploration/src/locales/locale/he.js | 182 ++++++++-------- Hexploration/src/locales/locale/hu.js | 170 ++++++++------- Hexploration/src/locales/locale/it.js | 170 ++++++++------- Hexploration/src/locales/locale/ja.js | 181 ++++++++-------- Hexploration/src/locales/locale/ko.js | 205 +++++++++--------- Hexploration/src/locales/locale/nl.js | 143 +++++++------ Hexploration/src/locales/locale/pl.js | 170 +++++++-------- Hexploration/src/locales/locale/pt-BR.js | 155 +++++++------- Hexploration/src/locales/locale/pt-PT.js | 168 +++++++-------- Hexploration/src/locales/locale/ru.js | 190 ++++++++--------- Hexploration/src/locales/locale/sv.js | 125 ++++++----- Hexploration/src/locales/locale/tr.js | 163 +++++++------- Hexploration/src/locales/locale/uk.js | 177 ++++++++-------- Hexploration/src/locales/locale/zh-TW.js | 175 ++++++++------- 26 files changed, 1883 insertions(+), 1901 deletions(-) diff --git a/Hexploration/src/constants.js b/Hexploration/src/constants.js index 346c4cf5d4..6467d0b63e 100644 --- a/Hexploration/src/constants.js +++ b/Hexploration/src/constants.js @@ -22,7 +22,9 @@ export const LEGACY_COMMANDS = { export const LEGACY_ARG_SEPARATOR = '&&'; export const HANDOUT_HELP_NAME = 'Hexploration - Help'; -export const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; +// The deck's name is not translated, so it always matches the handout's name. +export const DECK_TITLE = 'Command Deck'; +export const HANDOUT_DECK_NAME = `Hexploration - ${DECK_TITLE}`; export const AUTHOR_LINKS = { original: { diff --git a/Hexploration/src/journals.js b/Hexploration/src/journals.js index e04b64c8d3..b16da887cf 100644 --- a/Hexploration/src/journals.js +++ b/Hexploration/src/journals.js @@ -12,6 +12,7 @@ import { COLOR_MUTED, COLOR_TEXT, COMMAND, + DECK_TITLE, DEFAULT_CONFIG, DEMO_GIF_URL, HANDOUT_DECK_NAME, @@ -186,7 +187,7 @@ export function buildDeckHtml(locale) { return `

    ⬢ ${SCRIPT_NAME} ⬢

    -

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +

    ${DECK_TITLE} • v${SCRIPT_VERSION}

    ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index b3268090af..a60d44c6c5 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -1,11 +1,11 @@ const TRANSLATION = { titles: { - ready: 'Heeksplorasie is gereed.', - settings: 'Heksplorasie-instellings', + ready: 'Hexploration is gereed.', + settings: 'Hexploration-instellings', languages: "Kies 'n taal", pageSettings: 'Bladsyinstellings: {page}', - status: 'Heksplorasiestatus: {page}', - help: 'Heksplorasie-opdragte', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdragte', confirm: 'Bevestig asseblief', }, discovery: { @@ -16,14 +16,14 @@ const TRANSLATION = { reveal: 'Openbaar en versteek', locations: 'Liggings', tools: 'Gereedskap', - layerInUse: 'Nuwe hekse word op die {layer} geteken.', + layerInUse: 'Nuwe seshoeke word op die {layer} geteken.', pageSettingsHelp: - 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', + 'Hierdie instellings geld slegs vir hierdie bladsy. Instellings gemerk met ★ oorskryf die globale instellings.', }, buttons: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', - undo: 'Ontdoen vul', + fillInverse: 'Omgekeerde vulling', + undo: 'Ontdoen vulling', reveal: 'Onthul', conceal: 'Versteek', explore: 'Verken', @@ -31,18 +31,18 @@ const TRANSLATION = { resetPage: 'Stel bladsy terug', mark: 'Merk ligging', unmark: 'Ontmerk', - name: 'Noem Hex', + name: 'Benoem seshoek', settings: 'Instellings', pageSettings: 'Bladsy-instellings', status: 'Status', rescan: 'Skandeer weer', calibrate: 'Kalibreer', - calibrateReset: 'Stel Kalibrasie terug', - help: 'Help', + calibrateReset: 'Stel kalibrasie terug', + help: 'Hulp', change: 'Verander', - menu: 'Spyskaart', + menu: 'Kieslys', clearOverrides: 'Vee oorskrywings uit', - confirmReset: 'Ja, verwyder alle hekse', + confirmReset: 'Ja, verwyder alle seshoeke', }, prompts: { name: 'Liggingnaam (laat leeg om skoon te maak)', @@ -53,17 +53,17 @@ const TRANSLATION = { none: 'Geen', hexLayer: { auto: 'Outo (voorgrond indien beskikbaar)', - foreground: 'voorgrond laag', - objects: 'tekenlaag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Speler tokens', - characters: 'Karaktertekens', - all: 'Alle tekens', + players: 'Speler-tokens', + characters: 'Karaktertokens', + all: 'Alle tokens', }, revealMode: { - clear: 'Duidelik', - glimpse: 'Glimpie', + clear: 'Verwyder', + glimpse: 'Glimp', }, announce: { all: 'Almal', @@ -71,109 +71,109 @@ const TRANSLATION = { off: 'Af', }, orientation: { - vertical: 'Heks (V)', - horizontal: 'Heks (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', + fillInverse: 'Omgekeerde vulling', conceal: 'Versteek', }, }, settings: { language: { label: 'Taal', - desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', + desc: 'Taal vir kieslyste, boodskappe en uitdeelstukke.', }, hexLayer: { - label: 'Hex laag', - desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', + label: 'Seshoeklaag', + desc: 'Waar nuwe seshoeke geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die tokenlaag as die speletjie dit nie ondersteun nie.', }, fillColor: { - label: 'Vul kleur', - desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', + label: 'Vulkleur', + desc: 'Kleur van nuwe seshoeke. Gebruik rgba() vir deursigtige seshoeke, byvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Rand Kleur', - desc: 'Kleur van die buitelyn van nuwe hekse.', + label: 'Randkleur', + desc: 'Kleur van die buitelyn van nuwe seshoeke.', }, labelColor: { - label: 'Etiket Kleur', - desc: 'Kleur van die GM-net naametikette op benoemde hekse.', + label: 'Etiketkleur', + desc: 'Kleur van die naametikette wat net die GM sien, op benoemde seshoeke.', }, glimpseColor: { - label: 'Glimp kleur', - desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + label: 'Glimpkleur', + desc: "Kleur waarna seshoeke verander wanneer hulle deurskynend word (Glimp-onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", }, strokeWidth: { - label: 'Grens breedte', - desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', + label: 'Randdikte', + desc: 'Dikte van die buitelyn van nuwe seshoeke, in pieksels (0 tot 20).', }, maxDistance: { - label: 'Hex Reveal Distance', - desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + label: 'Seshoek-onthullingsafstand', + desc: "Word op seshoeke toegepas wanneer hulle geteken word: 'n token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", }, revealDistance: { label: 'Sigafstand', - desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + desc: "Hoeveel seshoeke rondom 'n bewegende token onthul word (0 tot 20). 0 onthul slegs die seshoeke waardeur die token beweeg.", }, lineOfSight: { label: 'Siglyn', - desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + desc: "Wanneer dit aan is, word 'n seshoek slegs onthul as geen bedekte seshoek tussen dit en die token lê nie.", }, revealPath: { - label: 'Openbaar Langs Pad', - desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + label: 'Onthul langs pad', + desc: "Wanneer dit aan is, word elke seshoek waardeur 'n token beweeg terwyl dit gesleep word (insluitend tussenpunte), onthul, nie net waar dit stop nie.", }, revealBy: { - label: 'Tekens wat openbaar', - desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + label: 'Tokens wat onthul', + desc: "Watter tokens op die tokenlaag seshoeke onthul: tokens wat deur 'n speler beheer word, tokens wat enige karakter verteenwoordig, of elke token.", }, revealMode: { label: 'Onthullingsmodus', - desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + desc: "Met Verwyder word seshoeke binne sig verwyder. Met Glimp word hulle eerder deurskynend; hulle word verwyder wanneer 'n token hulle binnegaan.", }, announce: { label: 'Kondig ontdekkings aan', desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", }, pingDiscoveries: { - label: 'Ping Ontdekkings', + label: 'Ping ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, hideCoveredTokens: { - label: 'Versteek bedekte tekens', - desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + label: 'Versteek bedekte tokens', + desc: "Roll20 teken name, balke en auras bo seshoeke. Wanneer dit aan is, word die naam, balke en auras wat spelers kan sien, afgeskakel vir tokens onder 'n bedekte seshoek, en weer aangeskakel wanneer hulle ontbloot word.", }, }, status: { - engine: 'Spel enjin', + engine: 'Spelenjin', grid: 'Rooster', - layer: 'Hex laag', - hexes: 'Hekse', - named: 'Benoemde hekse', - icons: 'Liggingtekens', - glimpsed: 'Geskimpte hekkies', - pending: "Liggings wat wag vir 'n vulling", + layer: 'Seshoeklaag', + hexes: 'Seshoeke', + named: 'Benoemde seshoeke', + icons: 'Liggingtokens', + glimpsed: 'Deurskynende seshoeke', + pending: "Liggings wat op 'n vulling wag", calibrated: 'Gekalibreer', - overrides: 'Bladsy ignoreer', + overrides: 'Bladsy-oorskrywings', undo: 'Ontdoen beskikbaar', }, messages: { filled: - 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', - revealed: 'Hekse geopenbaar: {count}.', - revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', + 'Vulling voltooi. Seshoeke geteken: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Seshoeke onthul: {count}.', + revealedPage: 'Elke seshoek op die bladsy is onthul ({count}).', confirmReset: - 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: 'Hekse verwyder van die bladsy: {count}.', + 'Verwyder elke seshoek van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Seshoeke van die bladsy verwyder: {count}.', undone: - 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', - named: 'Hekse genaamd "{name}": {count}.', + 'Laaste vulling ontdoen. Seshoeke verwyder: {removed}. Herstileerde seshoeke herstel: {restored}.', + named: 'Seshoeke benoem as "{name}": {count}.', unnamed: 'Name skoongemaak: {count}.', marked: - 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', - unmarked: 'Tekens wat nie meer liggings is nie: {count}.', + 'Liggings versteek in bestaande seshoeke: {attached}. Wag vir die volgende vulling wat hulle bedek: {pending}.', + unmarked: 'Tokens wat nie meer liggings is nie: {count}.', settingChanged: '{setting} gestel na {value}.', rescanned: 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', @@ -183,35 +183,35 @@ const TRANSLATION = { 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: - "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + "Jou Hexploration 1.x-seshoekkaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, gebruik Skandeer weer op elke seshoekkaartbladsy.", pruned: - 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + 'Gestoorde seshoeke wat nie meer bestaan nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, gebruik Skandeer weer op die bladsy om sy seshoeke weer op te tel.', readyHint: - 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + 'Tik !hexploration vir die kieslys, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, warnings: { foregroundUnavailable: - 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', + 'Hierdie speletjie ondersteun nie teken op die voorgrondlaag nie, dus is die seshoeke op die tokenlaag geteken.', someFailed: - 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', + 'Seshoeke wat nie geteken kon word nie: {count}. Kyk in die API-konsole vir besonderhede.', }, errors: { noPage: 'Kon nie die bladsy vind om aan te werk nie.', - notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + notHex: "Hierdie bladsy gebruik nie 'n seshoekrooster nie.", noPolygons: 'Kies een of meer getekende vorms om te vul.', - emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', - tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', - nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', - nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', - noTokens: 'Kies eers een of meer tekens.', - noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + emptyArea: 'Die geselekteerde gebied bevat geen seshoekmiddelpunte nie.', + tooMany: 'Dit sal te veel seshoeke op een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tokens om te versteek.', + nothingToReveal: 'Kies seshoeke, getekende vorms of tokens om te onthul.', + noTokens: 'Kies eers een of meer tokens.', + noHexes: 'Kies eers een of meer seshoeke (of tokens wat op seshoeke staan).', nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', unknownCommand: 'Onbekende opdrag: {command}', unknownSetting: 'Onbekende instelling: {key}', unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', - calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', - calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateFailed: 'Daardie tokens kan nie gebruik word om te kalibreer nie.', unexpected: 'Iets het verkeerd geloop: {message}', }, hints: { @@ -220,60 +220,61 @@ const TRANSLATION = { noPolygons: "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", - tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', - noHexes: 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + tooMany: "Vul 'n kleiner gebied, of verdeel die gebied in verskeie vorms.", + noHexes: + 'Seshoeke is op die voorgrond- of tokenlaag; skakel oor na daardie laag om hulle te kies.', unknownCommand: 'Tik !hexploration help om die opdragte te lys.', unknownSetting: 'Tik !hexploration set om elke instelling te sien.', calibrateNeedsTokens: - "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + "Klik 'n token vas in die middel van 'n seshoek en kies dit. Kies 'n tweede token wat op 'n naburige seshoek in dieselfde ry (Hex V) of kolom (Hex H) vasgeklik is om ook die seshoekgrootte reg te stel.", calibrateFailed: - 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + 'Die twee tokens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, minstens een seshoek uitmekaar.', unexpected: 'Besonderhede is in die API-konsole-logboek.', }, help: { - menu: 'Wys die spyskaart.', - fill: 'Bedek die geselekteerde getekende vorms met hekse.', + menu: 'Wys die kieslys.', + fill: 'Bedek die geselekteerde getekende vorms met seshoeke.', fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', - reveal: 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', - revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', - conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', - explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', - resetPage: 'Verwyder elke heks op die bladsy (vra eers).', - name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', - mark: 'Verander die geselekteerde tekens in versteekte liggings.', + reveal: + 'Onthul die geselekteerde seshoeke, en die seshoeke onder die geselekteerde vorms en tokens.', + revealPage: 'Onthul elke seshoek op die bladsy sonder aankondigings.', + conceal: 'Bedek die gebied onder die geselekteerde vorms en tokens weer met seshoeke.', + explore: 'Onthul rondom die geselekteerde tokens asof hulle pas daarheen beweeg het.', + resetPage: 'Verwyder elke seshoek op die bladsy (vra eers).', + name: 'Benoem die geselekteerde seshoeke, of die seshoeke onder die geselekteerde tokens. Laat die naam leeg om dit uit te vee.', + mark: 'Verander die geselekteerde tokens in versteekte liggings.', unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', set: "Verander 'n instelling, of wys alle instellings.", - pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", - pageClear: 'Verwyder die huidige bladsy se ignorering.', + pageSet: "Oorskryf 'n onthullingsinstelling slegs op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se oorskrywings.', rescan: - "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + "Herbou die bladsy se seshoeklys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", calibrate: - 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + 'Belyn die seshoekrooster met een of twee geselekteerde tokens wat op seshoekmiddelpunte vasgeklik is.', calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', status: 'Wys wat Hexploration van die huidige bladsy weet.', - journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + journal: 'Herbou die Help- en Command Deck-uitdeelstukke.', help: 'Wys hierdie lys.', handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', }, deck: { - subtitle: 'Beveldek', drawDesc: "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", revealDesc: - 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', + 'Kies seshoeke, vorms of tokens om hulle te onthul of weer te bedek. Verken onthul rondom geselekteerde tokens asof hulle beweeg het.', locationsDesc: - "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + "Kies tokens om hulle as liggings onder seshoeke te versteek. Kies seshoeke of tokens om 'n seshoek te benoem.", toolsDesc: - 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', + 'Instellings, bladsy-oorskrywings, status, herskandering van gekopieerde bladsye en kalibrering van die rooster.', footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', }, handout: { versionLabel: 'Weergawe', - subtitle: 'Heks-vir-heks verkenning vir Roll20', + subtitle: 'Seshoek-vir-seshoek-verkenning vir Roll20', footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', overview: { heading: 'Oorsig', - body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + body: "Hexploration bedek 'n seshoekkaart met ondeursigtige seshoeke. Soos die groep beweeg, word die seshoeke waardeur hulle gaan (en, as jy wil, die seshoeke rondom hulle) verwyder, sodat die kaart een seshoek op 'n slag ontbloot word. Versteekte liggings kan onder seshoeke geplaas word en word aangekondig wanneer hulle gevind word. Dit werk in Jumpgate- en Legacy-speletjies, op Hex (V)- en Hex (H)-roosters van enige grootte.", demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", }, quickStart: { @@ -281,9 +282,9 @@ const TRANSLATION = { steps: [ "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', - 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', - 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', - "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + 'Kies die vorms en klik op Vul in die Command Deck (of tik !hexploration fill). Die vorms word deur seshoeke vervang.', + 'Opsioneel: kies voor die vulling tokens vir belangrike plekke en klik Merk ligging. Hulle word onder die seshoeke versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n speler-token. Elke seshoek waardeur dit beweeg, en die seshoeke binne sy Sigafstand, word onthul.", ], }, commands: { @@ -296,29 +297,29 @@ const TRANSLATION = { revealing: { heading: 'Hoe onthulling werk', points: [ - 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', - "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", - "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", - "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", - "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke. Met Siglyn aan, word 'n seshoek slegs onthul as geen bedekte seshoek tussenin lê nie.", + "Seshoek-onthullingsafstand word op seshoeke gestoor wanneer hulle geteken word. Daardie seshoeke word slegs van binne soveel seshoeke onthul, hoe ver 'n token ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle lê.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan.", + "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { - heading: 'Genoemde hekse en liggings', + heading: 'Benoemde seshoeke en liggings', points: [ - "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", - 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', - 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', - "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", + 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, settings: { heading: 'Instellings', intro: - 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Seshoeklaag, Tokens wat onthul en Taal kan ook op die Mod se instellingsbladsy gestel word.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beskrywing', @@ -327,19 +328,19 @@ const TRANSLATION = { jumpgate: { heading: 'Jumpgate en Legacy', points: [ - 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', - 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', - "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", - "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + 'Hexploration bepaal watter enjin die speletjie gebruik en teken die ooreenstemmende soort vorm. Vorms wat in enige van die twee redigeerders geteken is, kan gevul word.', + 'Met Seshoeklaag op Outo gestel, word seshoeke op die voorgrondlaag bo tokens geteken, sodat spelers nie kan sien wat daaronder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tokenlaag eerder gebruik.', + "Jumpgate teken wiskundig reëlmatige seshoeke, wat 'n effens ander vorm as Legacy-seshoeke het. As die seshoeke nie met 'n bladsy se rooster belyn nie, klik 'n token vas op 'n seshoekmiddelpunt, kies dit en klik Kalibreer. Kies twee tokens in naburige seshoeke van dieselfde ry (Hex V) of kolom (Hex H) om ook die seshoekgrootte reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy seshoeke nuwe ID's. Gebruik Skandeer weer op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", ], }, upgrading: { heading: 'Opgradering vanaf weergawe 1', points: [ "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", - 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Bestaande seshoekkaarte, name, liggingtokens en instellings word met die eerste begin outomaties opgegradeer.', 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', - "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + "Weergawe 1 het enige token wat 'n karakter verteenwoordig, seshoeke laat onthul. Stel Tokens wat onthul op Karaktertokens om daardie gedrag te behou.", ], colV1: 'Weergawe 1 opdrag', colV2: 'Weergawe 2 opdrag', @@ -347,10 +348,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Probleemoplossing', points: [ - "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", - "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", - "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", - 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + "Niks gebeur wanneer 'n token beweeg nie: maak seker dat die token op die tokenlaag is en by Tokens wat onthul pas, en dat die bladsy seshoeke het (!hexploration status).", + "Seshoeke is van die rooster af verskuif: gebruik Kalibreer en kyk dan met 'n token op 'n paar seshoeke oor die kaart heen.", + "Seshoeke word nie meer onthul nadat 'n bladsy of speletjie gekopieer is nie: gebruik Skandeer weer op die bladsy.", + 'Vul sê die gebied het geen seshoekmiddelpunte nie: die vorm moet die middelpunt van ten minste een seshoek bevat.', 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', ], }, @@ -358,7 +359,7 @@ const TRANSLATION = { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index 104617b2fe..bb2ae00ceb 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -1,60 +1,60 @@ const TRANSLATION = { titles: { - ready: "L'exploració està a punt.", - settings: "Configuració d'exploració", + ready: 'Hexploration està a punt.', + settings: "Configuració d'Hexploration", languages: 'Trieu un idioma', pageSettings: 'Configuració de la pàgina: {page}', - status: "Estat de l'exploració: {page}", - help: "Comandes d'exploració", + status: "Estat d'Hexploration: {page}", + help: "Comandes d'Hexploration", confirm: 'Si us plau, confirmeu', }, discovery: { - title: 'Localització descoberta', + title: 'Ubicació descoberta', }, menu: { draw: 'Dibuixa', reveal: 'Revela i amaga', locations: 'Ubicacions', tools: 'Eines', - layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + layerInUse: "S'estan dibuixant hexàgons nous a la {layer}.", pageSettingsHelp: "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", }, buttons: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - undo: 'Desfer el farciment', - reveal: 'Revelar', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + undo: "Desfés l'emplenament", + reveal: 'Revela', + conceal: 'Amaga', explore: 'Explora', revealPage: 'Revela la pàgina', resetPage: 'Restableix la pàgina', mark: 'Marca la ubicació', unmark: 'Desmarca', - name: 'Nom Hex', + name: "Anomena l'hexàgon", settings: 'Configuració', pageSettings: 'Configuració de la pàgina', status: 'Estat', rescan: 'Torna a escanejar', - calibrate: 'Calibrar', + calibrate: 'Calibra', calibrateReset: 'Restableix la calibració', help: 'Ajuda', - change: 'Canviar', + change: 'Canvia', menu: 'Menú', clearOverrides: 'Esborra les substitucions', - confirmReset: 'Sí, traieu tots els hexagones', + confirmReset: 'Sí, elimina tots els hexàgons', }, prompts: { name: 'Nom de la ubicació (deixeu en blanc per esborrar)', }, values: { - on: 'Encès', - off: 'Apagat', + on: 'Activat', + off: 'Desactivat', none: 'Cap', hexLayer: { - auto: 'Automàtic (en primer pla si està disponible)', + auto: 'Automàtic (primer pla si està disponible)', foreground: 'capa de primer pla', - objects: 'capa de testimoni', + objects: 'capa de fitxes', }, revealBy: { players: 'Fitxes de jugador', @@ -62,22 +62,22 @@ const TRANSLATION = { all: 'Totes les fitxes', }, revealMode: { - clear: 'Clar', - glimpse: "Un cop d'ull", + clear: 'Neteja', + glimpse: "Cop d'ull", }, announce: { all: 'Tothom', - gm: 'Només GM', - off: 'Apagat', + gm: 'Només el GM', + off: 'Desactivat', }, orientation: { - vertical: 'Hexadecimal (V)', + vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + conceal: 'Amaga', }, }, settings: { @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Idioma per a menús, missatges i fullets.', }, hexLayer: { - label: 'Capa hexagonal', - desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + label: 'Capa dels hexàgons', + desc: "On es dibuixen els hexàgons nous. Automàtic prova la capa de primer pla (per sobre de les fitxes) i recorre a la capa de fitxes si el joc no l'admet.", }, fillColor: { label: 'Color de farciment', - desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', + desc: 'Color dels hexàgons nous. Utilitzeu rgba() per a hexàgons transparents, per exemple rgba(0,0,0,0.8).', }, strokeColor: { label: 'Color de la vora', @@ -99,18 +99,18 @@ const TRANSLATION = { }, labelColor: { label: "Color de l'etiqueta", - desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', + desc: 'Color de les etiquetes de nom, visibles només per al GM, dels hexàgons amb nom.', }, glimpseColor: { - label: "Color d'ull", - desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', + label: "Color de cop d'ull", + desc: "Color que prenen els hexàgons quan es veuen de cop d'ull (mode de revelació Cop d'ull). Utilitzeu un color rgba() transparent.", }, strokeWidth: { label: 'Amplada de la vora', - desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', + desc: 'Amplada del contorn dels hexàgons nous, en píxels (de 0 a 20).', }, maxDistance: { - label: 'Distància de revelació hexagonal', + label: 'Distància de revelació dels hexàgons', desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", }, revealDistance: { @@ -131,14 +131,14 @@ const TRANSLATION = { }, revealMode: { label: 'Mode de revelació', - desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + desc: "Neteja elimina els hexàgons a la vista. Cop d'ull, en canvi, els fa transparents; s'eliminen quan hi entra una fitxa.", }, announce: { label: 'Anunciar descobriments', desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', }, pingDiscoveries: { - label: 'Ping Descobriments', + label: 'Fer ping als descobriments', desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', }, hideCoveredTokens: { @@ -149,30 +149,30 @@ const TRANSLATION = { status: { engine: 'Motor de joc', grid: 'Quadrícula', - layer: 'Capa hexagonal', - hexes: 'Hexes', - named: 'Hexagones anomenats', + layer: 'Capa dels hexàgons', + hexes: 'Hexàgons', + named: 'Hexàgons amb nom', icons: "Fitxes d'ubicació", - glimpsed: 'Hexagones albirats', - pending: "Ubicacions a l'espera d'omplir-se", + glimpsed: 'Hexàgons albirats', + pending: "Ubicacions pendents d'emplenament", calibrated: 'Calibrat', - overrides: 'Anul·lació de la pàgina', - undo: 'Desfer disponible', + overrides: 'Substitucions de la pàgina', + undo: 'Es pot desfer', }, messages: { filled: - 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', revealed: 'Hexagones revelats: {count}.', - revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", + revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: - 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', + 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', + resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', - named: 'Hexadecimals anomenats "{name}": {count}.', + named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: - 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + 'Ubicacions amagades en hexàgons existents: {attached}. Pendents del següent farciment que les cobreixi: {pending}.', unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: @@ -183,11 +183,11 @@ const TRANSLATION = { "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: - "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", pruned: - "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexàgons desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Torna a escanejar a la pàgina per recuperar-ne els hexàgons.", readyHint: - 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + 'Escriviu !hexploration per obrir el menú o obriu el fullet "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -197,7 +197,7 @@ const TRANSLATION = { }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", - notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", tooMany: "Això crearia massa hexagones d'una vegada ({count}).", @@ -224,13 +224,13 @@ const TRANSLATION = { 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", noHexes: - 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + 'Els hexàgons són a la capa de primer pla o a la de fitxes; canvieu a aquesta capa per seleccionar-los.', unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', calibrateNeedsTokens: - "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Col·loqueu una fitxa al centre d'un hexàgon i seleccioneu-la. Seleccioneu una segona fitxa ajustada a un hexàgon veí de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", calibrateFailed: - "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + "Les dues fitxes han d'estar a la mateixa fila (Hex V) o a la mateixa columna (Hex H), separades almenys per un hexàgon.", unexpected: "Els detalls es troben al registre de la consola de l'API.", }, help: { @@ -240,10 +240,10 @@ const TRANSLATION = { undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", reveal: 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', - revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", - resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', @@ -251,30 +251,29 @@ const TRANSLATION = { pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: - 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', + "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', - journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", help: 'Mostra aquesta llista.', handout: 'Les instruccions completes es troben al fullet "{name}".', }, deck: { - subtitle: 'Comandament de la plataforma', drawDesc: - "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfés l'emplenament reverteix l'últim emplenament.", revealDesc: - "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + "Selecciona hexàgons, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revela el voltant de les fitxes seleccionades com si s'haguessin mogut.", locationsDesc: - 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', + 'Seleccioneu fitxes per amagar-les com a ubicacions sota els hexàgons. Seleccioneu hexàgons o fitxes per posar nom a un hexàgon.', toolsDesc: 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', }, handout: { versionLabel: 'Versió', - subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', + subtitle: 'Exploració hexàgon a hexàgon per a Roll20', footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', @@ -286,7 +285,7 @@ const TRANSLATION = { steps: [ 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", - "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + 'Seleccioneu les formes i feu clic a Omple al Command Deck (o escriviu !hexploration fill). Les formes se substitueixen per hexàgons.', "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', ], @@ -301,12 +300,12 @@ const TRANSLATION = { revealing: { heading: 'Com funciona la revelació', points: [ - 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', - "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", - "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", - "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", - "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", + "La distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons. Amb Línia de visió activada, un hexàgon només es revela si no hi ha cap hexàgon cobert entremig.", + "La distància de revelació dels hexàgons s'emmagatzema als hexàgons quan es dibuixen. Aquests hexàgons només es revelen des d'un màxim d'aquest nombre d'hexàgons, per lluny que pugui veure una fitxa. Utilitzeu-la per a muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, @@ -316,14 +315,14 @@ const TRANSLATION = { "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", - "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", - "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], }, settings: { heading: 'Configuració', intro: - "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', colKey: 'clau', colName: 'Configuració', colDesc: 'Descripció', @@ -333,18 +332,18 @@ const TRANSLATION = { heading: 'Jumpgate i Legacy', points: [ 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', - "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", - "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", - "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + "Amb Capa dels hexàgons establerta a Automàtic, els hexàgons es dibuixen a la capa de primer pla, per sobre de les fitxes, perquè els jugadors no puguin veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de fitxes.", + "Jumpgate dibuixa hexàgons matemàticament regulars, que tenen una forma lleugerament diferent dels hexàgons de Legacy. Si els hexàgons no s'alineen amb la graella d'una pàgina, ajusteu una fitxa al centre d'un hexàgon, seleccioneu-la i feu clic a Calibra. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + "Quan es copia una pàgina o un joc, els seus hexàgons reben identificadors nous. Executeu Torna a escanejar a la pàgina per tornar-los a recuperar, juntament amb les etiquetes de nom i les fitxes d'ubicació.", ], }, upgrading: { heading: 'Actualització de la versió 1', points: [ 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', - "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + "Els mapes d'hexàgons, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament la primera vegada que s'inicia.", 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', - 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], colV1: 'Comandament de la versió 1', colV2: 'Comandament de la versió 2', @@ -352,10 +351,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Resolució de problemes', points: [ - 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', - 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', - 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', - "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + 'No passa res quan es mou una fitxa: comproveu que la fitxa és a la capa de fitxes i que coincideix amb Fitxes que revelen, i que la pàgina té hexàgons (!hexploration status).', + 'Els hexàgons estan desplaçats respecte de la quadrícula: utilitzeu Calibra i, a continuació, comproveu-ho amb una fitxa en uns quants hexàgons del mapa.', + 'Els hexàgons han deixat de revelar-se després de copiar una pàgina o un joc: executeu Torna a escanejar a la pàgina.', + "Omple diu que l'àrea no té centres d'hexàgon: la forma ha de contenir el centre d'almenys un hexàgon.", "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", ], }, @@ -363,7 +362,7 @@ const TRANSLATION = { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", colLanguage: 'Llengua', - colNative: 'Nom nadiu', + colNative: 'Nom original', colCode: 'Codi', }, credits: { diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index 9c8ff3c65d..5f2fcdfd51 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -1,83 +1,83 @@ const TRANSLATION = { titles: { - ready: 'Heexploration je připraven.', - settings: 'Nastavení Heexploration', + ready: 'Hexploration je připraven.', + settings: 'Nastavení Hexploration', languages: 'Vyberte jazyk', pageSettings: 'Nastavení stránky: {page}', - status: 'Stav průzkumu: {page}', - help: 'Příkazy pro průzkum', - confirm: 'Prosím potvrďte', + status: 'Stav Hexploration: {page}', + help: 'Příkazy Hexploration', + confirm: 'Potvrďte prosím', }, discovery: { title: 'Místo objeveno', }, menu: { - draw: 'Remíza', - reveal: 'Odhalit a skrýt', + draw: 'Kreslení', + reveal: 'Odhalení a skrytí', locations: 'Místa', tools: 'Nástroje', - layerInUse: 'Na {layer} se kreslí nové hexy.', + layerInUse: 'Vrstva, do které se kreslí nové hexy: {layer}.', pageSettingsHelp: 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', }, buttons: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - undo: 'Vrátit zpět výplň', + undo: 'Vrátit výplň', reveal: 'Odhalit', - conceal: 'Skrývat', + conceal: 'Zakrýt', explore: 'Prozkoumat', revealPage: 'Odhalit stránku', - resetPage: 'Obnovit stránku', - mark: 'Označte umístění', + resetPage: 'Resetovat stránku', + mark: 'Označit místo', unmark: 'Zrušit označení', - name: 'Jméno Hex', + name: 'Pojmenovat hex', settings: 'Nastavení', pageSettings: 'Nastavení stránky', - status: 'Postavení', - rescan: 'Znovu naskenujte', + status: 'Stav', + rescan: 'Znovu skenovat', calibrate: 'Kalibrovat', calibrateReset: 'Resetovat kalibraci', help: 'Pomoc', - change: 'Přeměna', + change: 'Změnit', menu: 'Menu', - clearOverrides: 'Vymazat přepisy', - confirmReset: 'Ano, Odebrat všechny hexy', + clearOverrides: 'Zrušit přepsání', + confirmReset: 'Ano, odebrat všechny hexy', }, prompts: { name: 'Název místa (pro vymazání ponechte prázdné)', }, values: { - on: 'Na', + on: 'Zapnuto', off: 'Vypnuto', - none: 'Žádný', + none: 'Žádné', hexLayer: { auto: 'Auto (popředí, pokud je k dispozici)', foreground: 'vrstva popředí', - objects: 'vrstva tokenů', + objects: 'vrstva žetonů', }, revealBy: { - players: 'Hráčské žetony', + players: 'Žetony hráčů', characters: 'Žetony postav', - all: 'Všechny tokeny', + all: 'Všechny žetony', }, revealMode: { - clear: 'Jasný', + clear: 'Odstranění', glimpse: 'Záblesk', }, announce: { - all: 'Každý', + all: 'Všichni', gm: 'Pouze GM', off: 'Vypnuto', }, orientation: { - vertical: 'Hexadecimální (V)', - horizontal: 'Hexadecimální (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - conceal: 'Skrývat', + conceal: 'Zakrýt', }, }, settings: { @@ -86,7 +86,7 @@ const TRANSLATION = { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Hexadecimální vrstva', + label: 'Vrstva šestiúhelníků', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { @@ -98,66 +98,66 @@ const TRANSLATION = { desc: 'Barva obrysu nových hexů.', }, labelColor: { - label: 'Barva štítku', + label: 'Barva popisku', desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', }, glimpseColor: { label: 'Barva záblesku', - desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', + desc: 'Barva, kterou hexy získají při zahlédnutí (režim odhalování Záblesk). Použijte průhlednou barvu rgba().', }, strokeWidth: { - label: 'Šířka okraje', + label: 'Šířka ohraničení', desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Hexadecimální vzdálenost odhalení', + label: 'Vzdálenost odhalení šestiúhelníků', desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', }, revealDistance: { - label: 'Pohledová vzdálenost', + label: 'Vzdálenost dohledu', desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', }, lineOfSight: { - label: 'Zornost', + label: 'Přímá viditelnost', desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', }, revealPath: { - label: 'Odhalení Po cestě', + label: 'Odhalovat po cestě', desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', }, revealBy: { - label: 'Tokeny, které odhalují', + label: 'Žetony, které odhalují', desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', }, revealMode: { - label: 'Režim odhalení', - desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', + label: 'Režim odhalování', + desc: 'Odstranění odstraní hexy v dohledu. Záblesk je místo toho zprůhlední; odstraní se, když do nich vstoupí žeton.', }, announce: { - label: 'Oznamte objevy', + label: 'Oznamovat objevy', desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', }, pingDiscoveries: { - label: 'Ping Discovery', + label: 'Pingnout objevy', desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', }, hideCoveredTokens: { - label: 'Skryjte kryté žetony', + label: 'Skrýt zakryté žetony', desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', }, }, status: { engine: 'Herní engine', grid: 'Mřížka', - layer: 'Hexadecimální vrstva', + layer: 'Vrstva hexů', hexes: 'Hexy', named: 'Pojmenované hexy', - icons: 'Tokeny polohy', + icons: 'Žetony míst', glimpsed: 'Zahlédnuté hexy', - pending: 'Místa čekající na zaplnění', + pending: 'Místa čekající na výplň', calibrated: 'Zkalibrováno', - overrides: 'Přepíše stránku', - undo: 'Zpět k dispozici', + overrides: 'Přepsání stránky', + undo: 'Lze vrátit zpět', }, messages: { filled: @@ -168,7 +168,7 @@ const TRANSLATION = { 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', named: 'Hexusy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: @@ -183,11 +183,11 @@ const TRANSLATION = { 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: - 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', + 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', pruned: - 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + 'Uložené hexy, které již neexistují a byly zapomenuty: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte na stránce Znovu skenovat, aby se její hexy znovu načetly.', readyHint: - 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', + 'Zadejte !hexploration pro otevření nabídky nebo otevřete leták "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -197,7 +197,7 @@ const TRANSLATION = { }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', - notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', @@ -250,17 +250,16 @@ const TRANSLATION = { calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', - status: 'Ukažte, co Heexploration ví o aktuální stránce.', - journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + status: 'Zobrazit, co Hexploration ví o aktuální stránce.', + journal: 'Znovu vytvořte letáky „Pomoc“ a „Command Deck“.', help: 'Zobrazit tento seznam.', handout: 'Úplné pokyny jsou v letáku „{name}“.', }, deck: { - subtitle: 'Velitelský balíček', drawDesc: 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', revealDesc: - 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', + 'Vyberte hexy, tvary nebo žetony, abyste je odhalili nebo znovu zakryli. Prozkoumat odhalí okolí vybraných žetonů, jako by se pohnuly.', locationsDesc: 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', toolsDesc: @@ -281,9 +280,9 @@ const TRANSLATION = { steps: [ 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', - 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Vyberte tvary a v Command Deck klikněte na Vyplnit (nebo zadejte !hexploration fill). Tvary se nahradí hexy.', 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', - 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Vzdálenosti dohledu jsou odhaleny.', ], }, commands: { @@ -296,13 +295,13 @@ const TRANSLATION = { revealing: { heading: 'Jak funguje odhalování', points: [ - 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', - 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', - 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', - 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', - 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů. Se zapnutou Přímou viditelností je hex odhalen pouze tehdy, když mezi ním a žetonem neleží žádný zakrytý hex.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do hexů při jejich kreslení. Tyto hexy lze odhalit jen ze vzdálenosti nejvýše tolika hexů, ať žeton vidí jakkoli daleko. Použijte ji pro hory nebo lesy, které zakrývají, co je za nimi.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton.', + 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', + 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', ], }, locations: { @@ -311,14 +310,14 @@ const TRANSLATION = { 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', - 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -328,18 +327,18 @@ const TRANSLATION = { heading: 'Jumpgate a Legacy', points: [ 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', - 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', + 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], }, upgrading: { heading: 'Upgrade z verze 1', points: [ 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', - 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', - 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', - 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', + 'Stávající hexové mapy, názvy, tokeny lokací a nastavení se při prvním spuštění automaticky aktualizují.', + 'Příkazy verze 1, včetně makra Hexploration_menu, stále fungují.', + 'Verze 1 umožňovala odhalovat hexy každému žetonu, který představoval postavu. Chcete-li toto chování zachovat, nastavte Žetony, které odhalují, na Žetony postav.', ], colV1: 'Příkaz verze 1', colV2: 'Příkaz verze 2', @@ -347,18 +346,18 @@ const TRANSLATION = { troubleshooting: { heading: 'Odstraňování problémů', points: [ - 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá nastavení Žetony, které odhalují, a zda stránka obsahuje hexy (!hexploration status).', 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', - 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', - 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte na stránce Znovu skenovat.', + 'Vyplnit hlásí, že oblast neobsahuje žádné středy hexů: tvar musí obsahovat střed alespoň jednoho hexu.', 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', ], }, languages: { heading: 'Jazyky', - body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + body: 'Jazyk vyberte příkazem !hexploration set language. Dostupné jazyky:', colLanguage: 'Jazyk', - colNative: 'Rodné jméno', + colNative: 'Vlastní název', colCode: 'Kód', }, credits: { diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index 08f8791091..860684d2c5 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -4,34 +4,34 @@ const TRANSLATION = { settings: 'Indstillinger for Hexploration', languages: 'Vælg et sprog', pageSettings: 'Sideindstillinger: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandoer', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandoer', confirm: 'Bekræft venligst', }, discovery: { title: 'Sted opdaget', }, menu: { - draw: 'Tegne', - reveal: 'Afsløre og skjul', + draw: 'Tegn', + reveal: 'Afslør og skjul', locations: 'Steder', tools: 'Værktøjer', - layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', + layerInUse: 'Nye hexfelter tegnes på {layer}.', pageSettingsHelp: 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', }, buttons: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - undo: 'Fortryd Fyld', - reveal: 'Afsløre', - conceal: 'Skjule', - explore: 'Udforske', - revealPage: 'Afsløre side', + undo: 'Fortryd fyld', + reveal: 'Afslør', + conceal: 'Skjul', + explore: 'Udforsk', + revealPage: 'Afslør side', resetPage: 'Nulstil side', - mark: 'Marker placering', + mark: 'Marker sted', unmark: 'Fjern markering', - name: 'Navn Hex', + name: 'Navngiv hexfelt', settings: 'Indstillinger', pageSettings: 'Sideindstillinger', status: 'Status', @@ -39,45 +39,45 @@ const TRANSLATION = { calibrate: 'Kalibrer', calibrateReset: 'Nulstil kalibrering', help: 'Hjælp', - change: 'Forandring', + change: 'Skift', menu: 'Menu', clearOverrides: 'Ryd tilsidesættelser', - confirmReset: 'Ja, Fjern alle Hexes', + confirmReset: 'Ja, fjern alle hexfelter', }, prompts: { - name: 'Placeringsnavn (lad tom for at rydde)', + name: 'Stednavn (lad feltet være tomt for at rydde)', }, values: { - on: 'På', - off: 'Slukket', + on: 'Til', + off: 'Fra', none: 'Ingen', hexLayer: { auto: 'Auto (forgrund, hvis tilgængelig)', foreground: 'forgrundslaget', - objects: 'symbollag', + objects: 'tokenlaget', }, revealBy: { - players: 'Spillerpoletter', - characters: 'Karakter tokens', + players: 'Spillertokens', + characters: 'Karaktertokens', all: 'Alle tokens', }, revealMode: { - clear: 'Klar', + clear: 'Fjern', glimpse: 'Glimt', }, announce: { - all: 'Alle sammen', + all: 'Alle', gm: 'Kun GM', - off: 'Slukket', + off: 'Fra', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - conceal: 'Skjule', + conceal: 'Skjul', }, }, settings: { @@ -86,11 +86,11 @@ const TRANSLATION = { desc: 'Sprog til menuer, beskeder og uddelingskopier.', }, hexLayer: { - label: 'Hex lag', - desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + label: 'Lag for hexfelter', + desc: 'Hvor nye hexfelter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', }, fillColor: { - label: 'Fyld farve', + label: 'Fyldfarve', desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { @@ -98,19 +98,19 @@ const TRANSLATION = { desc: 'Farve på omridset af nye sekskanter.', }, labelColor: { - label: 'Etiket farve', + label: 'Etiketfarve', desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', }, glimpseColor: { - label: 'Glimt farve', - desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', + label: 'Glimtfarve', + desc: 'Den farve, hexfelter skifter til, når de skimtes (afsløringstilstanden Glimt). Brug en gennemsigtig rgba()-farve.', }, strokeWidth: { - label: 'Border Bredde', + label: 'Kantbredde', desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: 'Hex afsløre afstand', + label: 'Afsløringsafstand for hexfelter', desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { @@ -118,20 +118,20 @@ const TRANSLATION = { desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', }, lineOfSight: { - label: 'Synslinie', + label: 'Synslinje', desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', }, revealPath: { - label: 'Afsløre langs stien', + label: 'Afslør langs ruten', desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', }, revealBy: { - label: 'Tokens, der afslører', + label: 'Afslørende tokens', desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { label: 'Afsløringstilstand', - desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', + desc: 'Fjern fjerner hexfelter inden for synsvidde. Glimt gør dem i stedet gennemsigtige; de fjernes, når et token går ind i dem.', }, announce: { label: 'Annoncer opdagelser', @@ -147,16 +147,16 @@ const TRANSLATION = { }, }, status: { - engine: 'Spil motor', + engine: 'Spilmotor', grid: 'Gitter', - layer: 'Hex lag', - hexes: 'Hekser', - named: 'Navngivne hexes', - icons: 'Placeringstokens', - glimpsed: 'Glimpede sekskanter', - pending: 'Steder, der venter på udfyldning', + layer: 'Lag for hexfelter', + hexes: 'Hexfelter', + named: 'Navngivne hexfelter', + icons: 'Stedtokens', + glimpsed: 'Gennemsigtige hexfelter', + pending: 'Steder, der venter på fyld', calibrated: 'Kalibreret', - overrides: 'Side tilsidesætter', + overrides: 'Sidetilsidesættelser', undo: 'Fortryd tilgængelig', }, messages: { @@ -182,11 +182,11 @@ const TRANSLATION = { 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: - 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', + 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', pruned: - 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + 'Gemte hexfelter, der ikke længere findes og er blevet glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Scan igen på siden for at finde dens hexfelter igen.', readyHint: - 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + 'Skriv !hexploration for at åbne menuen, eller åbn uddelingsarket "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -249,16 +249,15 @@ const TRANSLATION = { 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', - journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + journal: 'Genopbyg uddelingsarkene Help og Command Deck.', help: 'Vis denne liste.', handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', }, deck: { - subtitle: 'Kommandodæk', drawDesc: - 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', + 'Tegn figurer rundt om et område, vælg dem, og fyld derefter. Fortryd fyld annullerer den sidste fyldning.', revealDesc: - 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', + 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', toolsDesc: @@ -279,9 +278,9 @@ const TRANSLATION = { steps: [ 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', - 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', - 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', - 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', + 'Vælg figurerne, og klik på Fyld i Command Deck (eller skriv !hexploration fill). Figurerne erstattes af hexfelter.', + 'Valgfrit: Før du fylder, kan du vælge tokens for vigtige steder og klikke på Marker sted. De skjules under hexfelterne og annonceres, når de opdages.', + 'Flyt et spillertoken. Hvert hexfelt, det passerer igennem, og hexfelterne inden for dets Synsafstand afsløres.', ], }, commands: { @@ -294,29 +293,29 @@ const TRANSLATION = { revealing: { heading: 'Sådan fungerer afsløring', points: [ - 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', - 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', - 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', - 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', - 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter. Med Synslinje slået til afsløres et hexfelt kun, hvis der ikke ligger noget dækket hexfelt imellem.', + 'Afsløringsafstand for hexfelter gemmes på hexfelterne, når de tegnes. Disse hexfelter afsløres kun inden for så mange hexfelters afstand, uanset hvor langt et token kan se. Brug det til bjerge eller skove, der skjuler, hvad der ligger bag dem.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem.', + 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', + 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', ], }, locations: { heading: 'Navngivne Hekser og Steder', points: [ - 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', - 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', - 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], }, settings: { heading: 'Indstillinger', intro: - "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + 'Skift indstillinger med !hexploration set (eller knappen Indstillinger). Lag for hexfelter, Afslørende tokens og Sprog kan også indstilles på modens indstillingsside.', colKey: 'Nøgle', colName: 'Indstilling', colDesc: 'Beskrivelse', @@ -326,9 +325,9 @@ const TRANSLATION = { heading: 'Jumpgate og Legacy', points: [ 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', - 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', - 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', - "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + 'Når Lag for hexfelter er sat til Auto, tegnes hexfelter på forgrundslaget over tokens, så spillerne ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexfelter, som har en lidt anden form end Legacy-hexfelter. Hvis hexfelterne ikke flugter med en sides gitter, så fastgør et token til midten af et hexfelt, vælg det, og klik på Kalibrer. Vælg to tokens i nabohexfelter i samme række (Hex V) eller kolonne (Hex H) for også at rette hexfeltstørrelsen.', + 'Når en side eller et spil kopieres, får hexfelterne nye id’er. Kør Scan igen på siden for at finde dem igen sammen med deres navneetiketter og stedtokens.', ], }, upgrading: { @@ -337,7 +336,7 @@ const TRANSLATION = { 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', - 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', + 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], colV1: 'Version 1 kommando', colV2: 'Version 2 kommando', @@ -345,10 +344,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Fejlfinding', points: [ - 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', - 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', - 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', - 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'Der sker ikke noget, når et token flytter sig: Kontroller, at tokenet ligger på tokenlaget og matcher Afslørende tokens, og at siden har hexfelter (!hexploration status).', + 'Hexfelterne er forskudt i forhold til gitteret: Brug Kalibrer, og kontroller derefter med et token på nogle få hexfelter rundt om på kortet.', + 'Hexfelterne holdt op med at blive afsløret efter kopiering af en side eller et spil: Kør Scan igen på siden.', + 'Fyld siger, at området ikke har nogen hexfeltcentre: Figuren skal indeholde midten af mindst ét hexfelt.', 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', ], }, @@ -356,7 +355,7 @@ const TRANSLATION = { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', colLanguage: 'Sprog', - colNative: 'Indfødt navn', + colNative: 'Eget navn', colCode: 'Kode', }, credits: { diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index 4a57d25a31..90d7ba905d 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -1,48 +1,48 @@ const TRANSLATION = { titles: { - ready: 'Hexploration ist fertig.', - settings: 'Erkundungseinstellungen', - languages: 'Wählen Sie eine Sprache', + ready: 'Hexploration ist bereit.', + settings: 'Hexploration-Einstellungen', + languages: 'Sprache wählen', pageSettings: 'Seiteneinstellungen: {page}', - status: 'Erkundungsstatus: {page}', - help: 'Erkundungsbefehle', + status: 'Hexploration-Status: {page}', + help: 'Hexploration-Befehle', confirm: 'Bitte bestätigen', }, discovery: { title: 'Standort entdeckt', }, menu: { - draw: 'Ziehen', - reveal: 'Enthüllen und Verstecken', + draw: 'Zeichnen', + reveal: 'Aufdecken und Verdecken', locations: 'Standorte', tools: 'Werkzeuge', - layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + layerInUse: 'Neue Hexfelder werden auf der {layer} gezeichnet.', pageSettingsHelp: 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', }, buttons: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', undo: 'Füllung rückgängig machen', reveal: 'Aufdecken', conceal: 'Verbergen', explore: 'Erkunden', - revealPage: 'Seite enthüllen', + revealPage: 'Seite aufdecken', resetPage: 'Seite zurücksetzen', mark: 'Standort markieren', unmark: 'Markierung aufheben', - name: 'Name Hex', + name: 'Hexfeld benennen', settings: 'Einstellungen', pageSettings: 'Seiteneinstellungen', status: 'Status', rescan: 'Erneut scannen', calibrate: 'Kalibrieren', calibrateReset: 'Kalibrierung zurücksetzen', - help: 'Helfen', + help: 'Hilfe', change: 'Ändern', - menu: 'Speisekarte', + menu: 'Menü', clearOverrides: 'Überschreibungen löschen', - confirmReset: 'Ja, alle Verhexungen entfernen', + confirmReset: 'Ja, alle Hexfelder entfernen', }, prompts: { name: 'Standortname (zum Löschen leer lassen)', @@ -50,11 +50,11 @@ const TRANSLATION = { values: { on: 'An', off: 'Aus', - none: 'Keiner', + none: 'Keine', hexLayer: { auto: 'Auto (Vordergrund, falls verfügbar)', foreground: 'Vordergrundebene', - objects: 'Token-Schicht', + objects: 'Token-Ebene', }, revealBy: { players: 'Spielertoken', @@ -62,8 +62,8 @@ const TRANSLATION = { all: 'Alle Token', }, revealMode: { - clear: 'Klar', - glimpse: 'Blick', + clear: 'Entfernen', + glimpse: 'Durchsicht', }, announce: { all: 'Alle', @@ -72,11 +72,11 @@ const TRANSLATION = { }, orientation: { vertical: 'Hex (V)', - horizontal: 'Sechskant (H)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', conceal: 'Verbergen', }, }, @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'Sprache für Menüs, Nachrichten und Handouts.', }, hexLayer: { - label: 'Hex-Ebene', - desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + label: 'Hexfeld-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. „Auto“ versucht es mit der Vordergrundebene (über den Token) und weicht auf die Token-Ebene aus, wenn das Spiel sie nicht unterstützt.', }, fillColor: { label: 'Füllfarbe', @@ -98,19 +98,19 @@ const TRANSLATION = { desc: 'Farbe der Umrisse neuer Hexfelder.', }, labelColor: { - label: 'Etikettenfarbe', + label: 'Beschriftungsfarbe', desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', }, glimpseColor: { - label: 'Einblick in die Farbe', - desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + label: 'Durchsicht-Farbe', + desc: 'Farbe, die Hexfelder annehmen, wenn sie durchsichtig werden (Aufdeckmodus „Durchsicht“). Verwenden Sie eine durchsichtige rgba()-Farbe.', }, strokeWidth: { label: 'Randbreite', desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', }, maxDistance: { - label: 'Hex-Enthüllungsabstand', + label: 'Aufdeckungsdistanz für Hexfelder', desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', }, revealDistance: { @@ -122,23 +122,23 @@ const TRANSLATION = { desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', }, revealPath: { - label: 'Auf dem Weg enthüllen', + label: 'Entlang des Wegs aufdecken', desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', }, revealBy: { - label: 'Zeichen, die offenbaren', + label: 'Aufdeckende Token', desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', }, revealMode: { - label: 'Reveal-Modus', - desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + label: 'Aufdeckmodus', + desc: '„Entfernen“ entfernt Hexfelder in Sichtweite. „Durchsicht“ macht sie stattdessen durchsichtig; sie werden entfernt, sobald ein Token sie betritt.', }, announce: { - label: 'Kündigen Sie Entdeckungen an', + label: 'Entdeckungen ankündigen', desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', }, pingDiscoveries: { - label: 'Ping-Entdeckungen', + label: 'Entdeckungen anpingen', desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', }, hideCoveredTokens: { @@ -148,16 +148,16 @@ const TRANSLATION = { }, status: { engine: 'Spiel-Engine', - grid: 'Netz', - layer: 'Hex-Schicht', - hexes: 'Verhexungen', - named: 'Benannte Verhexungen', - icons: 'Standorttoken', - glimpsed: 'Gesehene Verhexungen', - pending: 'Orte, die auf eine Besetzung warten', + grid: 'Raster', + layer: 'Hexfeld-Ebene', + hexes: 'Hexfelder', + named: 'Benannte Hexfelder', + icons: 'Standort-Token', + glimpsed: 'Durchsichtige Hexfelder', + pending: 'Standorte, die auf eine Füllung warten', calibrated: 'Kalibriert', overrides: 'Seitenüberschreibungen', - undo: 'Rückgängig machen verfügbar', + undo: 'Rückgängig möglich', }, messages: { filled: @@ -183,11 +183,11 @@ const TRANSLATION = { 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: - 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', pruned: - 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + 'Gespeicherte Hexfelder, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie auf der Seite „Erneut scannen“ aus, um ihre Hexfelder wieder zu erfassen.', readyHint: - 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + 'Geben Sie !hexploration ein, um das Menü aufzurufen, oder öffnen Sie das Handout "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -261,16 +261,15 @@ const TRANSLATION = { 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', - journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', help: 'Diese Liste anzeigen.', handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', }, deck: { - subtitle: 'Kommandodeck', drawDesc: - 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie dann. „Füllung rückgängig machen“ macht die letzte Füllung rückgängig.', revealDesc: - 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: @@ -291,9 +290,9 @@ const TRANSLATION = { steps: [ 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', - 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', - 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', - 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf Füllen (oder geben Sie !hexploration fill ein). Die Formen werden durch Hexfelder ersetzt.', + 'Optional: Wählen Sie vor dem Füllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie werden unter den Hexfeldern versteckt und bei ihrer Entdeckung angekündigt.', + 'Bewegen Sie einen Spieler-Token. Jedes Hexfeld, das er durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', ], }, commands: { @@ -306,29 +305,29 @@ const TRANSLATION = { revealing: { heading: 'Wie Offenlegung funktioniert', points: [ - 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', - 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', - 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', - 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', - 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', - 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nur aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Zeichnen in den Hexfeldern gespeichert. Diese Hexfelder werden nur aus höchstens so vielen Hexfeldern Entfernung aufgedeckt, egal wie weit ein Token sehen kann. Nutzen Sie dies für Berge oder Wälder, die verbergen, was dahinter liegt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt.', + 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', ], }, locations: { heading: 'Benannte Hexfelder und Orte', points: [ - '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', - 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', - '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', ], }, settings: { heading: 'Einstellungen', intro: - 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + 'Ändern Sie Einstellungen mit !hexploration set (oder über die Schaltfläche „Einstellungen“). „Hexfeld-Ebene“, „Aufdeckende Token“ und „Sprache“ lassen sich auch auf der Einstellungsseite des Mods festlegen.', colKey: 'Schlüssel', colName: 'Einstellung', colDesc: 'Beschreibung', @@ -338,9 +337,9 @@ const TRANSLATION = { heading: 'Jumpgate und Legacy', points: [ 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', - 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', - 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', - 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + 'Ist „Hexfeld-Ebene“ auf „Auto“ gesetzt, werden Hexfelder auf der Vordergrundebene über den Token gezeichnet, sodass Spieler nicht sehen können, was darunter liegt. Ist die Vordergrundebene nicht verfügbar, wird stattdessen die Token-Ebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Hexfelder, deren Form leicht von Legacy-Hexfeldern abweicht. Wenn die Hexfelder nicht mit dem Raster einer Seite übereinstimmen, rasten Sie einen Token in der Mitte eines Hexfelds ein, wählen Sie ihn aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Token in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie auf der Seite „Erneut scannen“ aus, um sie zusammen mit ihren Namensbeschriftungen und Standort-Token wieder zu erfassen.', ], }, upgrading: { @@ -349,7 +348,7 @@ const TRANSLATION = { 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', - 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], colV1: 'Befehl der Version 1', colV2: 'Befehl der Version 2', @@ -357,10 +356,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Fehlerbehebung', points: [ - 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', - 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', - 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', - 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Nichts passiert, wenn sich ein Token bewegt: Prüfen Sie, ob der Token auf der Token-Ebene liegt und zu „Aufdeckende Token“ passt und ob die Seite Hexfelder hat (!hexploration status).', + 'Hexfelder sind gegenüber dem Raster versetzt: Verwenden Sie „Kalibrieren“ und prüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Hexfelder werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr aufgedeckt: Führen Sie auf der Seite „Erneut scannen“ aus.', + '„Füllen“ meldet, dass der Bereich keine Hexfeld-Mittelpunkte enthält: Die Form muss den Mittelpunkt von mindestens einem Hexfeld enthalten.', 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', ], }, @@ -368,7 +367,7 @@ const TRANSLATION = { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', colLanguage: 'Sprache', - colNative: 'Einheimischer Name', + colNative: 'Eigenbezeichnung', colCode: 'Code', }, credits: { diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index c91b18e17b..f6532567af 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -1,18 +1,18 @@ const TRANSLATION = { titles: { - ready: 'Η εξερεύνηση είναι έτοιμη.', - settings: 'Ρυθμίσεις εξερεύνησης', + ready: 'Το Hexploration είναι έτοιμο.', + settings: 'Ρυθμίσεις Hexploration', languages: 'Επιλέξτε μια γλώσσα', pageSettings: 'Ρυθμίσεις σελίδας: {page}', - status: 'Κατάσταση εξερεύνησης: {page}', - help: 'Εντολές Εξερεύνησης', + status: 'Κατάσταση Hexploration: {page}', + help: 'Εντολές Hexploration', confirm: 'Επιβεβαιώστε', }, discovery: { title: 'Ανακαλύφθηκε τοποθεσία', }, menu: { - draw: 'Ισοπαλία', + draw: 'Σχεδίαση', reveal: 'Αποκάλυψη και απόκρυψη', locations: 'Τοποθεσίες', tools: 'Εργαλεία', @@ -23,52 +23,52 @@ const TRANSLATION = { buttons: { fill: 'Γέμισμα', fillInverse: 'Αντίστροφο γέμισμα', - undo: 'Αναίρεση συμπλήρωσης', - reveal: 'Αποκαλύπτω', + undo: 'Αναίρεση γεμίσματος', + reveal: 'Αποκάλυψη', conceal: 'Απόκρυψη', - explore: 'Εξερευνώ', + explore: 'Εξερεύνηση', revealPage: 'Αποκάλυψη σελίδας', resetPage: 'Επαναφορά σελίδας', mark: 'Επισήμανση τοποθεσίας', unmark: 'Κατάργηση επισήμανσης', - name: 'Όνομα Hex', + name: 'Ονομασία εξαγώνου', settings: 'Ρυθμίσεις', pageSettings: 'Ρυθμίσεις σελίδας', status: 'Κατάσταση', - rescan: 'Εκ νέου σάρωση', - calibrate: 'Μετρώ την διάμετρο', + rescan: 'Επανασάρωση', + calibrate: 'Βαθμονόμηση', calibrateReset: 'Επαναφορά βαθμονόμησης', help: 'Βοήθεια', change: 'Αλλαγή', menu: 'Μενού', - clearOverrides: 'Εκκαθάριση παρακάμψεων', - confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + clearOverrides: 'Κατάργηση παρακάμψεων', + confirmReset: 'Ναι, αφαίρεση όλων των εξαγώνων', }, prompts: { name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', }, values: { - on: 'Επί', - off: 'Μακριά από', - none: 'Κανένας', + on: 'Ενεργό', + off: 'Ανενεργό', + none: 'Κανένα', hexLayer: { - auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', - foreground: 'στρώμα πρώτου πλάνου', - objects: 'συμβολικό στρώμα', + auto: 'Αυτόματο (πρώτο πλάνο, αν είναι διαθέσιμο)', + foreground: 'επίπεδο πρώτου πλάνου', + objects: 'επίπεδο διακριτικών', }, revealBy: { - players: 'Μαρκάρια παίκτη', - characters: 'Μαρκάρια χαρακτήρων', - all: 'Όλες οι μάρκες', + players: 'Διακριτικά παικτών', + characters: 'Διακριτικά χαρακτήρων', + all: 'Όλα τα διακριτικά', }, revealMode: { - clear: 'Σαφής', + clear: 'Καθαρισμός', glimpse: 'Ματιά', }, announce: { - all: 'Καθένας', + all: 'Όλοι', gm: 'Μόνο GM', - off: 'Μακριά από', + off: 'Ανενεργό', }, orientation: { vertical: 'Hex (V)', @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', }, hexLayer: { - label: 'Εξάγωνο στρώμα', - desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + label: 'Επίπεδο εξαγώνων', + desc: 'Πού σχεδιάζονται τα νέα εξάγωνα. Το «Αυτόματο» δοκιμάζει το επίπεδο πρώτου πλάνου (πάνω από τα διακριτικά) και, αν το παιχνίδι δεν το υποστηρίζει, χρησιμοποιεί το επίπεδο διακριτικών.', }, fillColor: { label: 'Χρώμα πλήρωσης', @@ -98,19 +98,19 @@ const TRANSLATION = { desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', }, labelColor: { - label: 'Χρώμα ετικέτας', + label: 'Χρώμα ετικετών', desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', }, glimpseColor: { - label: 'Χρώμα Glimpse', - desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + label: 'Χρώμα Ματιάς', + desc: 'Το χρώμα που παίρνουν τα εξάγωνα στη λειτουργία «Ματιά». Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', }, strokeWidth: { label: 'Πλάτος περιγράμματος', desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', }, maxDistance: { - label: 'Εξάγωνο αποκαλύπτουν απόσταση', + label: 'Απόσταση αποκάλυψης εξαγώνων', desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', }, revealDistance: { @@ -126,37 +126,37 @@ const TRANSLATION = { desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', }, revealBy: { - label: 'Tokens που αποκαλύπτουν', + label: 'Διακριτικά που αποκαλύπτουν', desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', - desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + desc: "Ο «Καθαρισμός» αφαιρεί τα εξάγωνα εντός όρασης. Η «Ματιά» τα κάνει αντί γι' αυτό διαφανή· αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.", }, announce: { - label: 'Ανακοινώστε Ανακαλύψεις', + label: 'Ανακοίνωση ανακαλύψεων', desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', }, pingDiscoveries: { - label: 'Ping ανακαλύψεις', + label: 'Ping στις ανακαλύψεις', desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', }, hideCoveredTokens: { - label: 'Απόκρυψη καλυμμένων κουπονιών', + label: 'Απόκρυψη καλυμμένων διακριτικών', desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { engine: 'Μηχανή παιχνιδιού', grid: 'Πλέγμα', - layer: 'Εξάγωνο στρώμα', + layer: 'Επίπεδο εξαγώνων', hexes: 'Εξάγωνα', named: 'Ονομασμένα εξάγωνα', - icons: 'Διακριτικά τοποθεσίας', - glimpsed: 'Καθαρά εξάγωνα', + icons: 'Διακριτικά τοποθεσιών', + glimpsed: 'Εξάγωνα σε Ματιά', pending: 'Τοποθεσίες που περιμένουν γέμισμα', calibrated: 'Βαθμονομημένο', - overrides: 'Σελίδα παρακάμπτει', + overrides: 'Παρακάμψεις σελίδας', undo: 'Αναίρεση διαθέσιμη', }, messages: { @@ -183,11 +183,11 @@ const TRANSLATION = { 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: - 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', pruned: - 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πια και ξεχάστηκαν: {dropped}. Αν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά τα εξάγωνά της.', readyHint: - 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + 'Πληκτρολογήστε !hexploration για να ανοίξει το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -199,7 +199,7 @@ const TRANSLATION = { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', - emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', @@ -249,21 +249,20 @@ const TRANSLATION = { pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: - 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', - journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', help: 'Εμφάνιση αυτής της λίστας.', handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', }, deck: { - subtitle: 'Κατάστρωμα εντολών', drawDesc: - 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και κάντε «Γέμισμα». Η «Αναίρεση γεμίσματος» αναιρεί το τελευταίο γέμισμα.', revealDesc: - 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: @@ -284,9 +283,9 @@ const TRANSLATION = { steps: [ 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', - 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', - 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', - 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Γέμισμα στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν από το γέμισμα, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην «Επισήμανση τοποθεσίας». Κρύβονται κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και τα εξάγωνα εντός της «Απόστασης όρασης» του, αποκαλύπτονται.', ], }, commands: { @@ -299,29 +298,29 @@ const TRANSLATION = { revealing: { heading: 'Πώς λειτουργεί η αποκάλυψη', points: [ - 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', - 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', - 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', - 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', - 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο αποκαλύπτεται μόνο αν δεν παρεμβάλλεται καλυμμένο εξάγωνο.', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται στα εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται μόνο από απόσταση έως τόσα εξάγωνα, όσο μακριά κι αν βλέπει ένα διακριτικό. Χρησιμοποιήστε την για βουνά ή δάση που κρύβουν ό,τι βρίσκεται πίσω τους.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.', + 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', + 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', ], }, locations: { heading: 'Με όνομα Hexes and Locations', points: [ - 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', - 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', - 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], }, settings: { heading: 'Ρυθμίσεις', intro: - 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', colName: 'Σύνθεση', colDesc: 'Περιγραφή', @@ -331,18 +330,18 @@ const TRANSLATION = { heading: 'Jumpgate και Legacy', points: [ 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', - 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', - 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', - 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', + 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', ], }, upgrading: { heading: 'Αναβάθμιση από την έκδοση 1', points: [ 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', - 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι υπάρχοντες εξαγωνικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσιών και οι ρυθμίσεις αναβαθμίζονται αυτόματα στην πρώτη εκκίνηση.', 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', - 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + 'Η έκδοση 1 επέτρεπε σε κάθε διακριτικό που αντιπροσώπευε χαρακτήρα να αποκαλύπτει εξάγωνα. Ορίστε τα «Διακριτικά που αποκαλύπτουν» σε «Διακριτικά χαρακτήρων» για να διατηρήσετε αυτή τη συμπεριφορά.', ], colV1: 'Εντολή έκδοσης 1', colV2: 'Εντολή έκδοσης 2', @@ -350,10 +349,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Αντιμετώπιση προβλημάτων', points: [ - 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', - 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', - 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', - 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Δεν συμβαίνει τίποτα όταν μετακινείται ένα διακριτικό: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο διακριτικών και ταιριάζει με τη ρύθμιση «Διακριτικά που αποκαλύπτουν», και ότι η σελίδα έχει εξάγωνα (!hexploration status).', + 'Τα εξάγωνα είναι μετατοπισμένα από το πλέγμα: χρησιμοποιήστε τη «Βαθμονόμηση» και μετά ελέγξτε με ένα διακριτικό μερικά εξάγωνα σε διάφορα σημεία του χάρτη.', + 'Τα εξάγωνα σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε «Επανασάρωση» στη σελίδα.', + 'Το «Γέμισμα» αναφέρει ότι η περιοχή δεν έχει κέντρα εξαγώνων: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξαγώνου.', 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', ], }, @@ -361,7 +360,7 @@ const TRANSLATION = { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', - colNative: 'Εγγενές όνομα', + colNative: 'Όνομα στη γλώσσα της', colCode: 'Κώδικας', }, credits: { diff --git a/Hexploration/src/locales/locale/en-US.js b/Hexploration/src/locales/locale/en-US.js index cb6b0d08ac..68f359922a 100644 --- a/Hexploration/src/locales/locale/en-US.js +++ b/Hexploration/src/locales/locale/en-US.js @@ -253,7 +253,6 @@ export default { handout: 'Full instructions are in the "{name}" handout.', }, deck: { - subtitle: 'Command Deck', drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', revealDesc: 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index fd20413b5f..5865c1f41e 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -1,12 +1,12 @@ const TRANSLATION = { titles: { - ready: 'La hexploración está lista.', - settings: 'Configuración de hexploración', + ready: 'Hexploration está listo.', + settings: 'Configuración de Hexploration', languages: 'Elige un idioma', pageSettings: 'Configuración de página: {page}', - status: 'Estado de exploración: {page}', - help: 'Comandos de hexploración', - confirm: 'Por favor confirme', + status: 'Estado de Hexploration: {page}', + help: 'Comandos de Hexploration', + confirm: 'Por favor, confirme', }, discovery: { title: 'Ubicación descubierta', @@ -16,12 +16,12 @@ const TRANSLATION = { reveal: 'Revelar y ocultar', locations: 'Ubicaciones', tools: 'Herramientas', - layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + layerInUse: 'Se están dibujando nuevos hexágonos en la {layer}.', pageSettingsHelp: 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', }, buttons: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', undo: 'Deshacer relleno', reveal: 'Revelar', @@ -31,8 +31,8 @@ const TRANSLATION = { resetPage: 'Restablecer página', mark: 'Marcar ubicación', unmark: 'Desmarcar', - name: 'Nombre hexadecimal', - settings: 'Ajustes', + name: 'Nombrar hexágono', + settings: 'Configuración', pageSettings: 'Configuración de página', status: 'Estado', rescan: 'Volver a escanear', @@ -48,34 +48,34 @@ const TRANSLATION = { name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', }, values: { - on: 'En', - off: 'Apagado', + on: 'Activado', + off: 'Desactivado', none: 'Ninguno', hexLayer: { auto: 'Auto (primer plano si está disponible)', foreground: 'capa de primer plano', - objects: 'capa de token', + objects: 'capa de fichas', }, revealBy: { - players: 'fichas de jugador', + players: 'Fichas de jugador', characters: 'Fichas de personaje', all: 'Todas las fichas', }, revealMode: { - clear: 'Claro', + clear: 'Despejar', glimpse: 'Vistazo', }, announce: { all: 'Todos', - gm: 'solo GM', - off: 'Apagado', + gm: 'Solo el DJ', + off: 'Desactivado', }, orientation: { - vertical: 'Hexágono (V)', - horizontal: 'Hexagonal (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', conceal: 'Ocultar', }, @@ -86,7 +86,7 @@ const TRANSLATION = { desc: 'Idioma para menús, mensajes y folletos.', }, hexLayer: { - label: 'Capa hexagonal', + label: 'Capa de hexágonos', desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', }, fillColor: { @@ -102,15 +102,15 @@ const TRANSLATION = { desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', }, glimpseColor: { - label: 'Color de vislumbre', - desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + label: 'Color de vistazo', + desc: 'Color que toman los hexágonos al vislumbrarse (modo de revelación Vistazo). Use un color rgba() transparente.', }, strokeWidth: { label: 'Ancho del borde', desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', }, maxDistance: { - label: 'Distancia de revelación hexagonal', + label: 'Distancia de revelación de hexágonos', desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', }, revealDistance: { @@ -130,38 +130,38 @@ const TRANSLATION = { desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', }, revealMode: { - label: 'Modo revelar', - desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + label: 'Modo de revelación', + desc: 'Despejar elimina los hexágonos a la vista. Vistazo, en cambio, los vuelve transparentes; se eliminan cuando una ficha entra en ellos.', }, announce: { label: 'Anunciar descubrimientos', desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', }, pingDiscoveries: { - label: 'Descubrimientos de ping', + label: 'Hacer ping a los descubrimientos', desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', }, hideCoveredTokens: { - label: 'Ocultar tokens cubiertos', + label: 'Ocultar fichas cubiertas', desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', }, }, status: { - engine: 'motor de juego', - grid: 'Red', - layer: 'capa hexagonal', + engine: 'Motor de juego', + grid: 'Cuadrícula', + layer: 'Capa de hexágonos', hexes: 'Hexágonos', named: 'Hexágonos con nombre', icons: 'Fichas de ubicación', glimpsed: 'Hexágonos vislumbrados', - pending: 'Ubicaciones esperando ser llenadas', + pending: 'Ubicaciones pendientes de relleno', calibrated: 'Calibrado', overrides: 'Anulaciones de página', undo: 'Deshacer disponible', }, messages: { filled: - 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + 'Relleno completado. Hexágonos dibujados: {created}. Con nuevo estilo: {restyled}. Ubicaciones ocultas: {icons}.', revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: @@ -183,11 +183,11 @@ const TRANSLATION = { 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: - 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', pruned: 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', readyHint: - 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + 'Escriba !hexploration para ver el menú o abra el folleto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -197,9 +197,9 @@ const TRANSLATION = { }, errors: { noPage: 'No se pudo encontrar la página para trabajar.', - notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + notHex: 'Esta página no utiliza una cuadrícula hexagonal.', noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', - emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + emptyArea: 'El área seleccionada no contiene ningún centro de hexágono.', tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', @@ -210,7 +210,7 @@ const TRANSLATION = { unknownSetting: 'Configuración desconocida: {key}', unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', invalidValue: '"{value}" no es un valor válido para {key}.', - calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateNeedsTokens: 'Seleccione una o dos fichas ajustadas a centros de hexágonos.', calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', unexpected: 'Algo salió mal: {message}', }, @@ -251,21 +251,20 @@ const TRANSLATION = { pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: - 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', - journal: 'Reconstruya los folletos de Ayuda y Comando.', + journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', help: 'Muestra esta lista.', handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', }, deck: { - subtitle: 'Cubierta de mando', drawDesc: - 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + 'Dibuja formas alrededor de un área, selecciónalas y luego rellena. Deshacer relleno revierte el último relleno.', revealDesc: - 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + 'Selecciona hexágonos, formas o fichas para revelarlos o volver a cubrirlos. Explorar revela alrededor de las fichas seleccionadas como si se hubieran movido.', locationsDesc: 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', toolsDesc: @@ -286,7 +285,7 @@ const TRANSLATION = { steps: [ 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', - 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], @@ -301,29 +300,29 @@ const TRANSLATION = { revealing: { heading: 'Cómo funciona la revelación', points: [ - 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', + 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', ], }, locations: { heading: 'Hexágonos y ubicaciones con nombre', points: [ - 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', - 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', - 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], }, settings: { heading: 'Ajustes', intro: - 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', colKey: 'Llave', colName: 'Configuración', colDesc: 'Descripción', @@ -333,18 +332,18 @@ const TRANSLATION = { heading: 'Jumpgate y legado', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', - 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', - 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', - 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, cuya forma es ligeramente distinta de la de los hexágonos de Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha al centro de un hexágono, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos, junto con sus etiquetas de nombre y fichas de ubicación.', ], }, upgrading: { heading: 'Actualización desde la versión 1', points: [ 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', - 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los mapas de hexágonos, nombres, fichas de ubicación y ajustes existentes se actualizan automáticamente la primera vez que se inicia.', 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', - 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + 'La versión 1 permitía que cualquier ficha que representara a un personaje revelara hexágonos. Ajuste Fichas que revelan a Fichas de personaje para mantener ese comportamiento.', ], colV1: 'Comando versión 1', colV2: 'Comando versión 2', @@ -352,10 +351,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Solución de problemas', points: [ - 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'No pasa nada cuando una ficha se mueve: compruebe que la ficha está en la capa de fichas y coincide con Fichas que revelan, y que la página tiene hexágonos (!hexploration status).', 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', - 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', - 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Los hexágonos dejaron de revelarse tras copiar una página o un juego: ejecute Volver a escanear en la página.', + 'Rellenar dice que el área no tiene centros de hexágono: la forma debe contener el centro de al menos un hexágono.', 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', ], }, @@ -363,7 +362,7 @@ const TRANSLATION = { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', colLanguage: 'Idioma', - colNative: 'nombre nativo', + colNative: 'Nombre original', colCode: 'Código', }, credits: { diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index 536b18453f..a9dfed35f2 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -1,48 +1,48 @@ const TRANSLATION = { titles: { ready: 'Hexploration on valmis.', - settings: 'Tutkimusasetukset', + settings: 'Hexploration-asetukset', languages: 'Valitse kieli', pageSettings: 'Sivuasetukset: {page}', - status: 'Tutkimuksen tila: {page}', - help: 'Hexploration komennot', - confirm: 'Ole hyvä ja vahvista', + status: 'Hexploration-tila: {page}', + help: 'Hexploration-komennot', + confirm: 'Vahvista', }, discovery: { title: 'Sijainti löydetty', }, menu: { - draw: 'Piirrä', + draw: 'Piirto', reveal: 'Paljasta ja piilota', locations: 'Sijainnit', tools: 'Työkalut', - layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + layerInUse: 'Uudet heksat piirretään tasolle: {layer}.', pageSettingsHelp: 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', }, buttons: { - fill: 'Täyttää', + fill: 'Täytä', fillInverse: 'Käänteinen täyttö', undo: 'Kumoa täyttö', - reveal: 'Paljastaa', - conceal: 'Salata', - explore: 'Tutkia', + reveal: 'Paljasta', + conceal: 'Peitä', + explore: 'Tutki', revealPage: 'Paljasta sivu', resetPage: 'Nollaa sivu', mark: 'Merkitse sijainti', unmark: 'Poista merkintä', - name: 'Nimi Hex', + name: 'Nimeä heksa', settings: 'Asetukset', - pageSettings: 'Sivun asetukset', - status: 'Status', + pageSettings: 'Sivuasetukset', + status: 'Tila', rescan: 'Skannaa uudelleen', - calibrate: 'Kalibroida', + calibrate: 'Kalibroi', calibrateReset: 'Nollaa kalibrointi', - help: 'Auttaa', - change: 'Muuttaa', + help: 'Ohje', + change: 'Muuta', menu: 'Valikko', clearOverrides: 'Tyhjennä ohitukset', - confirmReset: 'Kyllä, poista kaikki heksit', + confirmReset: 'Kyllä, poista kaikki heksat', }, prompts: { name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', @@ -52,18 +52,18 @@ const TRANSLATION = { off: 'Pois', none: 'Ei mitään', hexLayer: { - auto: 'Automaattinen (etualalla, jos saatavilla)', - foreground: 'etualan kerros', - objects: 'merkkikerros', + auto: 'Automaattinen (etuala, jos saatavilla)', + foreground: 'etualan taso', + objects: 'merkkitaso', }, revealBy: { - players: 'Pelaajan merkit', - characters: 'Hahmomerkit', + players: 'Pelaajien merkit', + characters: 'Hahmojen merkit', all: 'Kaikki merkit', }, revealMode: { - clear: 'Selkeä', - glimpse: 'Vilkkaus', + clear: 'Poisto', + glimpse: 'Vilkaisu', }, announce: { all: 'Kaikki', @@ -75,9 +75,9 @@ const TRANSLATION = { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Täyttää', + fill: 'Täyttö', fillInverse: 'Käänteinen täyttö', - conceal: 'Salata', + conceal: 'Peitto', }, }, settings: { @@ -86,31 +86,31 @@ const TRANSLATION = { desc: 'Valikkojen, viestien ja monisteiden kieli.', }, hexLayer: { - label: 'Hex kerros', - desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + label: 'Heksataso', + desc: 'Mihin uudet heksat piirretään. Automaattinen kokeilee etualan tasoa (merkkien yläpuolella) ja käyttää merkkitasoa, jos peli ei tue sitä.', }, fillColor: { label: 'Täyttöväri', desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Reunuksen väri', + label: 'Reunan väri', desc: 'Uusien kuusioiden ääriviivan väri.', }, labelColor: { - label: 'Etiketin väri', + label: 'Nimilappujen väri', desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + label: 'Vilkaisun väri', + desc: 'Väri, jonka heksat saavat Vilkaisu-tilassa. Käytä läpikuultavaa rgba()-väriä.', }, strokeWidth: { label: 'Reunan leveys', desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', }, maxDistance: { - label: 'Hex paljastaa etäisyyttä', + label: 'Heksojen paljastusetäisyys', desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', }, revealDistance: { @@ -118,46 +118,46 @@ const TRANSLATION = { desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', }, lineOfSight: { - label: 'Näkökenttä', + label: 'Näköyhteys', desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', }, revealPath: { - label: 'Paljasta polun varrella', + label: 'Paljasta reitin varrelta', desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { - label: 'Tokenit jotka paljastavat', + label: 'Paljastavat merkit', desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', }, revealMode: { label: 'Paljastustila', - desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + desc: 'Poisto poistaa näköetäisyydellä olevat heksat. Vilkaisu tekee niistä sen sijaan läpikuultavia; ne poistetaan, kun merkki astuu niihin.', }, announce: { - label: 'Ilmoita löydökset', + label: 'Ilmoita löydöt', desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', }, pingDiscoveries: { - label: 'Ping löydöt', + label: 'Pingaa löydöt', desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', }, hideCoveredTokens: { - label: 'Piilota peitetyt rahakkeet', + label: 'Piilota peitetyt merkit', desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', }, }, status: { - engine: 'Pelin moottori', + engine: 'Pelimoottori', grid: 'Ruudukko', - layer: 'Hex kerros', - hexes: 'Hexes', + layer: 'Heksataso', + hexes: 'Heksat', named: 'Nimetyt heksat', - icons: 'Sijaintitunnukset', - glimpsed: 'Näytetyt kuusiot', - pending: 'Täyttöä odottavat paikat', + icons: 'Sijaintimerkit', + glimpsed: 'Vilkaistut heksat', + pending: 'Täyttöä odottavat sijainnit', calibrated: 'Kalibroitu', overrides: 'Sivun ohitukset', - undo: 'Kumoa käytettävissä', + undo: 'Kumoaminen käytettävissä', }, messages: { filled: @@ -183,10 +183,11 @@ const TRANSLATION = { 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: - 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', pruned: - 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', - readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla Skannaa uudelleen, jotta sen heksat löytyvät taas.', + readyHint: + 'Kirjoita !hexploration avataksesi valikon, tai avaa moniste "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -214,7 +215,7 @@ const TRANSLATION = { }, hints: { noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', - notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + notHex: 'Aseta sivun ruudukoksi Hex (V) tai Hex (H) sivun asetuksista.', noPolygons: 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', @@ -224,7 +225,7 @@ const TRANSLATION = { unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: - 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', @@ -247,23 +248,22 @@ const TRANSLATION = { pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: - 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', - journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', help: 'Näytä tämä luettelo.', handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', }, deck: { - subtitle: 'Komentolevy', drawDesc: - 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + 'Piirrä muotoja alueen ympärille, valitse ne ja napsauta Täytä. Kumoa täyttö peruu viimeisimmän täytön.', revealDesc: - 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + 'Valitse heksoja, muotoja tai merkkejä paljastaaksesi ne tai peittääksesi ne uudelleen. Tutki paljastaa valittujen merkkien ympäristön ikään kuin ne olisivat juuri siirtyneet sinne.', locationsDesc: - 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + 'Valitse merkit piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksoja tai merkkejä nimetäksesi heksan.', toolsDesc: 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', footer: 'Katso täydelliset ohjeet monisteesta "{help}".', @@ -282,9 +282,9 @@ const TRANSLATION = { steps: [ 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', - 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', - 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', - 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + 'Valitse muodot ja napsauta Command Deck -monisteessa Täytä (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: valitse ennen täyttöä merkit tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan heksojen alle, ja niistä ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajan merkkiä. Jokainen heksa, jonka läpi se kulkee, ja sen Näköetäisyyden sisällä olevat heksat paljastetaan.', ], }, commands: { @@ -297,29 +297,29 @@ const TRANSLATION = { revealing: { heading: 'Kuinka paljastaminen toimii', points: [ - 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', - 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', - 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', - 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', - 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat. Kun Näköyhteys on päällä, heksa paljastetaan vain, jos välissä ei ole peitettyä heksaa.', + 'Heksojen paljastusetäisyys tallennetaan heksoihin niitä piirrettäessä. Nämä heksat paljastuvat vain enintään näin monen heksan päästä, vaikka merkki näkisi kauemmas. Käytä sitä vuorille tai metsille, jotka kätkevät taakseen jäävän.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin.', + 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', + 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', ], }, locations: { heading: 'Nimetty Heksit ja sijainnit', points: [ - 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', - 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', - 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], }, settings: { heading: 'Asetukset', intro: - 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + 'Muuta asetuksia komennolla !hexploration set (tai Asetukset-painikkeella). Heksatason, Paljastavat merkit ja Kielen voi asettaa myös modin asetussivulla.', colKey: 'Avain', colName: 'Asetus', colDesc: 'Kuvaus', @@ -329,18 +329,18 @@ const TRANSLATION = { heading: 'Jumpgate ja Legacy', points: [ 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', - 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', - 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', - 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + 'Kun Heksataso on Automaattinen, heksat piirretään etualan tasolle merkkien yläpuolelle, joten pelaajat eivät näe, mitä alla on. Jos etualan taso ei ole käytettävissä, käytetään merkkitasoa.', + 'Jumpgate piirtää matemaattisesti säännöllisiä heksoja, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksat eivät osu sivun ruudukkoon, kiinnitä merkki heksan keskipisteeseen, valitse se ja napsauta Kalibroi. Korjaa myös heksan koko valitsemalla kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) vierekkäisistä heksoista.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnisteet. Suorita sivulla Skannaa uudelleen, jotta ne löytyvät taas nimilappuineen ja sijaintimerkkeineen.', ], }, upgrading: { heading: 'Päivitys versiosta 1', points: [ 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', - 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Nykyiset heksakartat, nimet, sijaintimerkit ja asetukset päivitetään automaattisesti ensimmäisellä käynnistyksellä.', 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', - 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + 'Versiossa 1 mikä tahansa hahmoa edustava merkki paljasti heksoja. Säilytä tämä toiminta asettamalla Paljastavat merkit arvoon Hahmojen merkit.', ], colV1: 'Version 1 komento', colV2: 'Version 2 komento', @@ -348,23 +348,23 @@ const TRANSLATION = { troubleshooting: { heading: 'Vianetsintä', points: [ - 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', - 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', - 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', - 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkitasolla ja vastaa Paljastavat merkit -asetusta ja että sivulla on heksoja (!hexploration status).', + 'Heksat ovat siirtyneet ruudukosta: käytä Kalibroi-toimintoa ja tarkista sitten merkillä muutama heksa eri puolilta karttaa.', + 'Heksat lakkasivat paljastumasta sivun tai pelin kopioinnin jälkeen: suorita sivulla Skannaa uudelleen.', + 'Täytä ilmoittaa, ettei alueella ole heksojen keskipisteitä: muodon on sisällettävä vähintään yhden heksan keskipiste.', 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', ], }, languages: { heading: 'Kielet', - body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + body: 'Valitse kieli komennolla !hexploration set language. Käytettävissä olevat kielet:', colLanguage: 'Kieli', - colNative: 'Alkuperäinen nimi', + colNative: 'Oma nimi', colCode: 'Koodi', }, credits: { heading: 'Krediitit', - original: 'Alkuperäinen mod', + original: 'Alkuperäisen modin tekijä', maintainer: 'Versio 2 ylläpitäjä', marketplace: 'Adan taidepaketit Roll20 Marketplacessa', support: diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index 3bbb6a95ca..664ee7cf85 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -1,11 +1,11 @@ const TRANSLATION = { titles: { - ready: "L'exploration est prête.", - settings: "Paramètres d'exploration", + ready: 'Hexploration est prêt.', + settings: "Paramètres d'Hexploration", languages: 'Choisissez une langue', pageSettings: 'Paramètres de la page : {page}', - status: "Statut d'exploration : {page}", - help: "Commandes d'exploration", + status: "État d'Hexploration : {page}", + help: "Commandes d'Hexploration", confirm: 'Veuillez confirmer', }, discovery: { @@ -28,18 +28,18 @@ const TRANSLATION = { conceal: 'Cacher', explore: 'Explorer', revealPage: 'Révéler la page', - resetPage: 'Page de réinitialisation', + resetPage: 'Réinitialiser la page', mark: "Marquer l'emplacement", - unmark: 'Décocher', - name: 'Nom Hex', + unmark: 'Démarquer', + name: "Nommer l'hexagone", settings: 'Paramètres', - pageSettings: 'Paramètres des pages', + pageSettings: 'Paramètres de la page', status: 'Statut', rescan: 'Nouvelle analyse', - calibrate: 'Étalonner', - calibrateReset: "Réinitialiser l'étalonnage", + calibrate: 'Calibrer', + calibrateReset: 'Réinitialiser le calibrage', help: 'Aide', - change: 'Changement', + change: 'Modifier', menu: 'Menu', clearOverrides: 'Effacer les remplacements', confirmReset: 'Oui, supprimer tous les hexagones', @@ -48,13 +48,13 @@ const TRANSLATION = { name: 'Nom du lieu (laissez vide pour effacer)', }, values: { - on: 'Sur', + on: 'Activé', off: 'Désactivé', none: 'Aucun', hexLayer: { auto: 'Auto (premier plan si disponible)', foreground: 'calque de premier plan', - objects: 'couche de jetons', + objects: 'calque des jetons', }, revealBy: { players: 'Jetons de joueur', @@ -62,12 +62,12 @@ const TRANSLATION = { all: 'Tous les jetons', }, revealMode: { - clear: 'Clair', + clear: 'Effacer', glimpse: 'Aperçu', }, announce: { all: 'Tout le monde', - gm: 'GM uniquement', + gm: 'MJ uniquement', off: 'Désactivé', }, orientation: { @@ -86,7 +86,7 @@ const TRANSLATION = { desc: 'Langue des menus, des messages et des documents.', }, hexLayer: { - label: 'Couche hexagonale', + label: 'Calque des hexagones', desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', }, fillColor: { @@ -102,15 +102,15 @@ const TRANSLATION = { desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', }, glimpseColor: { - label: 'Aperçu de la couleur', - desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + label: "Couleur d'aperçu", + desc: 'Couleur que prennent les hexagones aperçus (mode de révélation Aperçu). Utilisez une couleur rgba() transparente.', }, strokeWidth: { label: 'Largeur de la bordure', desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', }, maxDistance: { - label: 'Distance de révélation hexagonale', + label: 'Distance de révélation des hexagones', desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", }, revealDistance: { @@ -126,19 +126,19 @@ const TRANSLATION = { desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { - label: 'Des jetons qui révèlent', + label: 'Jetons révélateurs', desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", }, revealMode: { - label: 'Mode Révéler', - desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + label: 'Mode de révélation', + desc: "Effacer supprime les hexagones à portée de vue. Aperçu les rend plutôt transparents ; ils sont supprimés lorsqu'un jeton y entre.", }, announce: { - label: 'Annoncer des découvertes', + label: 'Annoncer les découvertes', desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", }, pingDiscoveries: { - label: 'Découvertes Ping', + label: 'Pinger les découvertes', desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", }, hideCoveredTokens: { @@ -149,19 +149,19 @@ const TRANSLATION = { status: { engine: 'Moteur de jeu', grid: 'Grille', - layer: 'Couche hexagonale', + layer: 'Calque des hexagones', hexes: 'Hexagones', - named: 'Hexs nommés', - icons: 'Jetons de localisation', - glimpsed: 'Hexs aperçus', - pending: "Emplacements en attente d'un remplissage", + named: 'Hexagones nommés', + icons: "Jetons d'emplacement", + glimpsed: 'Hexagones aperçus', + pending: 'Emplacements en attente de remplissage', calibrated: 'Calibré', overrides: 'Remplacements de page', - undo: 'Annuler disponible', + undo: 'Annulation disponible', }, messages: { filled: - 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', revealed: 'Hexs révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: @@ -187,7 +187,7 @@ const TRANSLATION = { pruned: "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: - 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -257,16 +257,15 @@ const TRANSLATION = { 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', status: 'Montre ce que Hexploration sait de la page actuelle.', - journal: "Reconstruisez les documents d'aide et de commande.", + journal: 'Reconstruisez les documents Help et Command Deck.', help: 'Montrez cette liste.', handout: 'Les instructions complètes se trouvent dans le document « {name} ».', }, deck: { - subtitle: 'Pont de commandement', drawDesc: - "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez. Annuler le remplissage annule le dernier remplissage.", revealDesc: - "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir. Explorer révèle les alentours des jetons sélectionnés comme s'ils venaient de s'y déplacer.", locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: @@ -287,7 +286,7 @@ const TRANSLATION = { steps: [ 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', - 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", ], @@ -302,29 +301,29 @@ const TRANSLATION = { revealing: { heading: 'Comment fonctionne la révélation', points: [ - 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", - 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', - "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "La distance de vue révèle les hexagones autour de chacun de ces hexagones. Avec Ligne de vue activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre les deux.", + "La distance de révélation des hexagones est enregistrée sur les hexagones au moment où ils sont dessinés. Ces hexagones ne sont révélés que depuis ce nombre d'hexagones au plus, quelle que soit la distance à laquelle un jeton peut voir. Utilisez-la pour des montagnes ou des forêts qui cachent ce qui se trouve derrière elles.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", - "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", ], }, locations: { heading: 'Hexs et emplacements nommés', points: [ - 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", - "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", - "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], }, settings: { heading: 'Paramètres', intro: - 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). Calque des hexagones, Jetons révélateurs et Langue peuvent aussi être définis sur la page de paramètres du mod.', colKey: 'Clé', colName: 'Paramètre', colDesc: 'Description', @@ -334,7 +333,7 @@ const TRANSLATION = { heading: 'Jumpgate et héritage', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", - "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", ], @@ -345,7 +344,7 @@ const TRANSLATION = { "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', - "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + 'La version 1 permettait à tout jeton représentant un personnage de révéler des hexagones. Réglez Jetons révélateurs sur Jetons de personnage pour conserver ce comportement.', ], colV1: 'Commande version 1', colV2: 'Commande version 2', @@ -353,10 +352,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Dépannage', points: [ - "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", - "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], }, @@ -364,7 +363,7 @@ const TRANSLATION = { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', colLanguage: 'Langue', - colNative: 'Nom natif', + colNative: "Nom d'origine", colCode: 'Code', }, credits: { diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index 4ab24ebd12..bd79375d77 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -1,92 +1,92 @@ const TRANSLATION = { titles: { - ready: 'החקירה מוכנה.', - settings: 'הגדרות החקירה', - languages: 'בחר שפה', + ready: 'Hexploration מוכן.', + settings: 'הגדרות Hexploration', + languages: 'בחירת שפה', pageSettings: 'הגדרות דף: {page}', - status: 'סטטוס החקירה: {page}', - help: 'פקודות החקירה', - confirm: 'אנא אשר', + status: 'מצב Hexploration: {page}', + help: 'פקודות Hexploration', + confirm: 'נא לאשר', }, discovery: { title: 'מיקום התגלה', }, menu: { - draw: 'לִמְשׁוֹך', - reveal: 'לגלות ולהסתיר', + draw: 'ציור', + reveal: 'חשיפה והסתרה', locations: 'מיקומים', - tools: 'כְּלֵי עֲבוֹדָה', - layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + tools: 'כלים', + layerInUse: 'משושים חדשים מצוירים על {layer}.', pageSettingsHelp: 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', }, buttons: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - undo: 'בטל מילוי', - reveal: 'לְגַלוֹת', - conceal: 'לְהַסתִיר', - explore: 'לַחקוֹר', - revealPage: 'גלה עמוד', - resetPage: 'אפס דף', - mark: 'סמן מיקום', - unmark: 'בטל את הסימון', - name: 'שם הקס', + undo: 'ביטול מילוי', + reveal: 'חשיפה', + conceal: 'הסתרה', + explore: 'חקירה', + revealPage: 'חשיפת הדף', + resetPage: 'איפוס הדף', + mark: 'סימון מיקום', + unmark: 'ביטול סימון', + name: 'מתן שם למשושה', settings: 'הגדרות', - pageSettings: 'הגדרות עמוד', - status: 'סטָטוּס', - rescan: 'סרוק מחדש', - calibrate: 'לְדַרֵג', + pageSettings: 'הגדרות דף', + status: 'מצב', + rescan: 'סריקה מחדש', + calibrate: 'כיול', calibrateReset: 'אפס כיול', - help: 'עֶזרָה', - change: 'לְשַׁנוֹת', - menu: 'תַפרִיט', - clearOverrides: 'נקה עקיפות', + help: 'עזרה', + change: 'שינוי', + menu: 'תפריט', + clearOverrides: 'ניקוי עקיפות', confirmReset: 'כן, הסר את כל המשושים', }, prompts: { name: 'שם המיקום (השאירו ריק כדי לנקות)', }, values: { - on: 'עַל', + on: 'מופעל', off: 'כבוי', - none: 'אַף לֹא אֶחָד', + none: 'ללא', hexLayer: { - auto: 'אוטומטי (בחזית אם זמין)', - foreground: 'שכבת חזית', - objects: 'שכבת אסימונים', + auto: 'אוטומטי (שכבת החזית אם זמינה)', + foreground: 'שכבת החזית', + objects: 'שכבת האסימונים', }, revealBy: { - players: 'אסימוני שחקן', - characters: 'אסימוני תווים', + players: 'אסימוני שחקנים', + characters: 'אסימוני דמויות', all: 'כל האסימונים', }, revealMode: { - clear: 'בָּרוּר', - glimpse: 'הֲצָצָה', + clear: 'הסרה', + glimpse: 'הצצה', }, announce: { - all: 'כֹּל אֶחָד', + all: 'כולם', gm: 'GM בלבד', off: 'כבוי', }, orientation: { - vertical: 'משושה (V)', - horizontal: 'משושה (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - conceal: 'לְהַסתִיר', + conceal: 'הסתרה', }, }, settings: { language: { - label: 'שָׂפָה', + label: 'שפה', desc: 'שפה לתפריטים, הודעות ודפי מידע.', }, hexLayer: { - label: 'שכבת משושה', + label: 'שכבת המשושים', desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', }, fillColor: { @@ -94,23 +94,23 @@ const TRANSLATION = { desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { - label: 'צבע גבול', + label: 'צבע מסגרת', desc: 'צבע קווי המתאר של משושות חדשות.', }, labelColor: { - label: 'צבע התווית', + label: 'צבע תווית', desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', }, glimpseColor: { label: 'צבע הצצה', - desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + desc: 'הצבע שאליו משושים משתנים בעת הצצה (מצב החשיפה הצצה). השתמש בצבע rgba() שקוף.', }, strokeWidth: { - label: 'רוחב גבול', + label: 'עובי מסגרת', desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', }, maxDistance: { - label: 'מרחק חשיפת משושה', + label: 'מרחק חשיפת משושים', desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', }, revealDistance: { @@ -122,42 +122,42 @@ const TRANSLATION = { desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', }, revealPath: { - label: 'גלה לאורך הנתיב', + label: 'חשיפה לאורך המסלול', desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', }, revealBy: { - label: 'אסימונים שחושפים', + label: 'אסימונים חושפים', desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', }, revealMode: { label: 'מצב חשיפה', - desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + desc: 'הסרה מסירה משושים שבטווח הראייה. הצצה הופכת אותם לשקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', }, announce: { - label: 'הכריזו על תגליות', + label: 'הכרזה על תגליות', desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", }, pingDiscoveries: { - label: 'פינג תגליות', + label: 'פינג לתגליות', desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', }, hideCoveredTokens: { label: 'הסתר אסימונים מכוסים', - desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + desc: 'Roll20 מצייר שמות, פסים והילות מעל משושים. כשההגדרה מופעלת, השם, הפסים וההילות הגלויים לשחקנים של אסימונים שמתחת למשושה מכוסה נכבים, ומופעלים שוב כשהם נחשפים.', }, }, status: { engine: 'מנוע משחק', - grid: 'רֶשֶׁת', - layer: 'שכבת משושה', + grid: 'רשת', + layer: 'שכבת המשושים', hexes: 'משושים', - named: 'ששים בשם', + named: 'משושים עם שם', icons: 'אסימוני מיקום', - glimpsed: 'משושים נוצצים', + glimpsed: 'משושים בהצצה', pending: 'מיקומים ממתינים למילוי', - calibrated: 'מְכוּיָל', - overrides: 'עקיפת עמוד', - undo: 'בטל זמין', + calibrated: 'מכויל', + overrides: 'עקיפות דף', + undo: 'ניתן לבטל', }, messages: { filled: @@ -181,10 +181,11 @@ const TRANSLATION = { 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: - 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', - readyHint: 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + readyHint: + 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -246,17 +247,16 @@ const TRANSLATION = { calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', - journal: 'בנה מחדש את דפי העזרה והפקודה.', + journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', help: 'הצג רשימה זו.', handout: 'ההנחיות המלאות נמצאות בדף "{name}".', }, deck: { - subtitle: 'סיפון פיקוד', - drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. ביטול מילוי מבטל את המילוי האחרון.', revealDesc: - 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + 'בחר משושים, צורות או אסימונים כדי לחשוף אותם או לכסות אותם שוב. חקירה חושפת את הסביבה של האסימונים הנבחרים כאילו הם זזו לשם.', locationsDesc: - 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר משושים או אסימונים כדי לתת שם למשושה.', toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', footer: 'עיין בדף "{help}" להנחיות מלאות.', }, @@ -266,7 +266,7 @@ const TRANSLATION = { footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', - body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + body: 'Hexploration מכסה מפת משושים במשושים אטומים. כשהחבורה זזה, המשושים שהיא עוברת דרכם (ואם תרצו, גם המשושים שסביבה) מוסרים, כך שהמפה נחשפת משושה אחר משושה. אפשר להציב מיקומים מוסתרים מתחת למשושים, והם מוכרזים כשהם נמצאים. הכלי עובד במשחקי Jumpgate ו-Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', demo: 'צפו בהדגמה קצרה (מגרסה 1)', }, quickStart: { @@ -274,9 +274,9 @@ const TRANSLATION = { steps: [ 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', - 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', - 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', - 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות במשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סימון מיקום. הם מוסתרים מתחת למשושים ומוכרזים כשהם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והמשושים שבתוך מרחק הראייה שלו, נחשפים.', ], }, commands: { @@ -289,40 +289,40 @@ const TRANSLATION = { revealing: { heading: 'איך עובד גילוי', points: [ - 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', - 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', - 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'מרחק חשיפת משושים נשמר על המשושים בזמן שהם מצוירים. משושים אלה נחשפים רק מטווח של מספר המשושים הזה, לא משנה כמה רחוק אסימון יכול לראות. השתמש בו להרים או ליערות שמסתירים את מה שמאחוריהם.', 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', + 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', ], }, locations: { heading: 'בשם משושים ומיקומים', points: [ - 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', - 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', - 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], }, settings: { heading: 'הגדרות', intro: - 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', colName: 'סְבִיבָה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, jumpgate: { - heading: 'Jumpgate ומורשת', + heading: 'Jumpgate ו-Legacy', points: [ - 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', - 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', - 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'Hexploration מזהה באיזה מנוע המשחק משתמש ומצייר את סוג הצורה המתאים. אפשר למלא צורות שצוירו בכל אחד משני העורכים.', + 'כששכבת המשושים מוגדרת לאוטומטי, משושים מצוירים בשכבת החזית, מעל האסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימונים במקום זאת.', + 'Jumpgate מצייר משושים משוכללים מתמטית, שצורתם שונה מעט ממשושי Legacy. אם המשושים אינם מתיישרים עם הרשת של הדף, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים במשושים שכנים באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', ], }, @@ -332,7 +332,7 @@ const TRANSLATION = { 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', - 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], colV1: 'פקודה גרסה 1', colV2: 'פקודה גרסה 2', @@ -340,9 +340,9 @@ const TRANSLATION = { troubleshooting: { heading: 'פתרון בעיות', points: [ - 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', - 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', - 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', + 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', + 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], @@ -351,7 +351,7 @@ const TRANSLATION = { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', colLanguage: 'שָׂפָה', - colNative: 'שם יליד', + colNative: 'שם בשפת המקור', colCode: 'קוד', }, credits: { diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index 21ab0fa793..93060bf6c5 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -1,60 +1,60 @@ const TRANSLATION = { titles: { - ready: 'A hexploration készen áll.', - settings: 'Hexexploration beállítások', + ready: 'A Hexploration készen áll.', + settings: 'Hexploration-beállítások', languages: 'Válasszon nyelvet', pageSettings: 'Oldalbeállítások: {page}', - status: 'Heti feltárás állapota: {page}', + status: 'Hexploration-állapot: {page}', help: 'Hexploration parancsok', confirm: 'Kérjük, erősítse meg', }, discovery: { - title: 'Hely felfedezve', + title: 'Helyszín felfedezve', }, menu: { - draw: 'Rajzolj', - reveal: 'Felfedni és elrejteni', + draw: 'Rajzolás', + reveal: 'Felfedés és elrejtés', locations: 'Helyszínek', tools: 'Eszközök', - layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + layerInUse: 'Az új hatszögek ide kerülnek: {layer}.', pageSettingsHelp: 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', }, buttons: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', undo: 'Kitöltés visszavonása', - reveal: 'Felfedni', - conceal: 'Elrejteni', - explore: 'Fedezze fel', - revealPage: 'Oldal feltárása', + reveal: 'Felfedés', + conceal: 'Lefedés', + explore: 'Felderítés', + revealPage: 'Oldal felfedése', resetPage: 'Oldal visszaállítása', - mark: 'Hely megjelölése', - unmark: 'Törölje a jelölést', - name: 'Név Hex', - settings: 'Beállítások elemre', + mark: 'Helyszín megjelölése', + unmark: 'Jelölés törlése', + name: 'Hatszög elnevezése', + settings: 'Beállítások', pageSettings: 'Oldalbeállítások', status: 'Állapot', rescan: 'Újraszkennelés', - calibrate: 'Kalibrálni', + calibrate: 'Kalibrálás', calibrateReset: 'Kalibrálás visszaállítása', help: 'Segítség', - change: 'Változás', + change: 'Módosítás', menu: 'Menü', clearOverrides: 'Felülbírálások törlése', - confirmReset: 'Igen, távolítsa el az összes hexát', + confirmReset: 'Igen, minden hatszög eltávolítása', }, prompts: { name: 'Helynév (a törléshez hagyja üresen)', }, values: { - on: 'On', - off: 'Le', - none: 'Egyik sem', + on: 'Be', + off: 'Ki', + none: 'Nincs', hexLayer: { - auto: 'Automatikus (előtérben, ha elérhető)', - foreground: 'előtér réteg', - objects: 'token réteg', + auto: 'Automatikus (előtér, ha elérhető)', + foreground: 'előtérréteg', + objects: 'tokenréteg', }, revealBy: { players: 'Játékos tokenek', @@ -62,22 +62,22 @@ const TRANSLATION = { all: 'Minden token', }, revealMode: { - clear: 'Világos', + clear: 'Eltávolítás', glimpse: 'Bepillantás', }, announce: { all: 'Mindenki', - gm: 'Csak GM', - off: 'Le', + gm: 'Csak a GM', + off: 'Ki', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', - conceal: 'Elrejteni', + conceal: 'Lefedés', }, }, settings: { @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'A menük, üzenetek és tájékoztatók nyelve.', }, hexLayer: { - label: 'Hatlapos réteg', - desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + label: 'Hatszögek rétege', + desc: 'Hová kerülnek az új hatszögek. Az Automatikus az előtérréteggel próbálkozik (a tokenek fölött), és ha a játék ezt nem támogatja, a tokenréteget használja.', }, fillColor: { label: 'Kitöltés színe', @@ -102,15 +102,15 @@ const TRANSLATION = { desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + label: 'Bepillantás színe', + desc: 'Az a szín, amelyre a hatszögek bepillantáskor váltanak (Bepillantás felfedési mód). Használjon átlátszó rgba() színt.', }, strokeWidth: { - label: 'Határ szélessége', + label: 'Szegély szélessége', desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', }, maxDistance: { - label: 'Hex Reveal távolság', + label: 'Hatszögek felfedési távolsága', desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', }, revealDistance: { @@ -122,42 +122,42 @@ const TRANSLATION = { desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', }, revealPath: { - label: 'Fedezd fel az ösvényen', + label: 'Felfedés az útvonal mentén', desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', }, revealBy: { - label: 'Tokenek, amelyek felfedik', + label: 'Felfedő tokenek', desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', }, revealMode: { - label: 'Felfedezési mód', - desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + label: 'Felfedési mód', + desc: 'Az Eltávolítás mód eltávolítja a látótávolságon belüli hatszögeket. A Bepillantás mód ehelyett átlátszóvá teszi őket; akkor tűnnek el, amikor egy token belép beléjük.', }, announce: { - label: 'Hirdesse a felfedezéseket', + label: 'Felfedezések bejelentése', desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', }, pingDiscoveries: { - label: 'Ping felfedezések', + label: 'Felfedezések pingelése', desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', }, hideCoveredTokens: { - label: 'Fedett tokenek elrejtése', + label: 'Lefedett tokenek elrejtése', desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', }, }, status: { - engine: 'Játék motor', + engine: 'Játékmotor', grid: 'Rács', - layer: 'Hatlapos réteg', - hexes: 'Hexák', - named: 'Elnevezett hexák', - icons: 'Helyjelzők', - glimpsed: 'Megpillantott hatszögek', - pending: 'Betöltésre váró helyek', + layer: 'Hatszögek rétege', + hexes: 'Hatszögek', + named: 'Elnevezett hatszögek', + icons: 'Helyszíntokenek', + glimpsed: 'Bepillantott hatszögek', + pending: 'Kitöltésre váró helyszínek', calibrated: 'Kalibrálva', - overrides: 'Oldal felülbírálása', - undo: 'Visszavonás elérhető', + overrides: 'Oldalszintű felülbírálások', + undo: 'Visszavonható', }, messages: { filled: @@ -183,11 +183,11 @@ const TRANSLATION = { 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', migrated: - 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: - 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + 'Mentett hatszögek, amelyek már nem léteznek, és törlődtek a nyilvántartásból: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraszkennelést az oldalon, hogy újra felvegye a hatszögeit.', readyHint: - 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + 'A menühöz írja be a !hexploration parancsot, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', }, warnings: { foregroundUnavailable: @@ -198,7 +198,7 @@ const TRANSLATION = { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', notHex: 'Ez az oldal nem használ hatszögletű rácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', - emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', nothingToReveal: @@ -228,7 +228,7 @@ const TRANSLATION = { calibrateNeedsTokens: 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', calibrateFailed: - 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + 'A két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hex H) kell lennie, egymástól legalább egy hatszögnyire.', unexpected: 'A részletek az API-konzol naplójában találhatók.', }, help: { @@ -241,7 +241,7 @@ const TRANSLATION = { revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', conceal: 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', - explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', @@ -249,22 +249,20 @@ const TRANSLATION = { set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', pageClear: 'Távolítsa el az aktuális oldal felülírásait.', - rescan: - 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', - journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', help: 'Mutasd ezt a listát.', handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', }, deck: { - subtitle: 'Parancsnoki pakli', drawDesc: 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', revealDesc: - 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', toolsDesc: @@ -277,7 +275,7 @@ const TRANSLATION = { footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', - body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', }, quickStart: { @@ -285,8 +283,8 @@ const TRANSLATION = { steps: [ 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', - 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', - 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', + 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', ], }, @@ -300,29 +298,29 @@ const TRANSLATION = { revealing: { heading: 'Hogyan működik a feltárás', points: [ - 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', - 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', - 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', - 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', - 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel. Ha a Látóvonal be van kapcsolva, egy hatszög csak akkor fedődik fel, ha nincs közte és a token között lefedett hatszög.', + 'A Hatszögek felfedési távolsága a hatszögek megrajzolásakor kerül tárolásra rajtuk. Ezek a hatszögek csak ennyi hatszögnyi távolságon belülről fedhetők fel, bármilyen messzire lát is egy token. Hegyekhez vagy erdőkhöz használja, amelyek eltakarják, ami mögöttük van.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és akkor tűnnek el, amikor egy token belép beléjük.', + 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', + 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', ], }, locations: { heading: 'Hexák és helyek neve', points: [ - 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', - 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', - 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { heading: 'Beállítások elemre', intro: - 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', colKey: 'Kulcsfontosságú', colName: 'Beállítás', colDesc: 'Leírás', @@ -332,9 +330,9 @@ const TRANSLATION = { heading: 'Jumpgate és Legacy', points: [ 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', - 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', - 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', - 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', + 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', ], }, upgrading: { @@ -343,7 +341,7 @@ const TRANSLATION = { 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', - 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], colV1: '1-es verzió parancs', colV2: '2-es verzió parancs', @@ -351,23 +349,23 @@ const TRANSLATION = { troubleshooting: { heading: 'Hibaelhárítás', points: [ - 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, megfelel-e a Felfedő tokenek beállításnak, és vannak-e hatszögek az oldalon (!hexploration status).', 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', - 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', ], }, languages: { heading: 'Nyelvek', - body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + body: 'Nyelvet a !hexploration set language paranccsal választhat. Elérhető nyelvek:', colLanguage: 'Nyelv', - colNative: 'Natív név', + colNative: 'Saját név', colCode: 'Kód', }, credits: { heading: 'Kredit', - original: 'Eredeti mod által', + original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index a8bb9f69c4..e7f00a028c 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -1,42 +1,42 @@ const TRANSLATION = { titles: { - ready: "L'esplorazione è pronta.", - settings: 'Impostazioni di esplorazione', + ready: 'Hexploration è pronto.', + settings: 'Impostazioni di Hexploration', languages: 'Scegli una lingua', pageSettings: 'Impostazioni pagina: {page}', - status: 'Stato esplorazione: {page}', - help: 'Comandi di esplorazione', - confirm: 'Per favore conferma', + status: 'Stato di Hexploration: {page}', + help: 'Comandi di Hexploration', + confirm: 'Conferma', }, discovery: { title: 'Posizione scoperta', }, menu: { - draw: 'Disegno', - reveal: 'Rivelare e nascondere', + draw: 'Disegna', + reveal: 'Rivela e nascondi', locations: 'Posizioni', - tools: 'Utensili', - layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + tools: 'Strumenti', + layerInUse: 'I nuovi esagoni vengono disegnati sul {layer}.', pageSettingsHelp: 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', }, buttons: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', undo: 'Annulla riempimento', - reveal: 'Svelare', - conceal: 'Nascondere', - explore: 'Esplorare', + reveal: 'Rivela', + conceal: 'Nascondi', + explore: 'Esplora', revealPage: 'Rivela pagina', resetPage: 'Reimposta pagina', mark: 'Segna posizione', - unmark: 'Deseleziona', - name: 'Nome esadecimale', + unmark: 'Rimuovi segno', + name: 'Nomina esagono', settings: 'Impostazioni', - pageSettings: 'Impostazioni della pagina', + pageSettings: 'Impostazioni pagina', status: 'Stato', rescan: 'Nuova scansione', - calibrate: 'Calibrare', + calibrate: 'Calibra', calibrateReset: 'Ripristina calibrazione', help: 'Aiuto', change: 'Modifica', @@ -48,36 +48,36 @@ const TRANSLATION = { name: 'Nome della posizione (lascia vuoto per cancellare)', }, values: { - on: 'SU', - off: 'Spento', + on: 'Attivo', + off: 'Disattivo', none: 'Nessuno', hexLayer: { auto: 'Automatico (in primo piano se disponibile)', - foreground: 'strato di primo piano', - objects: 'strato di token', + foreground: 'livello in primo piano', + objects: 'livello dei segnalini', }, revealBy: { - players: 'Gettoni del giocatore', - characters: 'Segnalini personaggio', - all: 'Tutti i gettoni', + players: 'Segnalini dei giocatori', + characters: 'Segnalini dei personaggi', + all: 'Tutti i segnalini', }, revealMode: { - clear: 'Chiaro', - glimpse: 'Occhiata', + clear: 'Elimina', + glimpse: 'Intravedi', }, announce: { all: 'Tutti', - gm: 'Solo GM', - off: 'Spento', + gm: 'Solo il GM', + off: 'Disattivo', }, orientation: { - vertical: 'Esadecimale (V)', - horizontal: 'Esadecimale (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', - conceal: 'Nascondere', + conceal: 'Nascondi', }, }, settings: { @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Lingua per menu, messaggi e dispense.', }, hexLayer: { - label: 'Strato esagonale', - desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + label: 'Livello degli esagoni', + desc: 'Dove vengono disegnati i nuovi esagoni. Automatico prova il livello in primo piano (sopra i segnalini) e ripiega sul livello dei segnalini se il gioco non lo supporta.', }, fillColor: { label: 'Colore riempimento', - desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + desc: 'Colore dei nuovi esagoni. Usa rgba() per esagoni trasparenti, ad esempio rgba(0,0,0,0.8).', }, strokeColor: { label: 'Colore del bordo', @@ -102,19 +102,19 @@ const TRANSLATION = { desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', }, glimpseColor: { - label: 'Colore scorcio', - desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + label: 'Colore degli esagoni intravisti', + desc: 'Colore che assumono gli esagoni intravisti (modalità di rivelazione Intravedi). Usa un colore rgba() trasparente.', }, strokeWidth: { label: 'Larghezza del bordo', desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', }, maxDistance: { - label: 'Distanza di rivelazione esadecimale', + label: 'Distanza di rivelazione degli esagoni', desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', }, revealDistance: { - label: 'Distanza visiva', + label: 'Distanza di vista', desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', }, lineOfSight: { @@ -130,40 +130,40 @@ const TRANSLATION = { desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', }, revealMode: { - label: 'Modalità Rivela', - desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + label: 'Modalità di rivelazione', + desc: 'Elimina rimuove gli esagoni in vista. Intravedi invece li rende trasparenti; vengono rimossi quando un segnalino vi entra.', }, announce: { - label: 'Annunciare le scoperte', + label: 'Annuncia le scoperte', desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', }, pingDiscoveries: { - label: 'Scoperte del ping', + label: 'Ping sulle scoperte', desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', }, hideCoveredTokens: { - label: 'Nascondi i token coperti', + label: 'Nascondi i segnalini coperti', desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', }, }, status: { engine: 'Motore di gioco', grid: 'Griglia', - layer: 'Strato esagonale', + layer: 'Livello degli esagoni', hexes: 'Esagoni', named: 'Esagoni con nome', - icons: 'Gettoni di posizione', + icons: 'Segnalini di posizione', glimpsed: 'Esagoni intravisti', pending: 'Posizioni in attesa di riempimento', calibrated: 'Calibrato', - overrides: "La pagina esegue l'override", - undo: 'Annulla disponibile', + overrides: 'Sostituzioni di pagina', + undo: 'Annullamento disponibile', }, messages: { filled: 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', - revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', @@ -183,11 +183,11 @@ const TRANSLATION = { 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: - 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', pruned: - 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Nuova scansione sulla pagina per riprenderne gli esagoni.', readyHint: - 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + 'Digita !hexploration per il menu, oppure apri la dispensa "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -197,9 +197,9 @@ const TRANSLATION = { }, errors: { noPage: 'Impossibile trovare la pagina su cui lavorare.', - notHex: 'Questa pagina non utilizza una griglia esadecimale.', + notHex: 'Questa pagina non usa una griglia esagonale.', noPolygons: 'Seleziona una o più forme disegnate da riempire.', - emptyArea: "L'area selezionata non contiene centri esadecimali.", + emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', @@ -216,8 +216,7 @@ const TRANSLATION = { }, hints: { noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', - notHex: - 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + notHex: 'Imposta la griglia della pagina su Hex (V) o Hex (H) nelle Impostazioni pagina.', noPolygons: "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", emptyArea: @@ -228,7 +227,7 @@ const TRANSLATION = { unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: - 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', @@ -250,21 +249,20 @@ const TRANSLATION = { pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: - "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', - journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', handout: 'Le istruzioni complete si trovano nel volantino "{name}".', }, deck: { - subtitle: 'Mazzo di comando', drawDesc: - "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla riempimento annulla l'ultimo riempimento.", revealDesc: - 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', toolsDesc: @@ -285,9 +283,9 @@ const TRANSLATION = { steps: [ 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", - 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', - 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', - 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + 'Seleziona le forme e fai clic su Riempi nel Command Deck (oppure digita !hexploration fill). Le forme vengono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i segnalini dei luoghi importanti e fai clic su Segna posizione. Vengono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un segnalino giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di vista, vengono rivelati.', ], }, commands: { @@ -300,29 +298,29 @@ const TRANSLATION = { revealing: { heading: 'Come funziona la rivelazione', points: [ - 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', - 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', - 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', - "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", - 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + "La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con Linea di vista attiva, un esagono viene rivelato solo se in mezzo non c'è alcun esagono coperto.", + "La Distanza di rivelazione degli esagoni viene memorizzata sugli esagoni nel momento in cui vengono disegnati. Quegli esagoni vengono rivelati solo da non più di quel numero di esagoni di distanza, per quanto lontano possa vedere un segnalino. Usala per montagne o foreste che nascondono ciò che c'è dietro.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra.', + 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', + "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", ], }, locations: { heading: 'Esagoni e posizioni con nome', points: [ - 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', - "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", - "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], }, settings: { heading: 'Impostazioni', intro: - 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', colName: 'Collocamento', colDesc: 'Descrizione', @@ -332,18 +330,18 @@ const TRANSLATION = { heading: 'Jumpgate e Legacy', points: [ "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", - "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", - "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", - 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", + 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', ], }, upgrading: { heading: 'Aggiornamento dalla versione 1', points: [ 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', - 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'Le mappe a esagoni, i nomi, i segnalini di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', - 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + 'La versione 1 permetteva a qualsiasi segnalino che rappresentasse un personaggio di rivelare esagoni. Imposta Segnalini che rivelano su Segnalini dei personaggi per mantenere quel comportamento.', ], colV1: 'Comando della versione 1', colV2: 'Comando della versione 2', @@ -351,10 +349,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Risoluzione dei problemi', points: [ - 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', - 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', - 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', - "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Non succede nulla quando un segnalino si muove: controlla che il segnalino sia sul livello dei segnalini e corrisponda a Segnalini che rivelano, e che la pagina abbia esagoni (!hexploration status).', + 'Gli esagoni sono sfalsati rispetto alla griglia: usa Calibra, poi controlla con un segnalino su alcuni esagoni in vari punti della mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Nuova scansione sulla pagina.', + "Riempi indica che l'area non contiene centri di esagono: la forma deve contenere il centro di almeno un esagono.", 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', ], }, @@ -362,7 +360,7 @@ const TRANSLATION = { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", colLanguage: 'Lingua', - colNative: 'Nome nativo', + colNative: 'Nome originale', colCode: 'Codice', }, credits: { diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index e113b452ab..a48ea906bc 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -1,60 +1,60 @@ const TRANSLATION = { titles: { - ready: 'H探索の準備は完了です。', - settings: 'H探索設定', - languages: '言語を選択してください', + ready: 'Hexploration の準備ができました。', + settings: 'Hexploration 設定', + languages: '言語の選択', pageSettings: 'ページ設定: {page}', - status: 'H探索ステータス: {page}', - help: 'H探索コマンド', + status: 'Hexploration ステータス: {page}', + help: 'Hexploration コマンド', confirm: 'ご確認ください', }, discovery: { title: '場所が発見されました', }, menu: { - draw: '描く', + draw: '描画', reveal: '表示と非表示', - locations: '所在地', + locations: '場所', tools: 'ツール', layerInUse: '新しいヘクスが {layer} に描画されています。', pageSettingsHelp: 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', }, buttons: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', undo: '塗りつぶしを元に戻す', - reveal: '明らかにする', + reveal: '表示', conceal: '隠す', - explore: '探検する', - revealPage: 'ページを公開', + explore: '探索', + revealPage: 'ページを全表示', resetPage: 'ページをリセット', - mark: '位置をマークする', - unmark: 'マークを外す', - name: '名前の 16 進数', + mark: '場所としてマーク', + unmark: 'マーク解除', + name: 'ヘクスに名前を付ける', settings: '設定', pageSettings: 'ページ設定', - status: '状態', + status: 'ステータス', rescan: '再スキャン', - calibrate: '校正する', - calibrateReset: 'キャリブレーションをリセットする', + calibrate: '調整', + calibrateReset: '調整をリセット', help: 'ヘルプ', - change: '変化', + change: '変更', menu: 'メニュー', - clearOverrides: 'オーバーライドのクリア', - confirmReset: 'はい、すべてのヘクスを削除します', + clearOverrides: '上書きを解除', + confirmReset: 'はい、すべてのヘクスを削除', }, prompts: { name: '場所の名前 (クリアするには空白のままにします)', }, values: { - on: 'の上', + on: 'オン', off: 'オフ', none: 'なし', hexLayer: { - auto: '自動 (利用可能な場合は前景)', + auto: '自動（可能なら前景レイヤー）', foreground: '前景レイヤー', - objects: 'トークン層', + objects: 'トークンレイヤー', }, revealBy: { players: 'プレイヤートークン', @@ -62,21 +62,21 @@ const TRANSLATION = { all: 'すべてのトークン', }, revealMode: { - clear: 'クリア', - glimpse: '垣間見る', + clear: '除去', + glimpse: '透過', }, announce: { - all: 'みんな', + all: '全員', gm: 'GMのみ', off: 'オフ', }, orientation: { - vertical: 'ヘックス(V)', - horizontal: '六角(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', conceal: '隠す', }, }, @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'メニュー、メッセージ、配布資料の言語。', }, hexLayer: { - label: 'ヘックスレイヤー', - desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + label: 'ヘクスのレイヤー', + desc: '新しいヘクスを描画する場所。自動では前景レイヤー（トークンの上）を試し、ゲームが対応していない場合はトークンレイヤーを使用します。', }, fillColor: { label: '塗りつぶしの色', @@ -102,19 +102,19 @@ const TRANSLATION = { desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', }, glimpseColor: { - label: '垣間見える色', - desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + label: '透過色', + desc: '透過したときにヘクスが変わる色（表示モード「透過」）。半透明の rgba() カラーを使用してください。', }, strokeWidth: { label: '枠線の幅', desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', }, maxDistance: { - label: '16進数の表示距離', + label: 'ヘクスの公開距離', desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', }, revealDistance: { - label: '視距離', + label: '視界距離', desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', }, lineOfSight: { @@ -122,42 +122,42 @@ const TRANSLATION = { desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', }, revealPath: { - label: 'パスに沿って表示', + label: '経路に沿って表示', desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', }, revealBy: { - label: '明らかにするトークン', - desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + label: '公開するトークン', + desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { - label: 'リビールモード', - desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + label: '公開モード', + desc: '除去は視界内のヘクスを取り除きます。透過は代わりにヘクスを半透明にし、トークンが入ると取り除きます。', }, announce: { - label: '発見の発表', + label: '発見を通知', desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', }, pingDiscoveries: { - label: 'Ping の発見', + label: '発見地点をピン', desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', }, hideCoveredTokens: { - label: 'カバーされたトークンを非表示にする', + label: '覆われたトークンを隠す', desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', }, }, status: { engine: 'ゲームエンジン', grid: 'グリッド', - layer: 'ヘックスレイヤー', + layer: 'ヘクスレイヤー', hexes: 'ヘクス', named: '名前付きヘクス', - icons: '位置トークン', - glimpsed: '垣間見えるヘクス', - pending: '埋まりを待っている場所', - calibrated: '校正済み', + icons: '場所トークン', + glimpsed: '透過中のヘクス', + pending: '塗りつぶし待ちの場所', + calibrated: '調整済み', overrides: 'ページの上書き', - undo: '元に戻すことが可能', + undo: '元に戻せる操作', }, messages: { filled: @@ -165,7 +165,7 @@ const TRANSLATION = { revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', @@ -183,11 +183,11 @@ const TRANSLATION = { 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: - 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + 'メニューを開くには !hexploration と入力するか、配布資料 "Hexploration - Command Deck" を開きます。', }, warnings: { foregroundUnavailable: @@ -197,7 +197,7 @@ const TRANSLATION = { }, errors: { noPage: '作業するページが見つかりませんでした。', - notHex: 'このページでは 16 進グリッドは使用されていません。', + notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', emptyArea: '選択した領域には六角中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', @@ -216,7 +216,7 @@ const TRANSLATION = { }, hints: { noPage: '作業したいページを開くか、ページ上で何かを選択します。', - notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + notHex: 'ページ設定でページのグリッドを Hex (V) または Hex (H) に設定してください。', noPolygons: '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', @@ -225,9 +225,9 @@ const TRANSLATION = { unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', calibrateNeedsTokens: - 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + 'トークンをヘクスの中心にスナップして選択します。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにスナップした 2 つ目のトークンも選択すると、ヘクスのサイズも補正されます。', calibrateFailed: - '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + '2 つのトークンは同じ行 (Hex V) または同じ列 (Hex H) にあり、少なくとも 1 ヘクス離れている必要があります。', unexpected: '詳細は API コンソールのログに記載されています。', }, help: { @@ -246,21 +246,20 @@ const TRANSLATION = { set: '設定を変更するか、すべての設定を表示します。', pageSet: '現在のページでのみ公開設定をオーバーライドします。', pageClear: '現在のページのオーバーライドを削除します。', - rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', - journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + journal: 'ヘルプと Command Deck の配布資料を再構築します。', help: 'このリストを表示します。', handout: '完全な手順は配布資料「{name}」に記載されています。', }, deck: { - subtitle: 'コマンドデッキ', drawDesc: - '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + '領域の周囲に図形を描き、選択して塗りつぶします。「塗りつぶしを元に戻す」で最後の塗りつぶしを取り消せます。', revealDesc: - 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', @@ -268,21 +267,21 @@ const TRANSLATION = { }, handout: { versionLabel: 'バージョン', - subtitle: 'Roll20 のヘックスごとの探索', + subtitle: 'Roll20 のヘクスごとの探索', footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', overview: { heading: '概要', - body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + body: 'Hexploration は、ヘクスマップを不透明なヘクスで覆います。パーティが移動すると、通過したヘクス（必要に応じてその周囲のヘクスも）が取り除かれ、マップが 1 ヘクスずつ明らかになります。隠し場所をヘクスの下に配置でき、見つかるとアナウンスされます。Jumpgate と Legacy の両方のゲームで、任意のサイズの Hex (V) および Hex (H) グリッドで動作します。', demo: '短いデモを見る (バージョン 1 から)', }, quickStart: { heading: 'クイックスタート', steps: [ - 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + 'グリッドが Hex (V) または Hex (H) に設定されたページを開きます。', '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', - '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', - 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', - 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + '図形を選択し、Command Deck の「塗りつぶし」をクリックします（または !hexploration fill と入力します）。図形がヘクスに置き換わります。', + '任意: 塗りつぶす前に、重要な場所のトークンを選択して「場所としてマーク」をクリックします。それらはヘクスの下に隠され、発見されるとアナウンスされます。', + 'プレイヤートークンを移動します。通過したすべてのヘクスと、その視界距離内のヘクスが表示されます。', ], }, commands: { @@ -295,40 +294,40 @@ const TRANSLATION = { revealing: { heading: '暴露の仕組み', points: [ - 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', - 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', - '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', - 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', - 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', + 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを表示します。「視線」がオンの場合、間に覆われたヘクスがないときだけヘクスが表示されます。', + '「ヘクスの公開距離」は、ヘクスを描画するときにそのヘクスに保存されます。それらのヘクスは、トークンがどれだけ遠くまで見えても、その数のヘクス以内からしか表示されません。背後を隠す山や森に使用します。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。', + 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', + 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', ], }, locations: { heading: '名前付きヘクスと場所', points: [ - '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', - 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', - '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], }, settings: { heading: '設定', intro: - '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', colKey: '鍵', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', }, jumpgate: { - heading: 'ジャンプゲートとレガシー', + heading: 'Jumpgate と Legacy', points: [ 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', - 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', - 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + '「ヘクスのレイヤー」が「自動」の場合、ヘクスは前景レイヤー（トークンの上）に描画されるため、プレイヤーはその下にあるものを見ることができません。前景レイヤーが使用できない場合は、代わりにトークンレイヤーが使用されます。', + 'Jumpgate は数学的に正確な正六角形のヘクスを描画するため、Legacy のヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃わない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにある 2 つのトークンを選択すると、ヘクスのサイズも補正されます。', 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', ], }, @@ -336,9 +335,9 @@ const TRANSLATION = { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', - 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], colV1: 'バージョン1のコマンド', colV2: 'バージョン 2 コマンド', @@ -346,10 +345,10 @@ const TRANSLATION = { troubleshooting: { heading: 'トラブルシューティング', points: [ - 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', - 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', - 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', - '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'トークンを動かしても何も起こらない: トークンがトークンレイヤー上にあり「公開するトークン」の設定に合っていること、ページにヘクスがあること（!hexploration status）を確認してください。', + 'ヘクスがグリッドからずれている: 「調整」を使い、マップ上のいくつかのヘクスにトークンを置いて確認してください。', + 'ページまたはゲームをコピーした後、ヘクスが表示されなくなりました。ページで再スキャンを実行してください。', + '「塗りつぶし」で領域にヘクスの中心がないと表示される: 図形には少なくとも 1 つのヘクスの中心が含まれている必要があります。', 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', ], }, @@ -357,12 +356,12 @@ const TRANSLATION = { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', colLanguage: '言語', - colNative: 'ネイティブネーム', + colNative: '現地語での名称', colCode: 'コード', }, credits: { heading: 'クレジット', - original: 'オリジナルMODによる', + original: 'オリジナル版の作者', maintainer: 'バージョン 2 の保守者', marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', support: diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index bf220ce239..10cfcc3047 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -1,18 +1,18 @@ const TRANSLATION = { titles: { - ready: '탐색이 준비되었습니다.', - settings: '탐색 설정', - languages: '언어를 선택하세요', + ready: 'Hexploration이 준비되었습니다.', + settings: 'Hexploration 설정', + languages: '언어 선택', pageSettings: '페이지 설정: {page}', - status: '탐색 상태: {page}', - help: '탐색 명령', + status: 'Hexploration 상태: {page}', + help: 'Hexploration 명령어', confirm: '확인해주세요', }, discovery: { - title: '발견된 위치', + title: '위치 발견', }, menu: { - draw: '그리다', + draw: '그리기', reveal: '공개 및 숨기기', locations: '위치', tools: '도구', @@ -21,35 +21,35 @@ const TRANSLATION = { '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', }, buttons: { - fill: '채우다', - fillInverse: '역 채우기', - undo: '채우기 실행 취소', - reveal: '드러내다', - conceal: '숨기다', - explore: '탐구하다', - revealPage: '페이지 공개', - resetPage: '페이지 재설정', + fill: '채우기', + fillInverse: '반전 채우기', + undo: '채우기 취소', + reveal: '공개', + conceal: '숨기기', + explore: '탐색', + revealPage: '페이지 전체 공개', + resetPage: '페이지 초기화', mark: '위치 표시', unmark: '표시 해제', - name: '이름 헥스', + name: '헥스 이름 지정', settings: '설정', pageSettings: '페이지 설정', status: '상태', rescan: '다시 스캔', - calibrate: '교정', - calibrateReset: '교정 재설정', - help: '돕다', - change: '변화', + calibrate: '보정', + calibrateReset: '보정 초기화', + help: '도움말', + change: '변경', menu: '메뉴', clearOverrides: '재정의 지우기', - confirmReset: '예, 모든 16진수를 제거합니다.', + confirmReset: '예, 모든 헥스 제거', }, prompts: { name: '위치 이름(지우려면 비워 두세요)', }, values: { - on: '~에', - off: '끄다', + on: '켜짐', + off: '꺼짐', none: '없음', hexLayer: { auto: '자동(사용 가능한 경우 전경)', @@ -62,22 +62,22 @@ const TRANSLATION = { all: '모든 토큰', }, revealMode: { - clear: '분명한', - glimpse: '일견', + clear: '제거', + glimpse: '반투명', }, announce: { - all: '모든 사람', + all: '모두', gm: 'GM 전용', - off: '끄다', + off: '꺼짐', }, orientation: { - vertical: '16진수(V)', - horizontal: '16진수(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '채우다', - fillInverse: '역 채우기', - conceal: '숨기다', + fill: '채우기', + fillInverse: '반전 채우기', + conceal: '숨기기', }, }, settings: { @@ -86,12 +86,12 @@ const TRANSLATION = { desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', }, hexLayer: { - label: '육각 레이어', - desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + label: '헥스 레이어', + desc: '새 헥스를 그릴 위치입니다. 자동은 전경 레이어(토큰 위)를 먼저 시도하고, 게임이 지원하지 않으면 토큰 레이어를 사용합니다.', }, fillColor: { label: '채우기 색상', - desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + desc: '새 헥스의 색상입니다. 비쳐 보이는 헥스를 원하면 rgba()를 사용하세요(예: rgba(0,0,0,0.8)).', }, strokeColor: { label: '테두리 색상', @@ -102,19 +102,19 @@ const TRANSLATION = { desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', }, glimpseColor: { - label: '미리보기 색상', - desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + label: '반투명 색상', + desc: '반투명 상태가 된 헥스의 색상입니다(반투명 공개 모드). 비쳐 보이는 rgba() 색상을 사용하세요.', }, strokeWidth: { label: '테두리 너비', desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', }, maxDistance: { - label: '16진수 공개 거리', + label: '헥스 공개 거리', desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', }, revealDistance: { - label: '시거리', + label: '시야 거리', desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', }, lineOfSight: { @@ -126,36 +126,36 @@ const TRANSLATION = { desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', }, revealBy: { - label: '공개되는 토큰', - desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + label: '공개하는 토큰', + desc: '토큰 레이어의 어떤 토큰이 헥스를 공개할지 정합니다: 플레이어가 조종하는 토큰, 캐릭터를 나타내는 토큰 또는 모든 토큰.', }, revealMode: { label: '공개 모드', - desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + desc: '제거는 시야 안의 헥스를 없앱니다. 반투명은 대신 헥스를 비쳐 보이게 하며, 토큰이 들어가면 제거합니다.', }, announce: { - label: '발견 발표', + label: '발견 알림', desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', }, pingDiscoveries: { - label: '핑 발견', + label: '발견 위치 핑', desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', }, hideCoveredTokens: { - label: '적용 토큰 숨기기', - desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + label: '덮인 토큰 숨기기', + desc: 'Roll20은 이름, 막대, 오라를 헥스 위에 그립니다. 켜져 있으면 덮인 헥스 아래에 있는 토큰의 플레이어에게 보이는 이름, 막대, 오라를 끄고, 덮개가 벗겨지면 다시 켭니다.', }, }, status: { engine: '게임 엔진', grid: '그리드', - layer: '육각층', + layer: '헥스 레이어', hexes: '헥스', named: '명명된 헥스', icons: '위치 토큰', - glimpsed: '살짝 엿본 육각형', + glimpsed: '반투명 헥스', pending: '채우기를 기다리는 위치', - calibrated: '교정됨', + calibrated: '보정됨', overrides: '페이지 재정의', undo: '실행 취소 가능', }, @@ -163,16 +163,16 @@ const TRANSLATION = { filled: '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', revealed: '공개된 헥스: {count}.', - revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + revealedPage: '페이지의 모든 헥스를 공개했습니다({count}).', confirmReset: - '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', - resetPage: '페이지에서 제거된 16진수: {count}.', + '"{page}"의 모든 헥스({count})를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 이 작업은 실행 취소로 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거한 헥스: {count}.', undone: - '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + '마지막 채우기를 취소했습니다. 제거한 헥스: {removed}. 원래 스타일로 복원한 헥스: {restored}.', named: '"{name}"이라는 헥스: {count}.', unnamed: '지워진 이름: {count}.', marked: - '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + '기존 헥스 아래에 숨긴 위치: {attached}. 이 위치를 덮을 다음 채우기를 기다리는 위치: {pending}.', unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: @@ -183,10 +183,11 @@ const TRANSLATION = { '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: - 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', pruned: - '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', - readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + '더 이상 존재하지 않아 잊어버린 저장된 헥스: {dropped}. 이 게임이나 페이지를 복사했다면 해당 페이지에서 다시 스캔을 실행해 헥스를 다시 인식시키세요.', + readyHint: + '메뉴를 보려면 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 여세요.', }, warnings: { foregroundUnavailable: @@ -197,7 +198,7 @@ const TRANSLATION = { noPage: '작업할 페이지를 찾을 수 없습니다.', notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', - emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', @@ -214,18 +215,18 @@ const TRANSLATION = { }, hints: { noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', - notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + notHex: '페이지 설정에서 페이지 격자를 Hex (V) 또는 Hex (H)로 설정하세요.', noPolygons: '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', - unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', - unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: - '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + '토큰 하나를 헥스 중심에 스냅한 뒤 선택하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 스냅한 두 번째 토큰도 선택하면 헥스 크기까지 보정합니다.', calibrateFailed: - '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + '두 토큰은 같은 행(Hex V) 또는 같은 열(Hex H)에 있어야 하며, 적어도 헥스 한 칸 이상 떨어져 있어야 합니다.', unexpected: '세부정보는 API 콘솔 로그에 있습니다.', }, help: { @@ -234,53 +235,51 @@ const TRANSLATION = { fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', - revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', - conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', - resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + resetPage: '페이지의 모든 헥스를 제거합니다(먼저 확인합니다).', name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', set: '설정을 변경하거나 모든 설정을 표시합니다.', pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', pageClear: '현재 페이지의 재정의를 제거합니다.', - rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', - calibrate: - '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + rescan: '페이지의 헥스 목록을 다시 만듭니다. 예를 들어 페이지나 게임을 복사한 뒤에 사용합니다.', + calibrate: '헥스 중심에 스냅된 토큰 한두 개를 선택해 헥스 격자를 맞춥니다.', calibrateReset: '현재 페이지의 보정을 제거합니다.', - status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', - journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + status: '현재 페이지에 대해 Hexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 Command Deck 유인물을 다시 만듭니다.', help: '이 목록을 보여주세요.', handout: '전체 지침은 "{name}" 유인물에 있습니다.', }, deck: { - subtitle: '커맨드 덱', drawDesc: - '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + '영역 주위에 도형을 그리고 선택한 다음 채웁니다. 채우기 취소는 마지막 채우기를 되돌립니다.', revealDesc: - '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + '헥스, 도형 또는 토큰을 선택해 공개하거나 다시 덮습니다. 탐색은 선택한 토큰이 그곳으로 막 이동한 것처럼 주변을 공개합니다.', locationsDesc: - '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + '토큰을 선택해 헥스 아래의 위치로 숨기세요. 헥스나 토큰을 선택해 헥스에 이름을 붙이세요.', toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', footer: '전체 지침은 "{help}" 유인물을 참조하세요.', }, handout: { versionLabel: '버전', - subtitle: 'Roll20의 16진수 탐색', + subtitle: 'Roll20용 헥스 단위 탐험', footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', overview: { heading: '개요', - body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + body: 'Hexploration은 헥스 지도를 불투명한 헥스로 덮습니다. 파티가 이동하면 지나간 헥스(원하면 주변 헥스도)가 제거되어 지도가 한 헥스씩 드러납니다. 숨겨진 위치를 헥스 아래에 둘 수 있으며, 발견되면 알려줍니다. Jumpgate와 Legacy 게임 모두에서, 모든 크기의 Hex (V) 및 Hex (H) 그리드에서 작동합니다.', demo: '짧은 데모 보기(버전 1부터)', }, quickStart: { heading: '빠른 시작', steps: [ - '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '격자가 Hex (V) 또는 Hex (H)로 설정된 페이지를 엽니다.', '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', - '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', - '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', - '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !hexploration fill 입력). 모양이 헥스로 바뀝니다.', + '선택 사항: 채우기 전에 중요한 장소의 토큰을 선택하고 위치 표시를 클릭하세요. 토큰은 헥스 아래에 숨겨지고 발견되면 알려집니다.', + '플레이어 토큰을 움직입니다. 토큰이 지나가는 모든 헥스와 시야 거리 안의 헥스가 공개됩니다.', ], }, commands: { @@ -293,40 +292,40 @@ const TRANSLATION = { revealing: { heading: '공개 작동 방식', points: [ - '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', - 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', - 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + '헥스 공개 거리는 헥스를 그릴 때 그 헥스에 저장됩니다. 그런 헥스는 토큰이 얼마나 멀리 볼 수 있든 그 헥스 수 이내에서만 공개됩니다. 뒤에 있는 것을 가리는 산이나 숲에 사용하세요.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다.', + 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { heading: '명명된 육각형 및 위치', points: [ - 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', - 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', - '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', ], }, settings: { heading: '설정', intro: - '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', colKey: '열쇠', colName: '환경', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, jumpgate: { - heading: '점프게이트와 레거시', + heading: 'Jumpgate와 Legacy', points: [ - 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', - 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', - 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + 'Hexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 어느 편집기에서 그린 도형이든 채울 수 있습니다.', + '헥스 레이어를 자동으로 설정하면 헥스가 토큰 위의 전경 레이어에 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없으면 대신 토큰 레이어를 사용합니다.', + 'Jumpgate는 수학적으로 정확한 정육각형 헥스를 그리므로 Legacy 헥스와 모양이 약간 다릅니다. 헥스가 페이지 격자와 맞지 않으면 토큰 하나를 헥스 중심에 스냅하고 선택한 뒤 보정을 클릭하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 있는 토큰 두 개를 선택하면 헥스 크기까지 보정합니다.', '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', ], }, @@ -334,9 +333,9 @@ const TRANSLATION = { heading: '버전 1에서 업그레이드', points: [ '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', - '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', - 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', - '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + '기존 헥스 지도, 이름, 위치 토큰과 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Hexploration_menu 매크로를 포함한 버전 1 명령은 여전히 작동합니다.', + '버전 1에서는 캐릭터를 나타내는 토큰이면 무엇이든 헥스를 공개할 수 있었습니다. 이 동작을 유지하려면 공개하는 토큰을 캐릭터 토큰으로 설정하세요.', ], colV1: '버전 1 명령', colV2: '버전 2 명령', @@ -344,23 +343,23 @@ const TRANSLATION = { troubleshooting: { heading: '문제 해결', points: [ - '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', - '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', - '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', - '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '토큰을 움직여도 아무 일도 일어나지 않음: 토큰이 토큰 레이어에 있고 공개하는 토큰 설정과 일치하는지, 페이지에 헥스가 있는지(!hexploration status) 확인하세요.', + '헥스가 격자에서 어긋남: 보정을 사용한 다음, 지도 곳곳의 몇몇 헥스에 토큰을 놓아 확인하세요.', + '페이지나 게임을 복사한 뒤 헥스가 더 이상 공개되지 않음: 해당 페이지에서 다시 스캔을 실행하세요.', + '채우기에서 영역에 헥스 중심이 없다고 나옴: 모양 안에 적어도 헥스 하나의 중심이 들어 있어야 합니다.', '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', ], }, languages: { heading: '언어', - body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', - colNative: '본명', + colNative: '현지어 이름', colCode: '암호', }, credits: { heading: '크레딧', - original: '원본 모드 작성자:', + original: '원본 모드 제작자', maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', support: diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index 844a1aa91e..ec2302f68c 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -1,11 +1,11 @@ const TRANSLATION = { titles: { - ready: 'Hexploratie is klaar.', - settings: 'Hexploratie-instellingen', + ready: 'Hexploration is klaar.', + settings: 'Hexploration-instellingen', languages: 'Kies een taal', pageSettings: 'Pagina-instellingen: {page}', - status: 'Hverkenningsstatus: {page}', - help: 'Hexploratie-opdrachten', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdrachten', confirm: 'Bevestig alstublieft', }, discovery: { @@ -16,7 +16,7 @@ const TRANSLATION = { reveal: 'Onthullen en verbergen', locations: 'Locaties', tools: 'Hulpmiddelen', - layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + layerInUse: 'Nieuwe zeshoeken worden getekend op de {layer}.', pageSettingsHelp: 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', }, @@ -25,44 +25,44 @@ const TRANSLATION = { fillInverse: 'Omgekeerde vulling', undo: 'Vulling ongedaan maken', reveal: 'Onthullen', - conceal: 'Maskeren', - explore: 'Ontdekken', + conceal: 'Verbergen', + explore: 'Verkennen', revealPage: 'Pagina onthullen', resetPage: 'Pagina opnieuw instellen', - mark: 'Markeer locatie', + mark: 'Locatie markeren', unmark: 'Markering opheffen', - name: 'Naam Hex', + name: 'Zeshoek benoemen', settings: 'Instellingen', pageSettings: 'Pagina-instellingen', status: 'Status', rescan: 'Opnieuw scannen', calibrate: 'Kalibreren', calibrateReset: 'Kalibratie opnieuw instellen', - help: 'Hulp', - change: 'Wijziging', + help: 'Help', + change: 'Wijzigen', menu: 'Menu', - clearOverrides: 'Wis overschrijvingen', - confirmReset: 'Ja, verwijder alle vakjes', + clearOverrides: 'Overschrijvingen wissen', + confirmReset: 'Ja, verwijder alle zeshoeken', }, prompts: { name: 'Locatienaam (leeg laten om te wissen)', }, values: { - on: 'Op', + on: 'Aan', off: 'Uit', none: 'Geen', hexLayer: { auto: 'Automatisch (voorgrond indien beschikbaar)', - foreground: 'voorgrond laag', - objects: 'token laag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Spelerfiches', - characters: 'Karakterfiches', + players: 'Spelertokens', + characters: 'Personagetokens', all: 'Alle tokens', }, revealMode: { - clear: 'Duidelijk', + clear: 'Wissen', glimpse: 'Glimp', }, announce: { @@ -71,13 +71,13 @@ const TRANSLATION = { off: 'Uit', }, orientation: { - vertical: 'Zeskant (V)', - horizontal: 'Zeskant (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vullen', fillInverse: 'Omgekeerde vulling', - conceal: 'Maskeren', + conceal: 'Verbergen', }, }, settings: { @@ -86,8 +86,8 @@ const TRANSLATION = { desc: "Taal voor menu's, berichten en hand-outs.", }, hexLayer: { - label: 'Hex-laag', - desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + label: 'Laag voor zeshoeken', + desc: 'Waar nieuwe zeshoeken worden getekend. Automatisch probeert de voorgrondlaag (boven tokens) en valt terug op de tokenlaag als het spel die niet ondersteunt.', }, fillColor: { label: 'Vulkleur', @@ -98,23 +98,23 @@ const TRANSLATION = { desc: 'Kleur van de omtrek van nieuwe vakjes.', }, labelColor: { - label: 'Etiketkleur', + label: 'Labelkleur', desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', }, glimpseColor: { - label: 'Glimp kleur', - desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + label: 'Glimpkleur', + desc: 'Kleur die zeshoeken krijgen wanneer er een glimp van wordt opgevangen (onthullingsmodus Glimp). Gebruik een doorzichtige rgba()-kleur.', }, strokeWidth: { label: 'Randbreedte', desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', }, maxDistance: { - label: 'Hex onthullen afstand', + label: 'Onthullingsafstand van zeshoeken', desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', }, revealDistance: { - label: 'Zicht afstand', + label: 'Zichtafstand', desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', }, lineOfSight: { @@ -122,7 +122,7 @@ const TRANSLATION = { desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', }, revealPath: { - label: 'Onthul langs het pad', + label: 'Onthullen langs pad', desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { @@ -131,30 +131,30 @@ const TRANSLATION = { }, revealMode: { label: 'Onthullingsmodus', - desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + desc: 'Wissen verwijdert zeshoeken binnen het zicht. Glimp maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer een token ze betreedt.', }, announce: { label: 'Ontdekkingen aankondigen', desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', }, pingDiscoveries: { - label: 'Ping-ontdekkingen', + label: 'Ontdekkingen pingen', desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { - label: 'Verberg afgedekte tokens', + label: 'Bedekte tokens verbergen', desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { engine: 'Game-engine', grid: 'Rooster', - layer: 'Hex-laag', - hexes: 'Hexen', - named: 'Genoemde hexen', - icons: 'Locatiefiches', - glimpsed: 'Glimp van hexen', - pending: 'Locaties die wachten op vulling', + layer: 'Laag voor zeshoeken', + hexes: 'Zeshoeken', + named: 'Benoemde zeshoeken', + icons: 'Locatietokens', + glimpsed: 'Doorzichtige zeshoeken', + pending: 'Locaties die op een vulling wachten', calibrated: 'Gekalibreerd', overrides: 'Pagina-overschrijvingen', undo: 'Ongedaan maken beschikbaar', @@ -183,11 +183,11 @@ const TRANSLATION = { 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: - 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', pruned: - 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + 'Opgeslagen zeshoeken die niet meer bestaan en zijn vergeten: {dropped}. Als dit spel of deze pagina is gekopieerd, voer dan Opnieuw scannen uit op de pagina om de zeshoeken weer op te pikken.', readyHint: - 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + 'Typ !hexploration voor het menu, of open de hand-out "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -249,21 +249,20 @@ const TRANSLATION = { pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', rescan: - 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', - journal: 'Herbouw de Help- en Command Deck-hand-outs.', + journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', help: 'Laat deze lijst zien.', handout: 'Volledige instructies vindt u in de hand-out "{name}".', }, deck: { - subtitle: 'Commandodek', drawDesc: - 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + 'Teken vormen rond een gebied, selecteer ze en vul ze dan. Vulling ongedaan maken draait de laatste vulling terug.', revealDesc: - 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', toolsDesc: @@ -284,9 +283,9 @@ const TRANSLATION = { steps: [ 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', - 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', - 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', - 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + 'Selecteer de vormen en klik in het Command Deck op Vullen (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze worden verborgen onder de zeshoeken en aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelertoken. Elke zeshoek waar het doorheen gaat, en de zeshoeken binnen zijn Zichtafstand, worden onthuld.', ], }, commands: { @@ -299,29 +298,29 @@ const TRANSLATION = { revealing: { heading: 'Hoe onthullen werkt', points: [ - 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', - "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", - 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', - 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', - 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken. Als Zichtlijn aan staat, wordt een zeshoek alleen onthuld als er geen bedekte zeshoek tussen ligt.', + 'Onthullingsafstand van zeshoeken wordt bij het tekenen in de zeshoeken opgeslagen. Die zeshoeken worden alleen onthuld vanaf hooguit zoveel zeshoeken afstand, hoe ver een token ook kan kijken. Gebruik dit voor bergen of bossen die verbergen wat erachter ligt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt.', + 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', + 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', ], }, locations: { heading: 'Genoemde velden en locaties', points: [ - 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', - 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', - 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], }, settings: { heading: 'Instellingen', intro: - 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Laag voor zeshoeken, Tokens die onthullen en Taal kunnen ook worden ingesteld op de instellingenpagina van de mod.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beschrijving', @@ -331,18 +330,18 @@ const TRANSLATION = { heading: 'Jumpgate en erfenis', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', - 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', - 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', - "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige zeshoeken, die een iets andere vorm hebben dan Legacy-zeshoeken. Als de zeshoeken niet samenvallen met het raster van een pagina, zet dan een token vast op het midden van een zeshoek, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende zeshoeken van dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', + 'Wanneer een pagina of spel wordt gekopieerd, krijgen de zeshoeken nieuwe ID’s. Voer Opnieuw scannen uit op de pagina om ze weer op te pikken, samen met hun naamlabels en locatietokens.', ], }, upgrading: { heading: 'Upgraden vanaf versie 1', points: [ 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', - 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'Bestaande hexkaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch bijgewerkt.', 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', - 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + 'In versie 1 kon elk token dat een personage voorstelde zeshoeken onthullen. Stel Tokens die onthullen in op Personagetokens om dat gedrag te behouden.', ], colV1: 'Versie 1-opdracht', colV2: 'Versie 2-opdracht', @@ -350,10 +349,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Problemen oplossen', points: [ - 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', - 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', - 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', - 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Er gebeurt niets wanneer een token beweegt: controleer of het token op de tokenlaag staat en overeenkomt met Tokens die onthullen, en of de pagina zeshoeken heeft (!hexploration status).', + 'Zeshoeken zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer daarna met een token op een paar zeshoeken verspreid over de kaart.', + 'Zeshoeken worden niet meer onthuld na het kopiëren van een pagina of spel: voer Opnieuw scannen uit op de pagina.', + 'Vullen meldt dat het gebied geen middelpunten van zeshoeken bevat: de vorm moet het middelpunt van ten minste één zeshoek bevatten.', 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', ], }, @@ -361,7 +360,7 @@ const TRANSLATION = { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Eigen naam', colCode: 'Code', }, credits: { diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index ae6fb85d64..0584777824 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -1,83 +1,83 @@ const TRANSLATION = { titles: { - ready: 'Heksploracja jest gotowa.', - settings: 'Ustawienia Heksploracji', + ready: 'Hexploration jest gotowy.', + settings: 'Ustawienia Hexploration', languages: 'Wybierz język', pageSettings: 'Ustawienia strony: {page}', - status: 'Stan heksploracji: {page}', - help: 'Komendy Heksploracji', + status: 'Stan Hexploration: {page}', + help: 'Polecenia Hexploration', confirm: 'Proszę potwierdzić', }, discovery: { - title: 'Lokalizacja odkryta', + title: 'Odkryto lokalizację', }, menu: { - draw: 'Rysować', - reveal: 'Odkryj i ukryj', + draw: 'Rysowanie', + reveal: 'Odkrywanie i ukrywanie', locations: 'Lokalizacje', tools: 'Narzędzia', - layerInUse: 'Nowe heksy są rysowane na {layer}.', + layerInUse: 'Warstwa, na której rysowane są nowe heksy: {layer}.', pageSettingsHelp: 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', }, buttons: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', undo: 'Cofnij wypełnienie', - reveal: 'Ujawnić', - conceal: 'Ukryć', - explore: 'Badać', + reveal: 'Odkryj', + conceal: 'Zakryj', + explore: 'Eksploruj', revealPage: 'Odkryj stronę', resetPage: 'Zresetuj stronę', - mark: 'Zaznacz lokalizację', - unmark: 'Odznacz', - name: 'Imię Hex', + mark: 'Oznacz lokalizację', + unmark: 'Usuń oznaczenie', + name: 'Nazwij heks', settings: 'Ustawienia', pageSettings: 'Ustawienia strony', status: 'Status', rescan: 'Skanuj ponownie', - calibrate: 'Kalibrować', + calibrate: 'Kalibruj', calibrateReset: 'Zresetuj kalibrację', help: 'Pomoc', - change: 'Zmiana', + change: 'Zmień', menu: 'Menu', - clearOverrides: 'Wyczyść zastąpienia', + clearOverrides: 'Usuń nadpisania', confirmReset: 'Tak, usuń wszystkie heksy', }, prompts: { name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', }, values: { - on: 'NA', - off: 'Wyłączony', - none: 'Nic', + on: 'Włączone', + off: 'Wyłączone', + none: 'Brak', hexLayer: { auto: 'Auto (pierwszy plan, jeśli jest dostępny)', foreground: 'warstwa pierwszego planu', - objects: 'warstwa tokenów', + objects: 'warstwa żetonów', }, revealBy: { players: 'Żetony graczy', characters: 'Żetony postaci', - all: 'Wszystkie tokeny', + all: 'Wszystkie żetony', }, revealMode: { - clear: 'Jasne', - glimpse: 'Dojrzeć', + clear: 'Usuwanie', + glimpse: 'Przebłysk', }, announce: { all: 'Wszyscy', - gm: "Tylko GM'a", - off: 'Wyłączony', + gm: 'Tylko MG', + off: 'Wyłączone', }, orientation: { - vertical: 'Sześciokąt (V)', - horizontal: 'Sześciokąt (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', - conceal: 'Ukryć', + conceal: 'Zakryj', }, }, settings: { @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa szesnastkowa', - desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + label: 'Warstwa heksagonów', + desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { label: 'Kolor wypełnienia', @@ -103,18 +103,18 @@ const TRANSLATION = { }, glimpseColor: { label: 'Kolor przebłysku', - desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + desc: 'Kolor, jaki przyjmują heksy objęte przebłyskiem (tryb odkrywania Przebłysk). Użyj przezroczystego koloru rgba().', }, strokeWidth: { label: 'Szerokość obramowania', desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość ujawnienia heksadecymalnego', + label: 'Odległość odkrywania heksagonów', desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', }, revealDistance: { - label: 'Odległość wzroku', + label: 'Zasięg wzroku', desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', }, lineOfSight: { @@ -122,42 +122,42 @@ const TRANSLATION = { desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', }, revealPath: { - label: 'Odkryj wzdłuż ścieżki', + label: 'Odkrywaj wzdłuż ścieżki', desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { - label: 'Żetony, które ujawniają', + label: 'Żetony odkrywające', desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', }, revealMode: { - label: 'Tryb ujawnienia', - desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + label: 'Tryb odkrywania', + desc: 'Usuwanie usuwa heksy w zasięgu wzroku. Przebłysk zamiast tego czyni je przezroczystymi; są usuwane, gdy wejdzie na nie żeton.', }, announce: { - label: 'Ogłoś odkrycia', + label: 'Ogłaszaj odkrycia', desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', }, pingDiscoveries: { - label: 'Odkrycia pingowe', + label: 'Pinguj odkrycia', desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', }, hideCoveredTokens: { - label: 'Ukryj zakryte tokeny', + label: 'Ukrywaj zakryte żetony', desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', }, }, status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa sześciokątna', + layer: 'Warstwa heksagonów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', - glimpsed: 'Prześwietlone heksy', - pending: 'Lokalizacje oczekujące na zapełnienie', - calibrated: 'Kalibrowane', - overrides: 'Zastąpienia strony', - undo: 'Cofnij dostępne', + glimpsed: 'Heksy w przebłysku', + pending: 'Lokalizacje czekające na wypełnienie', + calibrated: 'Skalibrowano', + overrides: 'Nadpisania strony', + undo: 'Można cofnąć', }, messages: { filled: @@ -183,10 +183,11 @@ const TRANSLATION = { 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: - 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', pruned: - 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', - readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom „Skanuj ponownie” na stronie, aby ponownie odnaleźć jej heksy.', + readyHint: + 'Wpisz !hexploration, aby otworzyć menu, lub otwórz materiał informacyjny "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -196,9 +197,9 @@ const TRANSLATION = { }, errors: { noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', - notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + notHex: 'Ta strona nie używa siatki heksowej.', noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', - emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + emptyArea: 'Zaznaczony obszar nie zawiera żadnych środków heksów.', tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', @@ -242,25 +243,24 @@ const TRANSLATION = { resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', mark: 'Zamień wybrane żetony w ukryte lokalizacje.', - unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + unmark: 'Spraw, by zaznaczone żetony przestały być ukrytymi lokalizacjami.', set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', pageClear: 'Usuń zastąpienia bieżącej strony.', - rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + rescan: 'Odbuduj listę heksów strony, na przykład po skopiowaniu strony lub gry.', calibrate: 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', calibrateReset: 'Usuń kalibrację bieżącej strony.', - status: 'Pokaż, co Heexploration wie o bieżącej stronie.', - journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + status: 'Pokaż, co Hexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne „Pomoc” i „Command Deck”.', help: 'Pokaż tę listę.', handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', }, deck: { - subtitle: 'Pokład dowodzenia', drawDesc: 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', revealDesc: - 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + 'Zaznacz heksy, kształty lub żetony, aby je odkryć lub ponownie zakryć. „Eksploruj” odkrywa okolicę zaznaczonych żetonów, jakby właśnie się przesunęły.', locationsDesc: 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', toolsDesc: @@ -282,28 +282,28 @@ const TRANSLATION = { steps: [ 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', - 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', - 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', - 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + 'Zaznacz kształty i kliknij „Wypełnij” w Command Deck (lub wpisz !hexploration fill). Kształty zostaną zastąpione heksami.', + 'Opcjonalnie: przed wypełnieniem zaznacz żetony ważnych miejsc i kliknij „Oznacz lokalizację”. Zostaną ukryte pod heksami i ogłoszone po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przejdzie, oraz heksy w jego zasięgu wzroku (ustawienie „Zasięg wzroku”) zostaną odkryte.', ], }, commands: { heading: 'Polecenia', intro: 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', - colCommand: 'Rozkaz', + colCommand: 'Polecenie', colDesc: 'Co to robi', }, revealing: { heading: 'Jak działa odkrywanie', points: [ - 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', - 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', - 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', - 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', - 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów. Gdy „Linia wzroku” jest włączona, heks zostaje odkryty tylko wtedy, gdy między nim a żetonem nie leży żaden zakryty heks.', + '„Odległość odkrywania heksagonów” jest zapisywana na heksach w chwili ich rysowania. Takie heksy można odkryć tylko z odległości najwyżej tylu heksów, niezależnie od tego, jak daleko widzi żeton. Używaj jej dla gór lub lasów, które zasłaniają to, co jest za nimi.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', + 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', ], }, locations: { @@ -312,15 +312,15 @@ const TRANSLATION = { 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', - 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', - colKey: 'Klawisz', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', @@ -329,9 +329,9 @@ const TRANSLATION = { heading: 'Jumpgate i Dziedzictwo', points: [ 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', - 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', - 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', + 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], }, upgrading: { @@ -339,8 +339,8 @@ const TRANSLATION = { points: [ 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', - 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', - 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + 'Polecenia wersji 1, w tym makro Hexploration_menu, nadal działają.', + 'W wersji 1 heksy mógł odkrywać każdy żeton reprezentujący postać. Aby zachować to zachowanie, ustaw „Żetony odkrywające” na „Żetony postaci”.', ], colV1: 'Polecenie wersji 1', colV2: 'Polecenie wersji 2', @@ -348,18 +348,18 @@ const TRANSLATION = { troubleshooting: { heading: 'Rozwiązywanie problemów', points: [ - 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Nic się nie dzieje, gdy żeton się porusza: sprawdź, czy żeton jest na warstwie żetonów i pasuje do ustawienia „Żetony odkrywające” oraz czy strona ma heksy (!hexploration status).', 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', - 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', - 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'Heksy przestały się odkrywać po skopiowaniu strony lub gry: uruchom „Skanuj ponownie” na stronie.', + '„Wypełnij” zgłasza, że obszar nie zawiera środków heksów: kształt musi zawierać środek co najmniej jednego heksu.', 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', ], }, languages: { heading: 'Języki', - body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + body: 'Wybierz język poleceniem !hexploration set language. Dostępne języki:', colLanguage: 'Język', - colNative: 'Imię rodzime', + colNative: 'Nazwa rodzima', colCode: 'Kod', }, credits: { diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index 94d9450215..389f62421a 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -1,45 +1,45 @@ const TRANSLATION = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Configurações do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Configurações da página: {page}', - status: 'Status de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Status do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { - draw: 'Empate', + draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + layerInUse: 'Novos hexágonos estão sendo desenhados na {layer}.', pageSettingsHelp: 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', + name: 'Nomear hexágono', settings: 'Configurações', - pageSettings: 'Configurações de página', + pageSettings: 'Configurações da página', status: 'Status', - rescan: 'Digitalizar novamente', + rescan: 'Reescanear', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -48,21 +48,21 @@ const TRANSLATION = { name: 'Nome do local (deixe em branco para limpar)', }, values: { - on: 'Sobre', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de tokens', }, revealBy: { players: 'Tokens de jogador', - characters: 'Fichas de personagem', + characters: 'Tokens de personagem', all: 'Todos os tokens', }, revealMode: { - clear: 'Claro', + clear: 'Limpar', glimpse: 'Vislumbre', }, announce: { @@ -76,17 +76,17 @@ const TRANSLATION = { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { language: { - label: 'Linguagem', + label: 'Idioma', desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', + label: 'Camada dos hexágonos', desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', }, fillColor: { @@ -98,19 +98,19 @@ const TRANSLATION = { desc: 'Cor do contorno dos novos hexágonos.', }, labelColor: { - label: 'Cor da etiqueta', + label: 'Cor do rótulo', desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Use uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -131,14 +131,14 @@ const TRANSLATION = { }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre os torna transparentes; eles são removidos quando um token entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', }, hideCoveredTokens: { @@ -149,14 +149,14 @@ const TRANSLATION = { status: { engine: 'Motor de jogo', grid: 'Grade', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Tokens de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Tokens de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais aguardando preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -165,7 +165,7 @@ const TRANSLATION = { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -183,10 +183,11 @@ const TRANSLATION = { 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute Reescanear na página para recuperar seus hexágonos.', + readyHint: + 'Digite !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -196,9 +197,9 @@ const TRANSLATION = { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não usa uma grade hexadecimal.', + notHex: 'Esta página não usa uma grade hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -209,7 +210,7 @@ const TRANSLATION = { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', unexpected: 'Algo deu errado: {message}', }, @@ -225,21 +226,22 @@ const TRANSLATION = { unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token encaixado em um hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'Os dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log do console da API.', }, help: { - menu: 'Mostre o cardápio.', + menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: + 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta antes).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -247,34 +249,33 @@ const TRANSLATION = { pageSet: 'Substituir uma configuração de revelação somente na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grade hexagonal com um ou dois tokens selecionados encaixados em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + 'Selecione hexágonos, formas ou tokens para revelá-los ou cobri-los novamente. Explorar revela ao redor dos tokens selecionados como se eles tivessem se movido.', locationsDesc: - 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Use o folheto "{deck}" para controles de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais ele passa (e, se você quiser, os hexágonos ao redor) são removidos, de modo que o mapa é descoberto um hexágono por vez. Locais ocultos podem ser colocados sob os hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -282,9 +283,9 @@ const TRANSLATION = { steps: [ 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar local. Eles ficam ocultos sob os hexágonos e são anunciados quando descobertos.', + 'Mova um token de jogador. Cada hexágono pelo qual ele passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -297,31 +298,31 @@ const TRANSLATION = { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', + 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A Distância de revelação dos hexágonos é gravada nos hexágonos quando eles são desenhados. Esses hexágonos só são revelados a no máximo essa quantidade de hexágonos de distância, por mais longe que um token consiga ver. Use-a para montanhas ou florestas que escondem o que há atrás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles.', + 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + 'Altere as configurações com !hexploration set (ou com o botão Configurações). Camada dos hexágonos, Tokens que revelam e Idioma também podem ser definidos na página de configurações do Mod.', colKey: 'Chave', - colName: 'Contexto', + colName: 'Configuração', colDesc: 'Descrição', perPage: '(Pode ser definido por página.)', }, @@ -329,18 +330,18 @@ const TRANSLATION = { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com um formato ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não se alinharem com a grade da página, encaixe um token no centro de um hexágono, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Reescanear na página para recuperá-los, junto com seus rótulos de nome e tokens de local.', ], }, upgrading: { heading: 'Atualizando da versão 1', points: [ 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', - 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + 'A versão 1 permitia que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que revelam como Tokens de personagem para manter esse comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -348,10 +349,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', - 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', + 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', ], }, @@ -359,7 +360,7 @@ const TRANSLATION = { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Linguagem', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index 0a025c537d..d32340bf88 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -1,45 +1,45 @@ const TRANSLATION = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Definições do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Definições da página: {page}', - status: 'Estado de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Estado do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + layerInUse: 'Os novos hexágonos estão a ser desenhados na {layer}.', pageSettingsHelp: 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', - settings: 'Configurações', - pageSettings: 'Configurações de página', - status: 'Estatuto', - rescan: 'Digitalizar novamente', + name: 'Nomear hexágono', + settings: 'Definições', + pageSettings: 'Definições da página', + status: 'Estado', + rescan: 'Reanalisar', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -48,26 +48,26 @@ const TRANSLATION = { name: 'Nome do local (deixar em branco para limpar)', }, values: { - on: 'Em', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de fichas', }, revealBy: { - players: 'Tokens de jogador', + players: 'Fichas de jogador', characters: 'Fichas de personagem', - all: 'Todos os tokens', + all: 'Todas as fichas', }, revealMode: { - clear: 'Claro', - glimpse: 'Relance', + clear: 'Limpar', + glimpse: 'Vislumbre', }, announce: { all: 'Toda a gente', - gm: 'Apenas GM', + gm: 'Apenas o GM', off: 'Desligado', }, orientation: { @@ -76,8 +76,8 @@ const TRANSLATION = { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', - desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + label: 'Camada dos hexágonos', + desc: 'Onde são desenhados os novos hexágonos. Automático tenta a camada de primeiro plano (acima das fichas) e recorre à camada de fichas se o jogo não a suportar.', }, fillColor: { label: 'Cor de preenchimento', @@ -102,15 +102,15 @@ const TRANSLATION = { desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Utilize uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -126,37 +126,37 @@ const TRANSLATION = { desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', }, revealBy: { - label: 'Tokens que revelam', + label: 'Fichas que revelam', desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre torna-os transparentes; são removidos quando uma ficha entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', }, hideCoveredTokens: { - label: 'Ocultar tokens cobertos', + label: 'Ocultar fichas cobertas', desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', }, }, status: { engine: 'Motor de jogo', - grid: 'Rede', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + grid: 'Grelha', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Fichas de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Fichas de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais a aguardar preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -165,7 +165,7 @@ const TRANSLATION = { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -183,10 +183,11 @@ const TRANSLATION = { 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos guardados que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute Reanalisar na página para recuperar os seus hexágonos.', + readyHint: + 'Escreva !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -196,9 +197,9 @@ const TRANSLATION = { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não utiliza uma grelha hexadecimal.', + notHex: 'Esta página não utiliza uma grelha hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -209,7 +210,7 @@ const TRANSLATION = { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', unexpected: 'Algo correu mal: {message}', }, @@ -225,9 +226,9 @@ const TRANSLATION = { unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe uma ficha no centro de um hexágono e selecione-a. Selecione uma segunda ficha encaixada num hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'As duas fichas têm de estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log da consola da API.', }, help: { @@ -238,8 +239,8 @@ const TRANSLATION = { reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -247,34 +248,33 @@ const TRANSLATION = { pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grelha hexagonal com uma ou duas fichas selecionadas encaixadas em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: - 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + 'Selecione hexágonos, formas ou fichas para os revelar ou voltar a cobrir. Explorar revela à volta das fichas selecionadas como se se tivessem movido.', locationsDesc: - 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Utilize o folheto "{deck}" para controlos de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se desloca, os hexágonos por onde passa (e, se quiser, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Podem ser colocados locais escondidos sob os hexágonos, que são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -282,9 +282,9 @@ const TRANSLATION = { steps: [ 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione fichas de locais importantes e clique em Marcar local. Ficam escondidas sob os hexágonos e são anunciadas quando descobertas.', + 'Mova uma ficha de jogador. Cada hexágono por onde passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -297,29 +297,29 @@ const TRANSLATION = { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + 'A Distância de revelação dos hexágonos é guardada nos hexágonos quando são desenhados. Esses hexágonos só são revelados a, no máximo, esse número de hexágonos de distância, por mais longe que uma ficha consiga ver. Utilize-a para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + 'Altere as definições com !hexploration set (ou com o botão Definições). Camada dos hexágonos, Fichas que revelam e Idioma também podem ser definidos na página de definições do Mod.', colKey: 'Chave', colName: 'Definição', colDesc: 'Descrição', @@ -329,18 +329,18 @@ const TRANSLATION = { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com uma forma ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não ficarem alinhados com a grelha da página, encaixe uma ficha no centro de um hexágono, selecione-a e clique em Calibrar. Selecione duas fichas em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Reanalisar na página para os voltar a apanhar, juntamente com as suas etiquetas de nome e fichas de local.', ], }, upgrading: { heading: 'Atualização da versão 1', points: [ 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', - 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, fichas de localização e definições existentes são atualizados automaticamente no primeiro arranque.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + 'A versão 1 permitia que qualquer ficha que representasse uma personagem revelasse hexágonos. Defina Fichas que revelam como Fichas de personagem para manter este comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -348,10 +348,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', - 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', - 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Nada acontece quando uma ficha se move: verifique se a ficha está na camada de fichas e corresponde a Fichas que revelam, e se a página tem hexágonos (!hexploration status).', + 'Os hexágonos estão desalinhados com a grelha: use Calibrar e verifique depois com uma ficha em alguns hexágonos do mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute Reanalisar na página.', + 'Preencher indica que a área não tem centros de hexágonos: a forma tem de conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', ], }, @@ -359,7 +359,7 @@ const TRANSLATION = { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Idioma', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index a77b1eb5d6..9a2fd2b982 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -1,83 +1,83 @@ const TRANSLATION = { titles: { - ready: 'Геразведка готова.', + ready: 'Hexploration готова.', settings: 'Настройки Hexploration', languages: 'Выберите язык', pageSettings: 'Настройки страницы: {page}', - status: 'Статус гексоразведки: {page}', - help: 'Команды гексоразведки', + status: 'Статус Hexploration: {page}', + help: 'Команды Hexploration', confirm: 'Пожалуйста, подтвердите', }, discovery: { - title: 'Местоположение обнаружено', + title: 'Локация обнаружена', }, menu: { - draw: 'Рисовать', - reveal: 'Показать и скрыть', + draw: 'Рисование', + reveal: 'Раскрытие и скрытие', locations: 'Локации', tools: 'Инструменты', - layerInUse: 'Новые гексы рисуются на {layer}.', + layerInUse: 'Новые гексы рисуются на этом слое: {layer}.', pageSettingsHelp: 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', }, buttons: { - fill: 'Наполнять', + fill: 'Заполнить', fillInverse: 'Обратная заливка', undo: 'Отменить заливку', - reveal: 'Раскрывать', + reveal: 'Раскрыть', conceal: 'Скрыть', explore: 'Исследовать', - revealPage: 'Открыть страницу', + revealPage: 'Раскрыть страницу', resetPage: 'Сбросить страницу', - mark: 'Отметить местоположение', + mark: 'Отметить локацию', unmark: 'Снять отметку', - name: 'Шестнадцатеричное имя', + name: 'Назвать гекс', settings: 'Настройки', pageSettings: 'Настройки страницы', status: 'Статус', - rescan: 'Повторное сканирование', - calibrate: 'Калибровка', - calibrateReset: 'Сброс калибровки', - help: 'Помощь', - change: 'Изменять', + rescan: 'Пересканировать', + calibrate: 'Калибровать', + calibrateReset: 'Сбросить калибровку', + help: 'Справка', + change: 'Изменить', menu: 'Меню', - clearOverrides: 'Очистить переопределения', - confirmReset: 'Да, удалить все шестигранники', + clearOverrides: 'Сбросить переопределения', + confirmReset: 'Да, удалить все гексы', }, prompts: { name: 'Название местоположения (оставьте пустым, чтобы очистить)', }, values: { - on: 'На', - off: 'Выключенный', - none: 'Никто', + on: 'Вкл.', + off: 'Выкл.', + none: 'Нет', hexLayer: { - auto: 'Авто (на переднем плане, если доступно)', - foreground: 'передний слой', + auto: 'Авто (передний план, если доступен)', + foreground: 'слой переднего плана', objects: 'слой токенов', }, revealBy: { - players: 'Жетоны игроков', - characters: 'Жетоны персонажей', + players: 'Токены игроков', + characters: 'Токены персонажей', all: 'Все токены', }, revealMode: { - clear: 'Прозрачный', - glimpse: 'Случайно заметить', + clear: 'Очистка', + glimpse: 'Проблеск', }, announce: { - all: 'Каждый', - gm: 'только ГМ', - off: 'Выключенный', + all: 'Все', + gm: 'Только ГМ', + off: 'Выкл.', }, orientation: { - vertical: 'Шестигранник (В)', - horizontal: 'Шестигранник (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Наполнять', + fill: 'Заливка', fillInverse: 'Обратная заливка', - conceal: 'Скрыть', + conceal: 'Скрытие', }, }, settings: { @@ -86,8 +86,8 @@ const TRANSLATION = { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Шестнадцатеричный слой', - desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + label: 'Слой шестиугольников', + desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', @@ -98,19 +98,19 @@ const TRANSLATION = { desc: 'Цвет контура новых гексов.', }, labelColor: { - label: 'Цвет этикетки', + label: 'Цвет меток', desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', }, glimpseColor: { - label: 'Взгляд цвета', - desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + label: 'Цвет проблеска', + desc: 'Цвет, который принимают гексы в режиме «Проблеск». Используйте полупрозрачный цвет rgba().', }, strokeWidth: { label: 'Ширина границы', desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Расстояние раскрытия шестигранника', + label: 'Дальность раскрытия шестиугольников', desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -122,50 +122,50 @@ const TRANSLATION = { desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', }, revealPath: { - label: 'Показать вдоль пути', + label: 'Раскрывать вдоль пути', desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', }, revealBy: { - label: 'Жетоны, которые раскрывают', + label: 'Раскрывающие токены', desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', }, revealMode: { label: 'Режим раскрытия', - desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + desc: '«Очистка» удаляет гексы в пределах видимости. «Проблеск» вместо этого делает их полупрозрачными; они удаляются, когда в них входит токен.', }, announce: { label: 'Объявлять об открытиях', desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', }, pingDiscoveries: { - label: 'Пинг-открытия', + label: 'Пинговать находки', desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', }, hideCoveredTokens: { - label: 'Скрыть покрытые токены', + label: 'Скрывать токены под гексами', desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', }, }, status: { engine: 'Игровой движок', grid: 'Сетка', - layer: 'Шестнадцатеричный слой', - hexes: 'шестиугольники', - named: 'Именованные шестигранники', - icons: 'Жетоны местоположения', - glimpsed: 'Замеченные гексы', - pending: 'Места, ожидающие заполнения', - calibrated: 'Калиброванный', - overrides: 'Переопределения страниц', - undo: 'Отмена доступна', + layer: 'Слой гексов', + hexes: 'Гексы', + named: 'Именованные гексы', + icons: 'Токены локаций', + glimpsed: 'Гексы в проблеске', + pending: 'Локации, ожидающие заливки', + calibrated: 'Откалибровано', + overrides: 'Переопределения страницы', + undo: 'Доступна отмена', }, messages: { filled: 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', revealed: 'Обнаружены гексы: {count}.', - revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: - 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', resetPage: 'Со страницы удалены шестигранники: {count}.', undone: 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', @@ -183,11 +183,11 @@ const TRANSLATION = { 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: - 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', pruned: - 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + 'Забыты сохранённые гексы, которых больше нет: {dropped}. Если эта игра или страница была скопирована, выполните «Пересканировать» на странице, чтобы снова найти её гексы.', readyHint: - 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + 'Введите !hexploration, чтобы открыть меню, или откройте раздаточный материал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -226,9 +226,9 @@ const TRANSLATION = { unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: - 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Привяжите токен к центру гекса и выделите его. Чтобы заодно исправить размер гекса, выделите второй токен, привязанный к соседнему гексу в той же строке (Hex V) или в том же столбце (Hex H).', calibrateFailed: - 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + 'Два токена должны находиться в одной строке (Hex V) или в одном столбце (Hex H) на расстоянии не менее одного гекса друг от друга.', unexpected: 'Подробности в журнале консоли API.', }, help: { @@ -240,29 +240,27 @@ const TRANSLATION = { revealPage: 'Раскройте каждый гекс на странице без объявлений.', conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', - resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', pageSet: 'Переопределить настройку отображения только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', - rescan: - 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', - journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', help: 'Покажите этот список.', handout: 'Полные инструкции приведены в раздаточном материале «{name}».', }, deck: { - subtitle: 'Командная колода', drawDesc: - 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + 'Обведите область фигурами, выделите их и нажмите «Заполнить». «Отменить заливку» отменяет последнюю заливку.', revealDesc: - 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + 'Выделите гексы, фигуры или токены, чтобы раскрыть их или снова скрыть. «Исследовать» раскрывает гексы вокруг выбранных токенов, как если бы они туда переместились.', locationsDesc: 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', toolsDesc: @@ -271,11 +269,11 @@ const TRANSLATION = { }, handout: { versionLabel: 'Версия', - subtitle: 'Шестнадцатеричное исследование для Roll20', + subtitle: 'Исследование гекс за гексом для Roll20', footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', overview: { heading: 'Обзор', - body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + body: 'Hexploration закрывает гексовую карту непрозрачными гексами. По мере продвижения группы гексы, через которые она проходит (и, при желании, гексы вокруг них), удаляются, так что карта открывается гекс за гексом. Под гексами можно разместить скрытые локации — при обнаружении о них будет объявлено. Работает в играх Jumpgate и Legacy, на сетках Hex (V) и Hex (H) любого размера.', demo: 'Посмотрите короткую демонстрацию (из версии 1)', }, quickStart: { @@ -283,9 +281,9 @@ const TRANSLATION = { steps: [ 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', - 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', - 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', - 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + 'Выделите фигуры и нажмите «Заполнить» в Command Deck (или введите !hexploration fill). Фигуры заменятся гексами.', + 'Необязательно: перед заливкой выделите токены важных мест и нажмите «Отметить локацию». Они будут спрятаны под гексами, а при обнаружении о них будет объявлено.', + 'Переместите токен игрока. Каждый гекс, через который он проходит, и гексы в пределах его «Расстояния обзора» раскрываются.', ], }, commands: { @@ -298,29 +296,29 @@ const TRANSLATION = { revealing: { heading: 'Как работает выявление', points: [ - 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', - 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', - 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', - 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', - 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', + 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов. При включённой «Линии видимости» гекс раскрывается, только если между ним и токеном нет закрытого гекса.', + '«Дальность раскрытия шестиугольников» сохраняется в гексах при их рисовании. Такие гексы раскрываются только с расстояния не больше этого числа гексов, как бы далеко ни видел токен. Используйте её для гор или лесов, скрывающих то, что за ними.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен.', + 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', + 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', ], }, locations: { heading: 'Именованные гексы и локации', points: [ - 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', - 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', @@ -330,18 +328,18 @@ const TRANSLATION = { heading: 'Джампгейт и Наследие', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', - 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', - 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', + 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], }, upgrading: { heading: 'Обновление с версии 1', points: [ 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', - 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Существующие гексовые карты, имена, токены локаций и настройки обновляются автоматически при первом запуске.', 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', - 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + 'В версии 1 гексы мог раскрывать любой токен, представляющий персонажа. Чтобы сохранить такое поведение, установите для «Раскрывающие токены» значение «Токены персонажей».', ], colV1: 'Команда версии 1', colV2: 'Команда версии 2', @@ -349,18 +347,18 @@ const TRANSLATION = { troubleshooting: { heading: 'Поиск неисправностей', points: [ - 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', - 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', - 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', - 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токенов и подходит под настройку «Раскрывающие токены», а на странице есть гексы (!hexploration status).', + 'Гексы смещены относительно сетки: нажмите «Калибровать», затем проверьте токеном несколько гексов в разных частях карты.', + 'Гексы перестали раскрываться после копирования страницы или игры: выполните «Пересканировать» на странице.', + '«Заполнить» сообщает, что в области нет центров гексов: фигура должна содержать центр хотя бы одного гекса.', 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', ], }, languages: { heading: 'Языки', - body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + body: 'Выберите язык командой !hexploration set language. Доступные языки:', colLanguage: 'Язык', - colNative: 'Родное имя', + colNative: 'Самоназвание', colCode: 'Код', }, credits: { diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index c8ebddb39c..780ac9c615 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -1,37 +1,37 @@ const TRANSLATION = { titles: { ready: 'Hexploration är redo.', - settings: 'Heexploration Inställningar', + settings: 'Hexploration-inställningar', languages: 'Välj ett språk', pageSettings: 'Sidinställningar: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandon', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandon', confirm: 'Vänligen bekräfta', }, discovery: { title: 'Plats upptäckt', }, menu: { - draw: 'Dra', - reveal: 'Avslöja och göm', + draw: 'Rita', + reveal: 'Avslöja och dölj', locations: 'Platser', tools: 'Verktyg', - layerInUse: 'Nya sexkanter ritas på {layer}.', + layerInUse: 'Nya hexar ritas på {layer}.', pageSettingsHelp: 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', }, buttons: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - undo: 'Ångra Fyll', + undo: 'Ångra fyllning', reveal: 'Avslöja', - conceal: 'Dölja', + conceal: 'Dölj', explore: 'Utforska', - revealPage: 'Avslöja sidan', + revealPage: 'Avslöja sida', resetPage: 'Återställ sida', mark: 'Markera plats', unmark: 'Avmarkera', - name: 'Namn Hex', + name: 'Namnge hex', settings: 'Inställningar', pageSettings: 'Sidinställningar', status: 'Status', @@ -53,12 +53,12 @@ const TRANSLATION = { none: 'Ingen', hexLayer: { auto: 'Auto (förgrund om tillgängligt)', - foreground: 'förgrundsskikt', - objects: 'symbollager', + foreground: 'förgrundslagret', + objects: 'tokenlagret', }, revealBy: { - players: 'Spelarpoletter', - characters: 'Karaktärspoletter', + players: 'Spelartokens', + characters: 'Rollpersonstokens', all: 'Alla tokens', }, revealMode: { @@ -75,9 +75,9 @@ const TRANSLATION = { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - conceal: 'Dölja', + conceal: 'Dölj', }, }, settings: { @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Språk för menyer, meddelanden och åhörarkopior.', }, hexLayer: { - label: 'Hexlager', + label: 'Lager för hexar', desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', - desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + desc: 'Färg på nya hexar. Använd rgba() för genomskinliga hexar, till exempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfärg', @@ -102,15 +102,15 @@ const TRANSLATION = { desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', }, glimpseColor: { - label: 'Glimt färg', - desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + label: 'Glimtfärg', + desc: 'Färgen som hexar byter till när de skymtas (avslöjandeläget Glimt). Använd en genomskinlig rgba()-färg.', }, strokeWidth: { label: 'Kantbredd', desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', }, maxDistance: { - label: 'Hexavslöjande avstånd', + label: 'Avslöjandeavstånd för hexar', desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', }, revealDistance: { @@ -118,7 +118,7 @@ const TRANSLATION = { desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', }, lineOfSight: { - label: 'Synlinje', + label: 'Siktlinje', desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', }, revealPath: { @@ -130,33 +130,33 @@ const TRANSLATION = { desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', }, revealMode: { - label: 'Avslöjande läge', - desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + label: 'Avslöjandeläge', + desc: 'Rensa tar bort hexar inom synhåll. Glimt gör dem i stället genomskinliga; de tas bort när en token går in i dem.', }, announce: { label: 'Tillkännage upptäckter', desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', }, pingDiscoveries: { - label: 'Ping upptäckter', + label: 'Pinga upptäckter', desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', }, hideCoveredTokens: { - label: 'Dölj täckta polletter', + label: 'Dölj täckta tokens', desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', }, }, status: { engine: 'Spelmotor', grid: 'Rutnät', - layer: 'Hexskikt', - hexes: 'Hex', + layer: 'Hexlager', + hexes: 'Hexar', named: 'Namngivna hexar', - icons: 'Platsskyltar', - glimpsed: 'Glimmade hexar', + icons: 'Platstokens', + glimpsed: 'Genomskinliga hexar', pending: 'Platser som väntar på fyllning', calibrated: 'Kalibrerad', - overrides: 'Sida åsidosätter', + overrides: 'Sidåsidosättningar', undo: 'Ångra tillgängligt', }, messages: { @@ -167,11 +167,11 @@ const TRANSLATION = { 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', resetPage: 'Hexen har tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', named: 'Hex med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: - 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: @@ -182,11 +182,11 @@ const TRANSLATION = { 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: - 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', pruned: - 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + 'Sparade hexar som inte längre finns och har glömts bort: {dropped}. Om det här spelet eller sidan kopierades kör du Skanna igen på sidan för att hitta dess hexar igen.', readyHint: - 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + 'Skriv !hexploration för menyn, eller öppna handouten "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -225,7 +225,7 @@ const TRANSLATION = { calibrateNeedsTokens: 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', calibrateFailed: - 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + 'Två tokens måste ligga i samma rad (Hex V) eller samma kolumn (Hex H), minst en hex från varandra.', unexpected: 'Detaljer finns i API-konsolloggen.', }, help: { @@ -248,16 +248,15 @@ const TRANSLATION = { calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', - journal: 'Bygg om hjälp- och kommandodäcken.', + journal: 'Bygg om handouterna Help och Command Deck.', help: 'Visa den här listan.', handout: 'Fullständiga instruktioner finns i "{name}" handout.', }, deck: { - subtitle: 'Kommandodäck', drawDesc: - 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + 'Rita former runt ett område, markera dem och fyll sedan. Ångra fyllning tar bort den senaste fyllningen.', revealDesc: - 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', toolsDesc: @@ -278,9 +277,9 @@ const TRANSLATION = { steps: [ 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', - 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', - 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, commands: { @@ -293,13 +292,13 @@ const TRANSLATION = { revealing: { heading: 'Hur avslöjande fungerar', points: [ - 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', - 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', - 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', - 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', - 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar. Med Siktlinje på avslöjas en hex bara om ingen täckt hex ligger emellan.', + 'Avslöjandeavstånd för hexar lagras på hexarna när de ritas. Dessa hexar avslöjas bara inom så många hexars avstånd, hur långt en token än kan se. Använd det för berg eller skogar som döljer vad som finns bakom dem.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem.', + 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', + 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', ], }, locations: { @@ -308,14 +307,14 @@ const TRANSLATION = { 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', - 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', - 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], }, settings: { heading: 'Inställningar', intro: - 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', colName: 'Miljö', colDesc: 'Beskrivning', @@ -325,18 +324,18 @@ const TRANSLATION = { heading: 'Jumpgate och Legacy', points: [ 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', - 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', - 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', - 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + 'När Lager för hexar är inställt på Auto ritas hexar på förgrundslagret, ovanför tokens, så att spelarna inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret i stället.', + 'Jumpgate ritar matematiskt regelbundna hexar, som har en något annan form än Legacy-hexar. Om hexarna inte stämmer med en sidas rutnät, fäst en token i mitten av en hex, markera den och klicka på Kalibrera. Markera två tokens i angränsande hexar i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID:n. Kör Skanna igen på sidan för att hitta dem igen, tillsammans med deras namnetiketter och platstokens.', ], }, upgrading: { heading: 'Uppgraderar från version 1', points: [ 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', - 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Befintliga hexkartor, namn, platstokens och inställningar uppgraderas automatiskt vid första starten.', 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', - 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + 'I version 1 kunde varje token som representerade en rollperson avslöja hexar. Ställ in Tokens som avslöjar på Rollpersonstokens för att behålla det beteendet.', ], colV1: 'Kommandot version 1', colV2: 'Kommandot version 2', @@ -344,10 +343,10 @@ const TRANSLATION = { troubleshooting: { heading: 'Felsökning', points: [ - 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', - 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', - 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', + 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', ], }, @@ -355,7 +354,7 @@ const TRANSLATION = { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', colLanguage: 'Språk', - colNative: 'Inhemskt namn', + colNative: 'Eget namn', colCode: 'Koda', }, credits: { diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index 24612c72ef..d15f5654db 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -1,45 +1,45 @@ const TRANSLATION = { titles: { - ready: 'Keşif hazır.', - settings: 'Keşif Ayarları', + ready: 'Hexploration hazır.', + settings: 'Hexploration Ayarları', languages: 'Bir Dil Seçin', pageSettings: 'Sayfa Ayarları: {page}', - status: 'Keşif Durumu: {page}', - help: 'Keşif Komutları', + status: 'Hexploration Durumu: {page}', + help: 'Hexploration Komutları', confirm: 'Lütfen Onaylayın', }, discovery: { title: 'Konum Keşfedildi', }, menu: { - draw: 'Çizmek', - reveal: 'Göster ve Gizle', + draw: 'Çizim', + reveal: 'Açığa Çıkarma ve Gizleme', locations: 'Konumlar', - tools: 'Aletler', - layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + tools: 'Araçlar', + layerInUse: 'Yeni altıgenler şu katmana çiziliyor: {layer}.', pageSettingsHelp: 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', }, buttons: { - fill: 'Doldurmak', - fillInverse: 'Ters Doldurma', + fill: 'Doldur', + fillInverse: 'Ters Doldur', undo: 'Doldurmayı Geri Al', - reveal: 'Ortaya çıkarmak', + reveal: 'Açığa Çıkar', conceal: 'Gizle', - explore: 'Keşfetmek', - revealPage: 'Sayfayı Göster', + explore: 'Keşfet', + revealPage: 'Sayfayı Açığa Çıkar', resetPage: 'Sayfayı Sıfırla', mark: 'Konumu İşaretle', - unmark: 'İşareti kaldır', - name: 'Ad Hex', + unmark: 'İşareti Kaldır', + name: 'Altıgeni Adlandır', settings: 'Ayarlar', pageSettings: 'Sayfa Ayarları', status: 'Durum', - rescan: 'Yeniden tara', - calibrate: 'Kalibre et', + rescan: 'Yeniden Tara', + calibrate: 'Kalibre Et', calibrateReset: 'Kalibrasyonu Sıfırla', help: 'Yardım', - change: 'Değiştirmek', + change: 'Değiştir', menu: 'Menü', clearOverrides: 'Geçersiz Kılmaları Temizle', confirmReset: 'Evet, Tüm Altıgenleri Kaldır', @@ -52,18 +52,18 @@ const TRANSLATION = { off: 'Kapalı', none: 'Hiçbiri', hexLayer: { - auto: 'Otomatik (varsa ön planda)', + auto: 'Otomatik (varsa ön plan)', foreground: 'ön plan katmanı', - objects: 'belirteç katmanı', + objects: 'jeton katmanı', }, revealBy: { players: 'Oyuncu jetonları', - characters: 'Karakter belirteçleri', + characters: 'Karakter jetonları', all: 'Tüm jetonlar', }, revealMode: { - clear: 'Temizlemek', - glimpse: 'Kısa bakış', + clear: 'Temizleme', + glimpse: 'Bakış', }, announce: { all: 'Herkes', @@ -71,23 +71,23 @@ const TRANSLATION = { off: 'Kapalı', }, orientation: { - vertical: 'Altıgen (V)', - horizontal: 'Altıgen (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Doldurmak', + fill: 'Doldurma', fillInverse: 'Ters Doldurma', - conceal: 'Gizle', + conceal: 'Gizleme', }, }, settings: { language: { label: 'Dil', - desc: 'Menüler, mesajlar ve bildiriler için dil.', + desc: 'Menüler, mesajlar ve broşürler için dil.', }, hexLayer: { - label: 'Altıgen Katman', - desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + label: 'Altıgen Katmanı', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (jetonların üstünde) dener; oyun bunu desteklemiyorsa jeton katmanına geri döner.', }, fillColor: { label: 'Dolgu Rengi', @@ -103,14 +103,14 @@ const TRANSLATION = { }, glimpseColor: { label: 'Bakış Rengi', - desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + desc: 'Altıgenlerin Bakış modunda aldığı renk. Yarı saydam bir rgba() rengi kullanın.', }, strokeWidth: { - label: 'Kenar Genişliği', + label: 'Kenarlık Kalınlığı', desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', }, maxDistance: { - label: 'Hex Ortaya Çıkma Mesafesi', + label: 'Altıgen Açığa Çıkarma Mesafesi', desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', }, revealDistance: { @@ -122,42 +122,42 @@ const TRANSLATION = { desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', }, revealPath: { - label: 'Yol Boyunca Ortaya Çıkar', + label: 'Yol Boyunca Açığa Çıkar', desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', }, revealBy: { - label: 'Ortaya Çıkan Tokenlar', + label: 'Açığa Çıkaran Jetonlar', desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', }, revealMode: { - label: 'Ortaya Çıkarma Modu', - desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + label: 'Açığa Çıkarma Modu', + desc: 'Temizleme, görüş alanındaki altıgenleri kaldırır. Bakış ise onları yarı saydam yapar; içlerine bir jeton girdiğinde kaldırılırlar.', }, announce: { - label: 'Keşifleri Duyurun', + label: 'Keşifleri Duyur', desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', }, pingDiscoveries: { - label: 'Ping Keşifleri', + label: 'Keşifleri Pingle', desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', }, hideCoveredTokens: { - label: 'Kapalı Jetonları Gizle', + label: 'Örtülü Jetonları Gizle', desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', }, }, status: { engine: 'Oyun motoru', grid: 'Izgara', - layer: 'Altıgen katman', + layer: 'Altıgen katmanı', hexes: 'Altıgenler', named: 'Adlandırılmış altıgenler', - icons: 'Konum belirteçleri', - glimpsed: 'Kısa bir bakış altıgenler', - pending: 'Doldurulmayı bekleyen yerler', + icons: 'Konum jetonları', + glimpsed: 'Bakış altındaki altıgenler', + pending: 'Doldurma bekleyen konumlar', calibrated: 'Kalibre edildi', overrides: 'Sayfa geçersiz kılmaları', - undo: 'Geri alma seçeneği mevcut', + undo: 'Geri alma mevcut', }, messages: { filled: @@ -166,7 +166,7 @@ const TRANSLATION = { revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', - resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', named: '"{name}" adlı altıgenler: {count}.', @@ -181,12 +181,12 @@ const TRANSLATION = { 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', calibrationReset: 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', - journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + journalRebuilt: '"{help}" ve "{deck}" broşürleri yeniden oluşturuldu.', migrated: - 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + "Hexploration 1.x altıgen haritalarınız yükseltildi. Bu oyun bir Legacy oyunundan kopyalandıysa, her altıgen harita sayfasında Yeniden Tara'yı çalıştırın.", pruned: - "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", - readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + "Artık var olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenlerini yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + readyHint: 'Menü için !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', }, warnings: { foregroundUnavailable: @@ -223,9 +223,9 @@ const TRANSLATION = { unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: - 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgene tutturulmuş ikinci bir jeton seçin.', calibrateFailed: - 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir altıgen aralıkla olması gerekir.', unexpected: 'Ayrıntılar API konsolu günlüğündedir.', }, help: { @@ -246,21 +246,20 @@ const TRANSLATION = { pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: - 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', calibrate: 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', - status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", - journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + status: "Hexploration'ın geçerli sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Command Deck broşürlerini yeniden oluşturun.', help: 'Bu listeyi göster.', handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', }, deck: { - subtitle: 'Komut Güvertesi', drawDesc: - 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + "Bir alanın çevresine şekiller çizin, onları seçin ve Doldur'a tıklayın. Doldurmayı Geri Al, son doldurmayı geri alır.", revealDesc: - 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', toolsDesc: @@ -273,7 +272,7 @@ const TRANSLATION = { footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', - body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + body: 'Hexploration, bir altıgen haritayı opak altıgenlerle kaplar. Grup ilerledikçe içinden geçtiği altıgenler (ve isterseniz çevresindeki altıgenler) kaldırılır; böylece harita altıgen altıgen ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduklarında duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', demo: "Kısa bir demo izleyin (versiyon 1'den)", }, quickStart: { @@ -281,7 +280,7 @@ const TRANSLATION = { steps: [ 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', - "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "Şekilleri seçin ve Command Deck'te Doldur'a tıklayın (veya !hexploration fill yazın). Şekiller altıgenlerle değiştirilir.", "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', ], @@ -296,13 +295,13 @@ const TRANSLATION = { revealing: { heading: 'Açığa Çıkarma Nasıl Çalışır?', points: [ - 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', - 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', - 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', - 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', - 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', + 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri açığa çıkarır. Görüş Hattı açıkken bir altıgen yalnızca arada örtülü bir altıgen yoksa açığa çıkar.', + 'Altıgen Açığa Çıkarma Mesafesi, altıgenler çizilirken onlara kaydedilir. Bu altıgenler, bir jeton ne kadar uzağı görürse görsün, yalnızca o kadar altıgen mesafeden açığa çıkar. Arkasındakini gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır.', + 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', + "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", ], }, locations: { @@ -311,14 +310,14 @@ const TRANSLATION = { 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', - "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", - "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], }, settings: { heading: 'Ayarlar', intro: - '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + "Ayarları !hexploration set ile (veya Ayarlar düğmesiyle) değiştirin. Altıgen Katmanı, Açığa Çıkaran Jetonlar ve Dil, Mod'un ayarlar sayfasından da ayarlanabilir.", colKey: 'Anahtar', colName: 'Ayar', colDesc: 'Tanım', @@ -327,10 +326,10 @@ const TRANSLATION = { jumpgate: { heading: 'Jumpgate ve Eski', points: [ - 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', - 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', - "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", - "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', + 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', + "Jumpgate matematiksel olarak düzgün altıgenler çizer; bunların şekli Legacy altıgenlerinden biraz farklıdır. Altıgenler sayfanın ızgarasıyla hizalı değilse bir altıgenin merkezine bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerde iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Onları ad etiketleri ve konum jetonlarıyla birlikte yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", ], }, upgrading: { @@ -338,8 +337,8 @@ const TRANSLATION = { points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', - 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', - 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', + "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], colV1: 'Sürüm 1 komutu', colV2: 'Sürüm 2 komutu', @@ -347,23 +346,23 @@ const TRANSLATION = { troubleshooting: { heading: 'Sorun giderme', points: [ - 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', - "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", - "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", - 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu ve Açığa Çıkaran Jetonlar ayarına uyduğunu, sayfada da altıgenler bulunduğunu (!hexploration status) kontrol edin.', + "Altıgenler ızgaradan kaymış: Kalibre Et'i kullanın, ardından haritanın farklı yerlerindeki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra altıgenler açığa çıkmıyor: sayfada Yeniden Tara'yı çalıştırın.", + 'Doldur, alanda altıgen merkezi olmadığını söylüyor: şeklin en az bir altıgenin merkezini içermesi gerekir.', 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', ], }, languages: { heading: 'Diller', - body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + body: '!hexploration set language ile bir dil seçin. Mevcut diller:', colLanguage: 'Dil', colNative: 'Yerel ad', colCode: 'Kod', }, credits: { heading: 'Kredi', - original: 'Orijinal mod', + original: 'Orijinal modun yapımcısı', maintainer: 'Versiyon 2 tarafından sürdürülen', marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index fb781cbbca..4ffc419135 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -3,20 +3,20 @@ const TRANSLATION = { ready: 'Hexploration готовий.', settings: 'Налаштування Hexploration', languages: 'Виберіть мову', - pageSettings: 'Параметри сторінки: {page}', - status: 'Статус дослідження: {page}', + pageSettings: 'Налаштування сторінки: {page}', + status: 'Статус Hexploration: {page}', help: 'Команди Hexploration', confirm: 'Будь ласка, підтвердьте', }, discovery: { - title: 'Розташування виявлено', + title: 'Локацію виявлено', }, menu: { - draw: 'малювати', - reveal: 'Відкрити і приховати', - locations: 'Розташування', + draw: 'Малювання', + reveal: 'Розкриття і приховування', + locations: 'Локації', tools: 'Інструменти', - layerInUse: 'Нові гекси малюються на {layer}.', + layerInUse: 'Нові гекси малюються на цьому шарі: {layer}.', pageSettingsHelp: 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', }, @@ -26,22 +26,22 @@ const TRANSLATION = { undo: 'Скасувати заповнення', reveal: 'Розкрити', conceal: 'Приховати', - explore: 'Досліджуйте', - revealPage: 'Відкрити сторінку', + explore: 'Дослідити', + revealPage: 'Розкрити сторінку', resetPage: 'Скинути сторінку', - mark: 'Позначте розташування', + mark: 'Позначити локацію', unmark: 'Зняти позначку', - name: "Ім'я Hex", + name: 'Назвати гекс', settings: 'Налаштування', - pageSettings: 'Параметри сторінки', + pageSettings: 'Налаштування сторінки', status: 'Статус', - rescan: 'Повторне сканування', + rescan: 'Пересканувати', calibrate: 'Відкалібрувати', calibrateReset: 'Скинути калібрування', help: 'Довідка', - change: 'Зміна', + change: 'Змінити', menu: 'Меню', - clearOverrides: 'Очистити перевизначення', + clearOverrides: 'Скинути перевизначення', confirmReset: 'Так, видалити всі гекси', }, prompts: { @@ -50,24 +50,24 @@ const TRANSLATION = { values: { on: 'Увімкнено', off: 'Вимкнено', - none: 'Жодного', + none: 'Немає', hexLayer: { - auto: 'Автоматично (на передньому плані, якщо доступно)', + auto: 'Авто (передній план, якщо доступний)', foreground: 'шар переднього плану', - objects: 'маркерний шар', + objects: 'шар маркерів', }, revealBy: { - players: 'Жетони гравців', - characters: 'Символьні маркери', - all: 'Усі жетони', + players: 'Маркери гравців', + characters: 'Маркери персонажів', + all: 'Усі маркери', }, revealMode: { - clear: 'ясно', - glimpse: 'Поблиск', + clear: 'Очищення', + glimpse: 'Проблиск', }, announce: { all: 'Всі', - gm: 'Тільки GM', + gm: 'Лише GM', off: 'Вимкнено', }, orientation: { @@ -75,9 +75,9 @@ const TRANSLATION = { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Заповнити', + fill: 'Заповнення', fillInverse: 'Зворотне заповнення', - conceal: 'Приховати', + conceal: 'Приховування', }, }, settings: { @@ -86,77 +86,77 @@ const TRANSLATION = { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шістнадцятковий шар', - desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + label: 'Шар шестикутників', + desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Колір рамки', + label: 'Колір контуру', desc: 'Колір контуру нових гексів.', }, labelColor: { - label: 'Колір етикетки', + label: 'Колір міток', desc: 'Колір написів імен лише для GM на іменованих гексах.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + label: 'Колір проблиску', + desc: 'Колір, якого набувають гекси в режимі «Проблиск». Використовуйте напівпрозорий колір rgba().', }, strokeWidth: { - label: 'Ширина кордону', + label: 'Товщина контуру', desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Шестигранна відстань розкриття', + label: 'Відстань розкриття шестикутників', desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { - label: 'Дистанція огляду', + label: 'Дальність огляду', desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', }, lineOfSight: { - label: 'Пряма видимість', + label: 'Лінія видимості', desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', }, revealPath: { - label: 'Показати уздовж шляху', + label: 'Розкривати вздовж шляху', desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', }, revealBy: { - label: 'Жетони, які розкривають', + label: 'Маркери, що розкривають', desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', }, revealMode: { - label: 'Режим виявлення', - desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + label: 'Режим розкриття', + desc: '«Очищення» видаляє гекси в межах видимості. «Проблиск» натомість робить їх напівпрозорими; вони видаляються, коли на них заходить маркер.', }, announce: { - label: 'Оголосити відкриття', + label: 'Оголошувати відкриття', desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', }, pingDiscoveries: { - label: 'Ping відкриття', + label: 'Пінгувати знахідки', desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', }, hideCoveredTokens: { - label: 'Приховати закриті токени', + label: 'Ховати маркери під гексами', desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', }, }, status: { - engine: 'Ігровий двигун', + engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шестигранний шар', + layer: 'Шар шестикутників', hexes: 'Гекси', named: 'Іменовані гекси', - icons: 'Жетони розташування', - glimpsed: 'Помітені прокляття', - pending: 'Локації очікують на заповнення', - calibrated: 'Відкалібрований', - overrides: 'Перевизначення сторінок', + icons: 'Маркери локацій', + glimpsed: 'Гекси в проблиску', + pending: 'Локації, що чекають на заповнення', + calibrated: 'Відкалібровано', + overrides: 'Перевизначення сторінки', undo: 'Доступне скасування', }, messages: { @@ -165,7 +165,7 @@ const TRANSLATION = { revealed: 'Розкрито гекси: {count}.', revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: - 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', resetPage: 'Зі сторінки видалено шестигранники: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', @@ -183,11 +183,11 @@ const TRANSLATION = { 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: - 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', pruned: - 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + 'Забуто збережені гекси, яких більше не існує: {dropped}. Якщо цю гру чи сторінку було скопійовано, виконайте «Пересканувати» на сторінці, щоб знову знайти її гекси.', readyHint: - 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + 'Введіть !hexploration, щоб відкрити меню, або відкрийте роздатковий матеріал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -197,7 +197,7 @@ const TRANSLATION = { }, errors: { noPage: 'Не вдалося знайти сторінку для роботи.', - notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', emptyArea: 'Вибрана область не містить шестигранних центрів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', @@ -216,8 +216,7 @@ const TRANSLATION = { }, hints: { noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', - notHex: - 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + notHex: 'Установіть для сітки сторінки Hex (V) або Hex (H) у налаштуваннях сторінки.', noPolygons: 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', @@ -248,22 +247,20 @@ const TRANSLATION = { set: 'Змінити налаштування або показати всі налаштування.', pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', - rescan: - 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: - 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + 'Вирівняйте гексову сітку за одним або двома вибраними маркерами, прив’язаними до центрів гексів.', calibrateReset: 'Видалити калібрування поточної сторінки.', status: 'Покажіть, що Hexploration знає про поточну сторінку.', - journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + journal: 'Перебудуйте роздаткові матеріали «Довідка» та «Command Deck».', help: 'Покажіть цей список.', handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', }, deck: { - subtitle: 'Командна колода', drawDesc: - 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + 'Обведіть область фігурами, виділіть їх і натисніть «Заповнити». «Скасувати заповнення» скасовує останнє заповнення.', revealDesc: - 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + 'Виділіть гекси, фігури або маркери, щоб розкрити їх або знову приховати. «Дослідити» розкриває гекси навколо вибраних маркерів, ніби вони туди перемістилися.', locationsDesc: 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', toolsDesc: @@ -272,7 +269,7 @@ const TRANSLATION = { }, handout: { versionLabel: 'Версія', - subtitle: 'Шістнадцяткове дослідження для Roll20', + subtitle: 'Дослідження гекс за гексом для Roll20', footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', @@ -284,9 +281,9 @@ const TRANSLATION = { steps: [ 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', - 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', - 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', - 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + 'Виберіть фігури та натисніть «Заповнити» в Command Deck (або введіть !hexploration fill). Фігури буде замінено гексами.', + 'Додатково: перед заповненням виділіть маркери важливих місць і натисніть «Позначити локацію». Вони сховаються під гексами, а коли їх виявлять, про це буде оголошено.', + 'Перемістіть маркер гравця. Кожен гекс, через який він проходить, і гекси в межах його «Дальності огляду» розкриваються.', ], }, commands: { @@ -299,29 +296,29 @@ const TRANSLATION = { revealing: { heading: 'Як працює розкриття', points: [ - 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', - 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', - 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', - 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', - 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', + 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів. З увімкненою «Лінією видимості» гекс розкривається, лише якщо між ним і маркером немає закритого гекса.', + '«Відстань розкриття шестикутників» зберігається в гексах під час їх малювання. Такі гекси розкриваються лише з відстані, не більшої за цю кількість гексів, хоч би як далеко бачив маркер. Використовуйте її для гір або лісів, що приховують те, що за ними.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер.', + "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", + 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', ], }, locations: { heading: 'Іменовані гекси та локації', points: [ - 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', - 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', colKey: 'ключ', colName: 'Налаштування', colDesc: 'опис', @@ -331,18 +328,18 @@ const TRANSLATION = { heading: 'Jumpgate і Legacy', points: [ 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', - 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', - 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', + 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], }, upgrading: { heading: 'Оновлення з версії 1', points: [ 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', - 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Наявні гексові карти, назви, маркери локацій і налаштування оновлюються автоматично під час першого запуску.', 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', - 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + 'У версії 1 гекси міг розкривати будь-який маркер, що представляв персонажа. Щоб зберегти таку поведінку, встановіть для «Маркери, що розкривають» значення «Маркери персонажів».', ], colV1: 'Команда версії 1', colV2: 'Команда версії 2', @@ -350,18 +347,18 @@ const TRANSLATION = { troubleshooting: { heading: 'Усунення несправностей', points: [ - 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', - 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', - 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', - 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Коли маркер рухається, нічого не відбувається: перевірте, чи маркер на шарі маркерів і відповідає параметру «Маркери, що розкривають», а на сторінці є гекси (!hexploration status).', + 'Гекси зміщені відносно сітки: натисніть «Відкалібрувати», а потім перевірте маркером кілька гексів у різних частинах карти.', + 'Гекси перестали розкриватися після копіювання сторінки або гри: виконайте «Пересканувати» на сторінці.', + '«Заповнити» повідомляє, що в області немає центрів гексів: фігура має містити центр принаймні одного гекса.', 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', ], }, languages: { heading: 'Мови', - body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + body: 'Виберіть мову командою !hexploration set language. Доступні мови:', colLanguage: 'Мова', - colNative: 'Рідна назва', + colNative: 'Самоназва', colCode: 'Код', }, credits: { diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index e2bc8c6354..e29801b0d2 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -1,80 +1,80 @@ const TRANSLATION = { titles: { - ready: 'H探索已準備就緒。', - settings: 'H探索設置', + ready: 'Hexploration 已就緒。', + settings: 'Hexploration 設定', languages: '選擇語言', pageSettings: '頁面設定：{page}', - status: 'H探索狀態：{page}', - help: '探索命令', + status: 'Hexploration 狀態：{page}', + help: 'Hexploration 指令', confirm: '請確認', }, discovery: { title: '發現地點', }, menu: { - draw: '畫', - reveal: '顯示和隱藏', + draw: '繪製', + reveal: '揭示與隱藏', locations: '地點', tools: '工具', layerInUse: '正在 {layer} 上繪製新的六角形。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', undo: '撤銷填充', reveal: '揭示', conceal: '隱藏', explore: '探索', - revealPage: '顯示頁面', + revealPage: '揭示整頁', resetPage: '重置頁面', - mark: '標記位置', + mark: '標記地點', unmark: '取消標記', - name: '名稱十六進位', + name: '命名六角格', settings: '設定', pageSettings: '頁面設定', - status: '地位', + status: '狀態', rescan: '重新掃描', calibrate: '校準', calibrateReset: '重置校準', - help: '幫助', - change: '改變', + help: '說明', + change: '變更', menu: '選單', - clearOverrides: '清除覆蓋', - confirmReset: '是的，刪除所有六角形', + clearOverrides: '清除覆寫', + confirmReset: '是，移除所有六角格', }, prompts: { name: '地點名稱（留空以清除）', }, values: { - on: '在', - off: '離開', - none: '沒有任何', + on: '開', + off: '關', + none: '無', hexLayer: { - auto: '自動（前景，如果可用）', + auto: '自動（可用時使用前景層）', foreground: '前景層', objects: '令牌層', }, revealBy: { - players: '玩家代幣', - characters: '字元標記', - all: '所有代幣', + players: '玩家令牌', + characters: '角色令牌', + all: '所有令牌', }, revealMode: { clear: '清除', - glimpse: '一瞥', + glimpse: '瞥見', }, announce: { - all: '每個人', - gm: '限通用汽車', - off: '離開', + all: '所有人', + gm: '僅限 GM', + off: '關', }, orientation: { - vertical: '六角 (V)', - horizontal: '六角 (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', conceal: '隱藏', }, @@ -85,12 +85,12 @@ const TRANSLATION = { desc: '選單、訊息和講義的語言。', }, hexLayer: { - label: '六角層', + label: '六角格圖層', desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', }, fillColor: { label: '填充顏色', - desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', + desc: '新六角格的顏色。若要讓六角格半透明，請使用 rgba()，例如 rgba(0,0,0,0.8)。', }, strokeColor: { label: '邊框顏色', @@ -102,14 +102,14 @@ const TRANSLATION = { }, glimpseColor: { label: '瞥見顏色', - desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', + desc: '六角格被瞥見時變成的顏色（「瞥見」揭示模式）。請使用半透明的 rgba() 顏色。', }, strokeWidth: { label: '邊框寬度', desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { - label: '十六進位顯示距離', + label: '六角格揭示距離', desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', }, revealDistance: { @@ -125,46 +125,46 @@ const TRANSLATION = { desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', }, revealBy: { - label: '揭示的代幣', - desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', + label: '可揭示的令牌', + desc: '令牌層上哪些令牌會揭示六角格：由玩家控制的令牌、代表任何角色的令牌，或所有令牌。', }, revealMode: { label: '揭示模式', - desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', + desc: '清除會移除視線範圍內的六角格。瞥見則改為讓六角格變得半透明；令牌進入時才將其移除。', }, announce: { - label: '宣布發現', + label: '公告發現', desc: '當發現指定位置時誰會看到聊天訊息。', }, pingDiscoveries: { - label: '平發現', + label: '標示發現位置', desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', }, hideCoveredTokens: { - label: '隱藏覆蓋的令牌', + label: '隱藏被覆蓋的令牌', desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', }, }, status: { engine: '遊戲引擎', grid: '網格', - layer: '六角層', - hexes: '六角形', - named: '命名六角形', - icons: '位置標記', - glimpsed: '瞥見的六角形', - pending: '等待填補的地點', + layer: '六角格圖層', + hexes: '六角格', + named: '已命名的六角格', + icons: '地點令牌', + glimpsed: '被瞥見的六角格', + pending: '等待填充的地點', calibrated: '已校準', - overrides: '頁面覆蓋', - undo: '可以撤銷', + overrides: '頁面覆寫', + undo: '可撤銷', }, messages: { filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', revealed: '六角形顯示：{count}。', - revealedPage: '顯示頁面上的每個十六進位 ({count})。', + revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: - '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', - resetPage: '從頁面中刪除的十六進位：{count}。', + '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', + resetPage: '已從頁面移除的六角格：{count}。', undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', named: '名為「{name}」的六角形：{count}。', unnamed: '已清除的名稱：{count}。', @@ -178,10 +178,10 @@ const TRANSLATION = { calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: - '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', - readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', + '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', + readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', @@ -208,7 +208,7 @@ const TRANSLATION = { }, hints: { noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', - notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + notHex: '請在頁面設定中將頁面網格設為 Hex (V) 或 Hex (H)。', noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', @@ -217,7 +217,7 @@ const TRANSLATION = { unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', - calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { @@ -226,49 +226,48 @@ const TRANSLATION = { fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', - revealPage: '顯示頁面上的每個十六進制，無需公告。', + revealPage: '揭示頁面上的所有六角格，不發布公告。', conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', - resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + resetPage: '移除頁面上的所有六角格（會先確認）。', name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', mark: '將選取的標記變成隱藏位置。', unmark: '停止將選定的標記隱藏在位置。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', - rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', - journal: '重建幫助和命令平台講義。', + journal: '重建說明與 Command Deck 講義。', help: '顯示此清單。', handout: '完整說明位於「{name}」講義。', }, deck: { - subtitle: '指揮台', - drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', + drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', - locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', }, handout: { versionLabel: '版本', - subtitle: 'Roll20 的逐十六進位探索', + subtitle: 'Roll20 的逐格六角格探索', footer: '使用“{deck}”講義進行一鍵式控制項。', overview: { heading: '概述', - body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + body: 'Hexploration 以不透明的六角格覆蓋六角格地圖。隊伍移動時，他們經過的六角格（以及你願意的話，周圍的六角格）會被移除，讓地圖一格一格地揭開。隱藏地點可以放在六角格下方，被找到時會公告。它適用於 Jumpgate 和 Legacy 遊戲，以及任何大小的 Hex (V) 和 Hex (H) 網格。', demo: '觀看簡短的演示（來自版本 1）', }, quickStart: { heading: '快速入門', steps: [ - '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '開啟網格設為 Hex (V) 或 Hex (H) 的頁面。', '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', - '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', - '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', + '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', ], }, @@ -282,40 +281,40 @@ const TRANSLATION = { revealing: { heading: '揭示如何運作', points: [ - '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', - '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', - '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + '「六角格揭示距離」會在六角格繪製時儲存在六角格上。無論令牌能看多遠，這些六角格都只會在該格數範圍內被揭示。可用於遮擋後方景物的山脈或森林。', + '在「瞥見」模式中，視線內的六角格會變為半透明而非消失，並在令牌進入時被移除。', + 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', + 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', ], }, locations: { heading: '命名六角形和位置', points: [ - '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', - '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', - 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', - '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', + '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', ], }, settings: { heading: '設定', intro: - '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', colKey: '鑰匙', colName: '環境', colDesc: '描述', perPage: '（可按頁設定。）', }, jumpgate: { - heading: '跳躍門和遺產', + heading: 'Jumpgate 與 Legacy', points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', - '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', - 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', ], }, @@ -323,9 +322,9 @@ const TRANSLATION = { heading: '從版本 1 升級', points: [ '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', - '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', - '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', - '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', + '現有的六角格地圖、名稱、地點令牌與設定會在首次啟動時自動升級。', + '版本 1 的指令（包括 Hexploration_menu 巨集）仍然有效。', + '版本 1 允許任何代表角色的令牌揭示六角格。若要保留此行為，請將「可揭示的令牌」設為「角色令牌」。', ], colV1: '版本 1 指令', colV2: '版本 2 指令', @@ -333,18 +332,18 @@ const TRANSLATION = { troubleshooting: { heading: '故障排除', points: [ - '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', - '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', - 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', + '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { heading: '語言', - body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', - colNative: '原生名', + colNative: '原文名稱', colCode: '程式碼', }, credits: { From 23f66bd182f1bc2b62778bf23728332a3d39fdb7 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 15:56:46 +0000 Subject: [PATCH 11/24] feat(Hexploration): Show language flags as Twemoji images Roll20 on Windows shows emoji flags as letter pairs, so flags drawn from an emoji font are unreliable. Draw each locale's flag as a Twemoji SVG image, as ConditionTracker does: before each code in the Help handout's language table, on the language picker buttons, and beside the current language on the settings card. Rebuild the script and the 2.0.0 snapshot. Signed-off-by: Steve Roberts --- Hexploration/2.0.0/Hexploration.js | 3844 ++++++++++++++-------------- Hexploration/Hexploration.js | 3844 ++++++++++++++-------------- Hexploration/src/chat.js | 36 +- Hexploration/src/commands.js | 17 +- Hexploration/src/journals.js | 9 +- 5 files changed, 3916 insertions(+), 3834 deletions(-) diff --git a/Hexploration/2.0.0/Hexploration.js b/Hexploration/2.0.0/Hexploration.js index d8d4f47859..062b681f65 100644 --- a/Hexploration/2.0.0/Hexploration.js +++ b/Hexploration/2.0.0/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T14:33:58.218Z + * Built: 2026-10-29T15:52:46.956Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T14:33:58.218Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T15:52:46.956Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -34,7 +34,9 @@ const HexplorationMod = (() => { const LEGACY_ARG_SEPARATOR = '&&'; const HANDOUT_HELP_NAME = 'Hexploration - Help'; - const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; + // The deck's name is not translated, so it always matches the handout's name. + const DECK_TITLE = 'Command Deck'; + const HANDOUT_DECK_NAME = `Hexploration - ${DECK_TITLE}`; const AUTHOR_LINKS = { original: { @@ -529,10 +531,42 @@ const HexplorationMod = (() => { * * @param {string} label Button label. * @param {string} command Chat command the button runs. + * @param {string} [prefixHtml=''] Trusted HTML shown before the label, such as a flag. * @returns {string} HTML anchor. */ - function buildSecondaryButton(label, command) { - return `${escapeHtml(label)}`; + function buildSecondaryButton(label, command, prefixHtml = '') { + return `${prefixHtml}${escapeHtml(label)}`; + } + + /** + * Builds a Twemoji asset URL for a locale flag. + * + * @param {string} flag Unicode regional-indicator flag. + * @returns {string} SVG asset URL or an empty string. + */ + function flagAssetUrl(flag) { + const codepoints = Array.from(String(flag || '').trim()) + .map((character) => character.codePointAt(0).toString(16)) + .join('-'); + return codepoints + ? `https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/${codepoints}.svg` + : ''; + } + + /** + * Builds a locale's flag as a Twemoji image. Roll20 on Windows shows emoji + * flags as letter pairs, so the flag is drawn from an SVG instead. + * + * @param {object} locale Locale metadata. + * @returns {string} Trusted flag HTML, or an empty string when there is no flag. + */ + function buildLocaleFlag(locale) { + const label = escapeHtml(locale?.flagLabel || locale?.name || ''); + const url = flagAssetUrl(locale?.flag); + if (!url) { + return ''; + } + return `${label}`; } /** @@ -1104,12 +1138,12 @@ const HexplorationMod = (() => { const TRANSLATION$m = { titles: { - ready: 'Heeksplorasie is gereed.', - settings: 'Heksplorasie-instellings', + ready: 'Hexploration is gereed.', + settings: 'Hexploration-instellings', languages: "Kies 'n taal", pageSettings: 'Bladsyinstellings: {page}', - status: 'Heksplorasiestatus: {page}', - help: 'Heksplorasie-opdragte', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdragte', confirm: 'Bevestig asseblief', }, discovery: { @@ -1120,14 +1154,14 @@ const HexplorationMod = (() => { reveal: 'Openbaar en versteek', locations: 'Liggings', tools: 'Gereedskap', - layerInUse: 'Nuwe hekse word op die {layer} geteken.', + layerInUse: 'Nuwe seshoeke word op die {layer} geteken.', pageSettingsHelp: - 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', + 'Hierdie instellings geld slegs vir hierdie bladsy. Instellings gemerk met ★ oorskryf die globale instellings.', }, buttons: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', - undo: 'Ontdoen vul', + fillInverse: 'Omgekeerde vulling', + undo: 'Ontdoen vulling', reveal: 'Onthul', conceal: 'Versteek', explore: 'Verken', @@ -1135,18 +1169,18 @@ const HexplorationMod = (() => { resetPage: 'Stel bladsy terug', mark: 'Merk ligging', unmark: 'Ontmerk', - name: 'Noem Hex', + name: 'Benoem seshoek', settings: 'Instellings', pageSettings: 'Bladsy-instellings', status: 'Status', rescan: 'Skandeer weer', calibrate: 'Kalibreer', - calibrateReset: 'Stel Kalibrasie terug', - help: 'Help', + calibrateReset: 'Stel kalibrasie terug', + help: 'Hulp', change: 'Verander', - menu: 'Spyskaart', + menu: 'Kieslys', clearOverrides: 'Vee oorskrywings uit', - confirmReset: 'Ja, verwyder alle hekse', + confirmReset: 'Ja, verwyder alle seshoeke', }, prompts: { name: 'Liggingnaam (laat leeg om skoon te maak)', @@ -1157,17 +1191,17 @@ const HexplorationMod = (() => { none: 'Geen', hexLayer: { auto: 'Outo (voorgrond indien beskikbaar)', - foreground: 'voorgrond laag', - objects: 'tekenlaag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Speler tokens', - characters: 'Karaktertekens', - all: 'Alle tekens', + players: 'Speler-tokens', + characters: 'Karaktertokens', + all: 'Alle tokens', }, revealMode: { - clear: 'Duidelik', - glimpse: 'Glimpie', + clear: 'Verwyder', + glimpse: 'Glimp', }, announce: { all: 'Almal', @@ -1175,109 +1209,109 @@ const HexplorationMod = (() => { off: 'Af', }, orientation: { - vertical: 'Heks (V)', - horizontal: 'Heks (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', + fillInverse: 'Omgekeerde vulling', conceal: 'Versteek', }, }, settings: { language: { label: 'Taal', - desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', + desc: 'Taal vir kieslyste, boodskappe en uitdeelstukke.', }, hexLayer: { - label: 'Hex laag', - desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', + label: 'Seshoeklaag', + desc: 'Waar nuwe seshoeke geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die tokenlaag as die speletjie dit nie ondersteun nie.', }, fillColor: { - label: 'Vul kleur', - desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', + label: 'Vulkleur', + desc: 'Kleur van nuwe seshoeke. Gebruik rgba() vir deursigtige seshoeke, byvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Rand Kleur', - desc: 'Kleur van die buitelyn van nuwe hekse.', + label: 'Randkleur', + desc: 'Kleur van die buitelyn van nuwe seshoeke.', }, labelColor: { - label: 'Etiket Kleur', - desc: 'Kleur van die GM-net naametikette op benoemde hekse.', + label: 'Etiketkleur', + desc: 'Kleur van die naametikette wat net die GM sien, op benoemde seshoeke.', }, glimpseColor: { - label: 'Glimp kleur', - desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + label: 'Glimpkleur', + desc: "Kleur waarna seshoeke verander wanneer hulle deurskynend word (Glimp-onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", }, strokeWidth: { - label: 'Grens breedte', - desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', + label: 'Randdikte', + desc: 'Dikte van die buitelyn van nuwe seshoeke, in pieksels (0 tot 20).', }, maxDistance: { - label: 'Hex Reveal Distance', - desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + label: 'Seshoek-onthullingsafstand', + desc: "Word op seshoeke toegepas wanneer hulle geteken word: 'n token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", }, revealDistance: { label: 'Sigafstand', - desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + desc: "Hoeveel seshoeke rondom 'n bewegende token onthul word (0 tot 20). 0 onthul slegs die seshoeke waardeur die token beweeg.", }, lineOfSight: { label: 'Siglyn', - desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + desc: "Wanneer dit aan is, word 'n seshoek slegs onthul as geen bedekte seshoek tussen dit en die token lê nie.", }, revealPath: { - label: 'Openbaar Langs Pad', - desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + label: 'Onthul langs pad', + desc: "Wanneer dit aan is, word elke seshoek waardeur 'n token beweeg terwyl dit gesleep word (insluitend tussenpunte), onthul, nie net waar dit stop nie.", }, revealBy: { - label: 'Tekens wat openbaar', - desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + label: 'Tokens wat onthul', + desc: "Watter tokens op die tokenlaag seshoeke onthul: tokens wat deur 'n speler beheer word, tokens wat enige karakter verteenwoordig, of elke token.", }, revealMode: { label: 'Onthullingsmodus', - desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + desc: "Met Verwyder word seshoeke binne sig verwyder. Met Glimp word hulle eerder deurskynend; hulle word verwyder wanneer 'n token hulle binnegaan.", }, announce: { label: 'Kondig ontdekkings aan', desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", }, pingDiscoveries: { - label: 'Ping Ontdekkings', + label: 'Ping ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, hideCoveredTokens: { - label: 'Versteek bedekte tekens', - desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + label: 'Versteek bedekte tokens', + desc: "Roll20 teken name, balke en auras bo seshoeke. Wanneer dit aan is, word die naam, balke en auras wat spelers kan sien, afgeskakel vir tokens onder 'n bedekte seshoek, en weer aangeskakel wanneer hulle ontbloot word.", }, }, status: { - engine: 'Spel enjin', + engine: 'Spelenjin', grid: 'Rooster', - layer: 'Hex laag', - hexes: 'Hekse', - named: 'Benoemde hekse', - icons: 'Liggingtekens', - glimpsed: 'Geskimpte hekkies', - pending: "Liggings wat wag vir 'n vulling", + layer: 'Seshoeklaag', + hexes: 'Seshoeke', + named: 'Benoemde seshoeke', + icons: 'Liggingtokens', + glimpsed: 'Deurskynende seshoeke', + pending: "Liggings wat op 'n vulling wag", calibrated: 'Gekalibreer', - overrides: 'Bladsy ignoreer', + overrides: 'Bladsy-oorskrywings', undo: 'Ontdoen beskikbaar', }, messages: { filled: - 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', - revealed: 'Hekse geopenbaar: {count}.', - revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', + 'Vulling voltooi. Seshoeke geteken: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Seshoeke onthul: {count}.', + revealedPage: 'Elke seshoek op die bladsy is onthul ({count}).', confirmReset: - 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: 'Hekse verwyder van die bladsy: {count}.', + 'Verwyder elke seshoek van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Seshoeke van die bladsy verwyder: {count}.', undone: - 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', - named: 'Hekse genaamd "{name}": {count}.', + 'Laaste vulling ontdoen. Seshoeke verwyder: {removed}. Herstileerde seshoeke herstel: {restored}.', + named: 'Seshoeke benoem as "{name}": {count}.', unnamed: 'Name skoongemaak: {count}.', marked: - 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', - unmarked: 'Tekens wat nie meer liggings is nie: {count}.', + 'Liggings versteek in bestaande seshoeke: {attached}. Wag vir die volgende vulling wat hulle bedek: {pending}.', + unmarked: 'Tokens wat nie meer liggings is nie: {count}.', settingChanged: '{setting} gestel na {value}.', rescanned: 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', @@ -1287,35 +1321,35 @@ const HexplorationMod = (() => { 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: - "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + "Jou Hexploration 1.x-seshoekkaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, gebruik Skandeer weer op elke seshoekkaartbladsy.", pruned: - 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + 'Gestoorde seshoeke wat nie meer bestaan nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, gebruik Skandeer weer op die bladsy om sy seshoeke weer op te tel.', readyHint: - 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + 'Tik !hexploration vir die kieslys, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, warnings: { foregroundUnavailable: - 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', + 'Hierdie speletjie ondersteun nie teken op die voorgrondlaag nie, dus is die seshoeke op die tokenlaag geteken.', someFailed: - 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', + 'Seshoeke wat nie geteken kon word nie: {count}. Kyk in die API-konsole vir besonderhede.', }, errors: { noPage: 'Kon nie die bladsy vind om aan te werk nie.', - notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + notHex: "Hierdie bladsy gebruik nie 'n seshoekrooster nie.", noPolygons: 'Kies een of meer getekende vorms om te vul.', - emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', - tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', - nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', - nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', - noTokens: 'Kies eers een of meer tekens.', - noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + emptyArea: 'Die geselekteerde gebied bevat geen seshoekmiddelpunte nie.', + tooMany: 'Dit sal te veel seshoeke op een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tokens om te versteek.', + nothingToReveal: 'Kies seshoeke, getekende vorms of tokens om te onthul.', + noTokens: 'Kies eers een of meer tokens.', + noHexes: 'Kies eers een of meer seshoeke (of tokens wat op seshoeke staan).', nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', unknownCommand: 'Onbekende opdrag: {command}', unknownSetting: 'Onbekende instelling: {key}', unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', - calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', - calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateFailed: 'Daardie tokens kan nie gebruik word om te kalibreer nie.', unexpected: 'Iets het verkeerd geloop: {message}', }, hints: { @@ -1324,63 +1358,62 @@ const HexplorationMod = (() => { noPolygons: "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", - tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', + tooMany: "Vul 'n kleiner gebied, of verdeel die gebied in verskeie vorms.", noHexes: - 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + 'Seshoeke is op die voorgrond- of tokenlaag; skakel oor na daardie laag om hulle te kies.', unknownCommand: 'Tik !hexploration help om die opdragte te lys.', unknownSetting: 'Tik !hexploration set om elke instelling te sien.', calibrateNeedsTokens: - "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + "Klik 'n token vas in die middel van 'n seshoek en kies dit. Kies 'n tweede token wat op 'n naburige seshoek in dieselfde ry (Hex V) of kolom (Hex H) vasgeklik is om ook die seshoekgrootte reg te stel.", calibrateFailed: - 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + 'Die twee tokens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, minstens een seshoek uitmekaar.', unexpected: 'Besonderhede is in die API-konsole-logboek.', }, help: { - menu: 'Wys die spyskaart.', - fill: 'Bedek die geselekteerde getekende vorms met hekse.', + menu: 'Wys die kieslys.', + fill: 'Bedek die geselekteerde getekende vorms met seshoeke.', fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', reveal: - 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', - revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', - conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', - explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', - resetPage: 'Verwyder elke heks op die bladsy (vra eers).', - name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', - mark: 'Verander die geselekteerde tekens in versteekte liggings.', + 'Onthul die geselekteerde seshoeke, en die seshoeke onder die geselekteerde vorms en tokens.', + revealPage: 'Onthul elke seshoek op die bladsy sonder aankondigings.', + conceal: 'Bedek die gebied onder die geselekteerde vorms en tokens weer met seshoeke.', + explore: 'Onthul rondom die geselekteerde tokens asof hulle pas daarheen beweeg het.', + resetPage: 'Verwyder elke seshoek op die bladsy (vra eers).', + name: 'Benoem die geselekteerde seshoeke, of die seshoeke onder die geselekteerde tokens. Laat die naam leeg om dit uit te vee.', + mark: 'Verander die geselekteerde tokens in versteekte liggings.', unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', set: "Verander 'n instelling, of wys alle instellings.", - pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", - pageClear: 'Verwyder die huidige bladsy se ignorering.', + pageSet: "Oorskryf 'n onthullingsinstelling slegs op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se oorskrywings.', rescan: - "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + "Herbou die bladsy se seshoeklys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", calibrate: - 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + 'Belyn die seshoekrooster met een of twee geselekteerde tokens wat op seshoekmiddelpunte vasgeklik is.', calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', status: 'Wys wat Hexploration van die huidige bladsy weet.', - journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + journal: 'Herbou die Help- en Command Deck-uitdeelstukke.', help: 'Wys hierdie lys.', handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', }, deck: { - subtitle: 'Beveldek', drawDesc: "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", revealDesc: - 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', + 'Kies seshoeke, vorms of tokens om hulle te onthul of weer te bedek. Verken onthul rondom geselekteerde tokens asof hulle beweeg het.', locationsDesc: - "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + "Kies tokens om hulle as liggings onder seshoeke te versteek. Kies seshoeke of tokens om 'n seshoek te benoem.", toolsDesc: - 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', + 'Instellings, bladsy-oorskrywings, status, herskandering van gekopieerde bladsye en kalibrering van die rooster.', footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', }, handout: { versionLabel: 'Weergawe', - subtitle: 'Heks-vir-heks verkenning vir Roll20', + subtitle: 'Seshoek-vir-seshoek-verkenning vir Roll20', footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', overview: { heading: 'Oorsig', - body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + body: "Hexploration bedek 'n seshoekkaart met ondeursigtige seshoeke. Soos die groep beweeg, word die seshoeke waardeur hulle gaan (en, as jy wil, die seshoeke rondom hulle) verwyder, sodat die kaart een seshoek op 'n slag ontbloot word. Versteekte liggings kan onder seshoeke geplaas word en word aangekondig wanneer hulle gevind word. Dit werk in Jumpgate- en Legacy-speletjies, op Hex (V)- en Hex (H)-roosters van enige grootte.", demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", }, quickStart: { @@ -1388,9 +1421,9 @@ const HexplorationMod = (() => { steps: [ "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', - 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', - 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', - "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + 'Kies die vorms en klik op Vul in die Command Deck (of tik !hexploration fill). Die vorms word deur seshoeke vervang.', + 'Opsioneel: kies voor die vulling tokens vir belangrike plekke en klik Merk ligging. Hulle word onder die seshoeke versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n speler-token. Elke seshoek waardeur dit beweeg, en die seshoeke binne sy Sigafstand, word onthul.", ], }, commands: { @@ -1403,29 +1436,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hoe onthulling werk', points: [ - 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', - "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", - "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", - "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", - "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke. Met Siglyn aan, word 'n seshoek slegs onthul as geen bedekte seshoek tussenin lê nie.", + "Seshoek-onthullingsafstand word op seshoeke gestoor wanneer hulle geteken word. Daardie seshoeke word slegs van binne soveel seshoeke onthul, hoe ver 'n token ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle lê.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan.", + "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { - heading: 'Genoemde hekse en liggings', + heading: 'Benoemde seshoeke en liggings', points: [ - "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", - 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', - 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', - "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", + 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, settings: { heading: 'Instellings', intro: - 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Seshoeklaag, Tokens wat onthul en Taal kan ook op die Mod se instellingsbladsy gestel word.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beskrywing', @@ -1434,19 +1467,19 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate en Legacy', points: [ - 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', - 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', - "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", - "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + 'Hexploration bepaal watter enjin die speletjie gebruik en teken die ooreenstemmende soort vorm. Vorms wat in enige van die twee redigeerders geteken is, kan gevul word.', + 'Met Seshoeklaag op Outo gestel, word seshoeke op die voorgrondlaag bo tokens geteken, sodat spelers nie kan sien wat daaronder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tokenlaag eerder gebruik.', + "Jumpgate teken wiskundig reëlmatige seshoeke, wat 'n effens ander vorm as Legacy-seshoeke het. As die seshoeke nie met 'n bladsy se rooster belyn nie, klik 'n token vas op 'n seshoekmiddelpunt, kies dit en klik Kalibreer. Kies twee tokens in naburige seshoeke van dieselfde ry (Hex V) of kolom (Hex H) om ook die seshoekgrootte reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy seshoeke nuwe ID's. Gebruik Skandeer weer op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", ], }, upgrading: { heading: 'Opgradering vanaf weergawe 1', points: [ "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", - 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Bestaande seshoekkaarte, name, liggingtokens en instellings word met die eerste begin outomaties opgegradeer.', 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', - "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + "Weergawe 1 het enige token wat 'n karakter verteenwoordig, seshoeke laat onthul. Stel Tokens wat onthul op Karaktertokens om daardie gedrag te behou.", ], colV1: 'Weergawe 1 opdrag', colV2: 'Weergawe 2 opdrag', @@ -1454,10 +1487,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Probleemoplossing', points: [ - "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", - "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", - "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", - 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + "Niks gebeur wanneer 'n token beweeg nie: maak seker dat die token op die tokenlaag is en by Tokens wat onthul pas, en dat die bladsy seshoeke het (!hexploration status).", + "Seshoeke is van die rooster af verskuif: gebruik Kalibreer en kyk dan met 'n token op 'n paar seshoeke oor die kaart heen.", + "Seshoeke word nie meer onthul nadat 'n bladsy of speletjie gekopieer is nie: gebruik Skandeer weer op die bladsy.", + 'Vul sê die gebied het geen seshoekmiddelpunte nie: die vorm moet die middelpunt van ten minste een seshoek bevat.', 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', ], }, @@ -1465,7 +1498,7 @@ const HexplorationMod = (() => { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { @@ -1481,61 +1514,61 @@ const HexplorationMod = (() => { const TRANSLATION$l = { titles: { - ready: "L'exploració està a punt.", - settings: "Configuració d'exploració", + ready: 'Hexploration està a punt.', + settings: "Configuració d'Hexploration", languages: 'Trieu un idioma', pageSettings: 'Configuració de la pàgina: {page}', - status: "Estat de l'exploració: {page}", - help: "Comandes d'exploració", + status: "Estat d'Hexploration: {page}", + help: "Comandes d'Hexploration", confirm: 'Si us plau, confirmeu', }, discovery: { - title: 'Localització descoberta', + title: 'Ubicació descoberta', }, menu: { draw: 'Dibuixa', reveal: 'Revela i amaga', locations: 'Ubicacions', tools: 'Eines', - layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + layerInUse: "S'estan dibuixant hexàgons nous a la {layer}.", pageSettingsHelp: "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", }, buttons: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - undo: 'Desfer el farciment', - reveal: 'Revelar', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + undo: "Desfés l'emplenament", + reveal: 'Revela', + conceal: 'Amaga', explore: 'Explora', revealPage: 'Revela la pàgina', resetPage: 'Restableix la pàgina', mark: 'Marca la ubicació', unmark: 'Desmarca', - name: 'Nom Hex', + name: "Anomena l'hexàgon", settings: 'Configuració', pageSettings: 'Configuració de la pàgina', status: 'Estat', rescan: 'Torna a escanejar', - calibrate: 'Calibrar', + calibrate: 'Calibra', calibrateReset: 'Restableix la calibració', help: 'Ajuda', - change: 'Canviar', + change: 'Canvia', menu: 'Menú', clearOverrides: 'Esborra les substitucions', - confirmReset: 'Sí, traieu tots els hexagones', + confirmReset: 'Sí, elimina tots els hexàgons', }, prompts: { name: 'Nom de la ubicació (deixeu en blanc per esborrar)', }, values: { - on: 'Encès', - off: 'Apagat', + on: 'Activat', + off: 'Desactivat', none: 'Cap', hexLayer: { - auto: 'Automàtic (en primer pla si està disponible)', + auto: 'Automàtic (primer pla si està disponible)', foreground: 'capa de primer pla', - objects: 'capa de testimoni', + objects: 'capa de fitxes', }, revealBy: { players: 'Fitxes de jugador', @@ -1543,22 +1576,22 @@ const HexplorationMod = (() => { all: 'Totes les fitxes', }, revealMode: { - clear: 'Clar', - glimpse: "Un cop d'ull", + clear: 'Neteja', + glimpse: "Cop d'ull", }, announce: { all: 'Tothom', - gm: 'Només GM', - off: 'Apagat', + gm: 'Només el GM', + off: 'Desactivat', }, orientation: { - vertical: 'Hexadecimal (V)', + vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + conceal: 'Amaga', }, }, settings: { @@ -1567,12 +1600,12 @@ const HexplorationMod = (() => { desc: 'Idioma per a menús, missatges i fullets.', }, hexLayer: { - label: 'Capa hexagonal', - desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + label: 'Capa dels hexàgons', + desc: "On es dibuixen els hexàgons nous. Automàtic prova la capa de primer pla (per sobre de les fitxes) i recorre a la capa de fitxes si el joc no l'admet.", }, fillColor: { label: 'Color de farciment', - desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', + desc: 'Color dels hexàgons nous. Utilitzeu rgba() per a hexàgons transparents, per exemple rgba(0,0,0,0.8).', }, strokeColor: { label: 'Color de la vora', @@ -1580,18 +1613,18 @@ const HexplorationMod = (() => { }, labelColor: { label: "Color de l'etiqueta", - desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', + desc: 'Color de les etiquetes de nom, visibles només per al GM, dels hexàgons amb nom.', }, glimpseColor: { - label: "Color d'ull", - desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', + label: "Color de cop d'ull", + desc: "Color que prenen els hexàgons quan es veuen de cop d'ull (mode de revelació Cop d'ull). Utilitzeu un color rgba() transparent.", }, strokeWidth: { label: 'Amplada de la vora', - desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', + desc: 'Amplada del contorn dels hexàgons nous, en píxels (de 0 a 20).', }, maxDistance: { - label: 'Distància de revelació hexagonal', + label: 'Distància de revelació dels hexàgons', desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", }, revealDistance: { @@ -1612,14 +1645,14 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Mode de revelació', - desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + desc: "Neteja elimina els hexàgons a la vista. Cop d'ull, en canvi, els fa transparents; s'eliminen quan hi entra una fitxa.", }, announce: { label: 'Anunciar descobriments', desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', }, pingDiscoveries: { - label: 'Ping Descobriments', + label: 'Fer ping als descobriments', desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', }, hideCoveredTokens: { @@ -1630,30 +1663,30 @@ const HexplorationMod = (() => { status: { engine: 'Motor de joc', grid: 'Quadrícula', - layer: 'Capa hexagonal', - hexes: 'Hexes', - named: 'Hexagones anomenats', + layer: 'Capa dels hexàgons', + hexes: 'Hexàgons', + named: 'Hexàgons amb nom', icons: "Fitxes d'ubicació", - glimpsed: 'Hexagones albirats', - pending: "Ubicacions a l'espera d'omplir-se", + glimpsed: 'Hexàgons albirats', + pending: "Ubicacions pendents d'emplenament", calibrated: 'Calibrat', - overrides: 'Anul·lació de la pàgina', - undo: 'Desfer disponible', + overrides: 'Substitucions de la pàgina', + undo: 'Es pot desfer', }, messages: { filled: - 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', revealed: 'Hexagones revelats: {count}.', - revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", + revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: - 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', + 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', + resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', - named: 'Hexadecimals anomenats "{name}": {count}.', + named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: - 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + 'Ubicacions amagades en hexàgons existents: {attached}. Pendents del següent farciment que les cobreixi: {pending}.', unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: @@ -1664,11 +1697,11 @@ const HexplorationMod = (() => { "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: - "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", pruned: - "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexàgons desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Torna a escanejar a la pàgina per recuperar-ne els hexàgons.", readyHint: - 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + 'Escriviu !hexploration per obrir el menú o obriu el fullet "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -1678,7 +1711,7 @@ const HexplorationMod = (() => { }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", - notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", tooMany: "Això crearia massa hexagones d'una vegada ({count}).", @@ -1705,13 +1738,13 @@ const HexplorationMod = (() => { 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", noHexes: - 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + 'Els hexàgons són a la capa de primer pla o a la de fitxes; canvieu a aquesta capa per seleccionar-los.', unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', calibrateNeedsTokens: - "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Col·loqueu una fitxa al centre d'un hexàgon i seleccioneu-la. Seleccioneu una segona fitxa ajustada a un hexàgon veí de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", calibrateFailed: - "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + "Les dues fitxes han d'estar a la mateixa fila (Hex V) o a la mateixa columna (Hex H), separades almenys per un hexàgon.", unexpected: "Els detalls es troben al registre de la consola de l'API.", }, help: { @@ -1721,10 +1754,10 @@ const HexplorationMod = (() => { undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", reveal: 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', - revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", - resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', @@ -1732,30 +1765,29 @@ const HexplorationMod = (() => { pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: - 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', + "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', - journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", help: 'Mostra aquesta llista.', handout: 'Les instruccions completes es troben al fullet "{name}".', }, deck: { - subtitle: 'Comandament de la plataforma', drawDesc: - "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfés l'emplenament reverteix l'últim emplenament.", revealDesc: - "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + "Selecciona hexàgons, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revela el voltant de les fitxes seleccionades com si s'haguessin mogut.", locationsDesc: - 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', + 'Seleccioneu fitxes per amagar-les com a ubicacions sota els hexàgons. Seleccioneu hexàgons o fitxes per posar nom a un hexàgon.', toolsDesc: 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', }, handout: { versionLabel: 'Versió', - subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', + subtitle: 'Exploració hexàgon a hexàgon per a Roll20', footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', @@ -1767,7 +1799,7 @@ const HexplorationMod = (() => { steps: [ 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", - "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + 'Seleccioneu les formes i feu clic a Omple al Command Deck (o escriviu !hexploration fill). Les formes se substitueixen per hexàgons.', "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', ], @@ -1782,12 +1814,12 @@ const HexplorationMod = (() => { revealing: { heading: 'Com funciona la revelació', points: [ - 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', - "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", - "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", - "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", - "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", + "La distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons. Amb Línia de visió activada, un hexàgon només es revela si no hi ha cap hexàgon cobert entremig.", + "La distància de revelació dels hexàgons s'emmagatzema als hexàgons quan es dibuixen. Aquests hexàgons només es revelen des d'un màxim d'aquest nombre d'hexàgons, per lluny que pugui veure una fitxa. Utilitzeu-la per a muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, @@ -1797,14 +1829,14 @@ const HexplorationMod = (() => { "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", - "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", - "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], }, settings: { heading: 'Configuració', intro: - "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', colKey: 'clau', colName: 'Configuració', colDesc: 'Descripció', @@ -1814,18 +1846,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate i Legacy', points: [ 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', - "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", - "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", - "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + "Amb Capa dels hexàgons establerta a Automàtic, els hexàgons es dibuixen a la capa de primer pla, per sobre de les fitxes, perquè els jugadors no puguin veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de fitxes.", + "Jumpgate dibuixa hexàgons matemàticament regulars, que tenen una forma lleugerament diferent dels hexàgons de Legacy. Si els hexàgons no s'alineen amb la graella d'una pàgina, ajusteu una fitxa al centre d'un hexàgon, seleccioneu-la i feu clic a Calibra. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + "Quan es copia una pàgina o un joc, els seus hexàgons reben identificadors nous. Executeu Torna a escanejar a la pàgina per tornar-los a recuperar, juntament amb les etiquetes de nom i les fitxes d'ubicació.", ], }, upgrading: { heading: 'Actualització de la versió 1', points: [ 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', - "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + "Els mapes d'hexàgons, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament la primera vegada que s'inicia.", 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', - 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], colV1: 'Comandament de la versió 1', colV2: 'Comandament de la versió 2', @@ -1833,10 +1865,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Resolució de problemes', points: [ - 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', - 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', - 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', - "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + 'No passa res quan es mou una fitxa: comproveu que la fitxa és a la capa de fitxes i que coincideix amb Fitxes que revelen, i que la pàgina té hexàgons (!hexploration status).', + 'Els hexàgons estan desplaçats respecte de la quadrícula: utilitzeu Calibra i, a continuació, comproveu-ho amb una fitxa en uns quants hexàgons del mapa.', + 'Els hexàgons han deixat de revelar-se després de copiar una pàgina o un joc: executeu Torna a escanejar a la pàgina.', + "Omple diu que l'àrea no té centres d'hexàgon: la forma ha de contenir el centre d'almenys un hexàgon.", "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", ], }, @@ -1844,7 +1876,7 @@ const HexplorationMod = (() => { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", colLanguage: 'Llengua', - colNative: 'Nom nadiu', + colNative: 'Nom original', colCode: 'Codi', }, credits: { @@ -1860,81 +1892,81 @@ const HexplorationMod = (() => { const TRANSLATION$k = { titles: { - ready: 'H探索已準備就緒。', - settings: 'H探索設置', + ready: 'Hexploration 已就緒。', + settings: 'Hexploration 設定', languages: '選擇語言', pageSettings: '頁面設定：{page}', - status: 'H探索狀態：{page}', - help: '探索命令', + status: 'Hexploration 狀態：{page}', + help: 'Hexploration 指令', confirm: '請確認', }, discovery: { title: '發現地點', }, menu: { - draw: '畫', - reveal: '顯示和隱藏', + draw: '繪製', + reveal: '揭示與隱藏', locations: '地點', tools: '工具', layerInUse: '正在 {layer} 上繪製新的六角形。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', undo: '撤銷填充', reveal: '揭示', conceal: '隱藏', explore: '探索', - revealPage: '顯示頁面', + revealPage: '揭示整頁', resetPage: '重置頁面', - mark: '標記位置', + mark: '標記地點', unmark: '取消標記', - name: '名稱十六進位', + name: '命名六角格', settings: '設定', pageSettings: '頁面設定', - status: '地位', + status: '狀態', rescan: '重新掃描', calibrate: '校準', calibrateReset: '重置校準', - help: '幫助', - change: '改變', + help: '說明', + change: '變更', menu: '選單', - clearOverrides: '清除覆蓋', - confirmReset: '是的，刪除所有六角形', + clearOverrides: '清除覆寫', + confirmReset: '是，移除所有六角格', }, prompts: { name: '地點名稱（留空以清除）', }, values: { - on: '在', - off: '離開', - none: '沒有任何', + on: '開', + off: '關', + none: '無', hexLayer: { - auto: '自動（前景，如果可用）', + auto: '自動（可用時使用前景層）', foreground: '前景層', objects: '令牌層', }, revealBy: { - players: '玩家代幣', - characters: '字元標記', - all: '所有代幣', + players: '玩家令牌', + characters: '角色令牌', + all: '所有令牌', }, revealMode: { clear: '清除', - glimpse: '一瞥', + glimpse: '瞥見', }, announce: { - all: '每個人', - gm: '限通用汽車', - off: '離開', + all: '所有人', + gm: '僅限 GM', + off: '關', }, orientation: { - vertical: '六角 (V)', - horizontal: '六角 (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', conceal: '隱藏', }, @@ -1945,12 +1977,12 @@ const HexplorationMod = (() => { desc: '選單、訊息和講義的語言。', }, hexLayer: { - label: '六角層', + label: '六角格圖層', desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', }, fillColor: { label: '填充顏色', - desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', + desc: '新六角格的顏色。若要讓六角格半透明，請使用 rgba()，例如 rgba(0,0,0,0.8)。', }, strokeColor: { label: '邊框顏色', @@ -1962,14 +1994,14 @@ const HexplorationMod = (() => { }, glimpseColor: { label: '瞥見顏色', - desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', + desc: '六角格被瞥見時變成的顏色（「瞥見」揭示模式）。請使用半透明的 rgba() 顏色。', }, strokeWidth: { label: '邊框寬度', desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { - label: '十六進位顯示距離', + label: '六角格揭示距離', desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', }, revealDistance: { @@ -1985,46 +2017,46 @@ const HexplorationMod = (() => { desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', }, revealBy: { - label: '揭示的代幣', - desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', + label: '可揭示的令牌', + desc: '令牌層上哪些令牌會揭示六角格：由玩家控制的令牌、代表任何角色的令牌，或所有令牌。', }, revealMode: { label: '揭示模式', - desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', + desc: '清除會移除視線範圍內的六角格。瞥見則改為讓六角格變得半透明；令牌進入時才將其移除。', }, announce: { - label: '宣布發現', + label: '公告發現', desc: '當發現指定位置時誰會看到聊天訊息。', }, pingDiscoveries: { - label: '平發現', + label: '標示發現位置', desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', }, hideCoveredTokens: { - label: '隱藏覆蓋的令牌', + label: '隱藏被覆蓋的令牌', desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', }, }, status: { engine: '遊戲引擎', grid: '網格', - layer: '六角層', - hexes: '六角形', - named: '命名六角形', - icons: '位置標記', - glimpsed: '瞥見的六角形', - pending: '等待填補的地點', + layer: '六角格圖層', + hexes: '六角格', + named: '已命名的六角格', + icons: '地點令牌', + glimpsed: '被瞥見的六角格', + pending: '等待填充的地點', calibrated: '已校準', - overrides: '頁面覆蓋', - undo: '可以撤銷', + overrides: '頁面覆寫', + undo: '可撤銷', }, messages: { filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', revealed: '六角形顯示：{count}。', - revealedPage: '顯示頁面上的每個十六進位 ({count})。', + revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: - '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', - resetPage: '從頁面中刪除的十六進位：{count}。', + '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', + resetPage: '已從頁面移除的六角格：{count}。', undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', named: '名為「{name}」的六角形：{count}。', unnamed: '已清除的名稱：{count}。', @@ -2038,10 +2070,10 @@ const HexplorationMod = (() => { calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: - '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', - readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', + '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', + readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', @@ -2068,7 +2100,7 @@ const HexplorationMod = (() => { }, hints: { noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', - notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + notHex: '請在頁面設定中將頁面網格設為 Hex (V) 或 Hex (H)。', noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', @@ -2077,7 +2109,7 @@ const HexplorationMod = (() => { unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', - calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { @@ -2086,49 +2118,48 @@ const HexplorationMod = (() => { fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', - revealPage: '顯示頁面上的每個十六進制，無需公告。', + revealPage: '揭示頁面上的所有六角格，不發布公告。', conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', - resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + resetPage: '移除頁面上的所有六角格（會先確認）。', name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', mark: '將選取的標記變成隱藏位置。', unmark: '停止將選定的標記隱藏在位置。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', - rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', - journal: '重建幫助和命令平台講義。', + journal: '重建說明與 Command Deck 講義。', help: '顯示此清單。', handout: '完整說明位於「{name}」講義。', }, deck: { - subtitle: '指揮台', - drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', + drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', - locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', }, handout: { versionLabel: '版本', - subtitle: 'Roll20 的逐十六進位探索', + subtitle: 'Roll20 的逐格六角格探索', footer: '使用“{deck}”講義進行一鍵式控制項。', overview: { heading: '概述', - body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + body: 'Hexploration 以不透明的六角格覆蓋六角格地圖。隊伍移動時，他們經過的六角格（以及你願意的話，周圍的六角格）會被移除，讓地圖一格一格地揭開。隱藏地點可以放在六角格下方，被找到時會公告。它適用於 Jumpgate 和 Legacy 遊戲，以及任何大小的 Hex (V) 和 Hex (H) 網格。', demo: '觀看簡短的演示（來自版本 1）', }, quickStart: { heading: '快速入門', steps: [ - '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '開啟網格設為 Hex (V) 或 Hex (H) 的頁面。', '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', - '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', - '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', + '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', ], }, @@ -2142,40 +2173,40 @@ const HexplorationMod = (() => { revealing: { heading: '揭示如何運作', points: [ - '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', - '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', - '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + '「六角格揭示距離」會在六角格繪製時儲存在六角格上。無論令牌能看多遠，這些六角格都只會在該格數範圍內被揭示。可用於遮擋後方景物的山脈或森林。', + '在「瞥見」模式中，視線內的六角格會變為半透明而非消失，並在令牌進入時被移除。', + 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', + 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', ], }, locations: { heading: '命名六角形和位置', points: [ - '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', - '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', - 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', - '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', + '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', ], }, settings: { heading: '設定', intro: - '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', colKey: '鑰匙', colName: '環境', colDesc: '描述', perPage: '（可按頁設定。）', }, jumpgate: { - heading: '跳躍門和遺產', + heading: 'Jumpgate 與 Legacy', points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', - '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', - 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', ], }, @@ -2183,9 +2214,9 @@ const HexplorationMod = (() => { heading: '從版本 1 升級', points: [ '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', - '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', - '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', - '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', + '現有的六角格地圖、名稱、地點令牌與設定會在首次啟動時自動升級。', + '版本 1 的指令（包括 Hexploration_menu 巨集）仍然有效。', + '版本 1 允許任何代表角色的令牌揭示六角格。若要保留此行為，請將「可揭示的令牌」設為「角色令牌」。', ], colV1: '版本 1 指令', colV2: '版本 2 指令', @@ -2193,18 +2224,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: '故障排除', points: [ - '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', - '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', - 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', + '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { heading: '語言', - body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', - colNative: '原生名', + colNative: '原文名稱', colCode: '程式碼', }, credits: { @@ -2220,84 +2251,84 @@ const HexplorationMod = (() => { const TRANSLATION$j = { titles: { - ready: 'Heexploration je připraven.', - settings: 'Nastavení Heexploration', + ready: 'Hexploration je připraven.', + settings: 'Nastavení Hexploration', languages: 'Vyberte jazyk', pageSettings: 'Nastavení stránky: {page}', - status: 'Stav průzkumu: {page}', - help: 'Příkazy pro průzkum', - confirm: 'Prosím potvrďte', + status: 'Stav Hexploration: {page}', + help: 'Příkazy Hexploration', + confirm: 'Potvrďte prosím', }, discovery: { title: 'Místo objeveno', }, menu: { - draw: 'Remíza', - reveal: 'Odhalit a skrýt', + draw: 'Kreslení', + reveal: 'Odhalení a skrytí', locations: 'Místa', tools: 'Nástroje', - layerInUse: 'Na {layer} se kreslí nové hexy.', + layerInUse: 'Vrstva, do které se kreslí nové hexy: {layer}.', pageSettingsHelp: 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', }, buttons: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - undo: 'Vrátit zpět výplň', + undo: 'Vrátit výplň', reveal: 'Odhalit', - conceal: 'Skrývat', + conceal: 'Zakrýt', explore: 'Prozkoumat', revealPage: 'Odhalit stránku', - resetPage: 'Obnovit stránku', - mark: 'Označte umístění', + resetPage: 'Resetovat stránku', + mark: 'Označit místo', unmark: 'Zrušit označení', - name: 'Jméno Hex', + name: 'Pojmenovat hex', settings: 'Nastavení', pageSettings: 'Nastavení stránky', - status: 'Postavení', - rescan: 'Znovu naskenujte', + status: 'Stav', + rescan: 'Znovu skenovat', calibrate: 'Kalibrovat', calibrateReset: 'Resetovat kalibraci', help: 'Pomoc', - change: 'Přeměna', + change: 'Změnit', menu: 'Menu', - clearOverrides: 'Vymazat přepisy', - confirmReset: 'Ano, Odebrat všechny hexy', + clearOverrides: 'Zrušit přepsání', + confirmReset: 'Ano, odebrat všechny hexy', }, prompts: { name: 'Název místa (pro vymazání ponechte prázdné)', }, values: { - on: 'Na', + on: 'Zapnuto', off: 'Vypnuto', - none: 'Žádný', + none: 'Žádné', hexLayer: { auto: 'Auto (popředí, pokud je k dispozici)', foreground: 'vrstva popředí', - objects: 'vrstva tokenů', + objects: 'vrstva žetonů', }, revealBy: { - players: 'Hráčské žetony', + players: 'Žetony hráčů', characters: 'Žetony postav', - all: 'Všechny tokeny', + all: 'Všechny žetony', }, revealMode: { - clear: 'Jasný', + clear: 'Odstranění', glimpse: 'Záblesk', }, announce: { - all: 'Každý', + all: 'Všichni', gm: 'Pouze GM', off: 'Vypnuto', }, orientation: { - vertical: 'Hexadecimální (V)', - horizontal: 'Hexadecimální (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - conceal: 'Skrývat', + conceal: 'Zakrýt', }, }, settings: { @@ -2306,7 +2337,7 @@ const HexplorationMod = (() => { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Hexadecimální vrstva', + label: 'Vrstva šestiúhelníků', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { @@ -2318,66 +2349,66 @@ const HexplorationMod = (() => { desc: 'Barva obrysu nových hexů.', }, labelColor: { - label: 'Barva štítku', + label: 'Barva popisku', desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', }, glimpseColor: { label: 'Barva záblesku', - desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', + desc: 'Barva, kterou hexy získají při zahlédnutí (režim odhalování Záblesk). Použijte průhlednou barvu rgba().', }, strokeWidth: { - label: 'Šířka okraje', + label: 'Šířka ohraničení', desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Hexadecimální vzdálenost odhalení', + label: 'Vzdálenost odhalení šestiúhelníků', desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', }, revealDistance: { - label: 'Pohledová vzdálenost', + label: 'Vzdálenost dohledu', desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', }, lineOfSight: { - label: 'Zornost', + label: 'Přímá viditelnost', desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', }, revealPath: { - label: 'Odhalení Po cestě', + label: 'Odhalovat po cestě', desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', }, revealBy: { - label: 'Tokeny, které odhalují', + label: 'Žetony, které odhalují', desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', }, revealMode: { - label: 'Režim odhalení', - desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', + label: 'Režim odhalování', + desc: 'Odstranění odstraní hexy v dohledu. Záblesk je místo toho zprůhlední; odstraní se, když do nich vstoupí žeton.', }, announce: { - label: 'Oznamte objevy', + label: 'Oznamovat objevy', desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', }, pingDiscoveries: { - label: 'Ping Discovery', + label: 'Pingnout objevy', desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', }, hideCoveredTokens: { - label: 'Skryjte kryté žetony', + label: 'Skrýt zakryté žetony', desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', }, }, status: { engine: 'Herní engine', grid: 'Mřížka', - layer: 'Hexadecimální vrstva', + layer: 'Vrstva hexů', hexes: 'Hexy', named: 'Pojmenované hexy', - icons: 'Tokeny polohy', + icons: 'Žetony míst', glimpsed: 'Zahlédnuté hexy', - pending: 'Místa čekající na zaplnění', + pending: 'Místa čekající na výplň', calibrated: 'Zkalibrováno', - overrides: 'Přepíše stránku', - undo: 'Zpět k dispozici', + overrides: 'Přepsání stránky', + undo: 'Lze vrátit zpět', }, messages: { filled: @@ -2388,7 +2419,7 @@ const HexplorationMod = (() => { 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', named: 'Hexusy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: @@ -2403,11 +2434,11 @@ const HexplorationMod = (() => { 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: - 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', + 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', pruned: - 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + 'Uložené hexy, které již neexistují a byly zapomenuty: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte na stránce Znovu skenovat, aby se její hexy znovu načetly.', readyHint: - 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', + 'Zadejte !hexploration pro otevření nabídky nebo otevřete leták "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -2417,7 +2448,7 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', - notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', @@ -2470,17 +2501,16 @@ const HexplorationMod = (() => { calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', - status: 'Ukažte, co Heexploration ví o aktuální stránce.', - journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + status: 'Zobrazit, co Hexploration ví o aktuální stránce.', + journal: 'Znovu vytvořte letáky „Pomoc“ a „Command Deck“.', help: 'Zobrazit tento seznam.', handout: 'Úplné pokyny jsou v letáku „{name}“.', }, deck: { - subtitle: 'Velitelský balíček', drawDesc: 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', revealDesc: - 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', + 'Vyberte hexy, tvary nebo žetony, abyste je odhalili nebo znovu zakryli. Prozkoumat odhalí okolí vybraných žetonů, jako by se pohnuly.', locationsDesc: 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', toolsDesc: @@ -2501,9 +2531,9 @@ const HexplorationMod = (() => { steps: [ 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', - 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Vyberte tvary a v Command Deck klikněte na Vyplnit (nebo zadejte !hexploration fill). Tvary se nahradí hexy.', 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', - 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Vzdálenosti dohledu jsou odhaleny.', ], }, commands: { @@ -2516,13 +2546,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Jak funguje odhalování', points: [ - 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', - 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', - 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', - 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', - 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů. Se zapnutou Přímou viditelností je hex odhalen pouze tehdy, když mezi ním a žetonem neleží žádný zakrytý hex.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do hexů při jejich kreslení. Tyto hexy lze odhalit jen ze vzdálenosti nejvýše tolika hexů, ať žeton vidí jakkoli daleko. Použijte ji pro hory nebo lesy, které zakrývají, co je za nimi.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton.', + 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', + 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', ], }, locations: { @@ -2531,14 +2561,14 @@ const HexplorationMod = (() => { 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', - 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -2548,18 +2578,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate a Legacy', points: [ 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', - 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', + 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], }, upgrading: { heading: 'Upgrade z verze 1', points: [ 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', - 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', - 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', - 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', + 'Stávající hexové mapy, názvy, tokeny lokací a nastavení se při prvním spuštění automaticky aktualizují.', + 'Příkazy verze 1, včetně makra Hexploration_menu, stále fungují.', + 'Verze 1 umožňovala odhalovat hexy každému žetonu, který představoval postavu. Chcete-li toto chování zachovat, nastavte Žetony, které odhalují, na Žetony postav.', ], colV1: 'Příkaz verze 1', colV2: 'Příkaz verze 2', @@ -2567,18 +2597,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Odstraňování problémů', points: [ - 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá nastavení Žetony, které odhalují, a zda stránka obsahuje hexy (!hexploration status).', 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', - 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', - 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte na stránce Znovu skenovat.', + 'Vyplnit hlásí, že oblast neobsahuje žádné středy hexů: tvar musí obsahovat střed alespoň jednoho hexu.', 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', ], }, languages: { heading: 'Jazyky', - body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + body: 'Jazyk vyberte příkazem !hexploration set language. Dostupné jazyky:', colLanguage: 'Jazyk', - colNative: 'Rodné jméno', + colNative: 'Vlastní název', colCode: 'Kód', }, credits: { @@ -2598,34 +2628,34 @@ const HexplorationMod = (() => { settings: 'Indstillinger for Hexploration', languages: 'Vælg et sprog', pageSettings: 'Sideindstillinger: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandoer', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandoer', confirm: 'Bekræft venligst', }, discovery: { title: 'Sted opdaget', }, menu: { - draw: 'Tegne', - reveal: 'Afsløre og skjul', + draw: 'Tegn', + reveal: 'Afslør og skjul', locations: 'Steder', tools: 'Værktøjer', - layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', + layerInUse: 'Nye hexfelter tegnes på {layer}.', pageSettingsHelp: 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', }, buttons: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - undo: 'Fortryd Fyld', - reveal: 'Afsløre', - conceal: 'Skjule', - explore: 'Udforske', - revealPage: 'Afsløre side', + undo: 'Fortryd fyld', + reveal: 'Afslør', + conceal: 'Skjul', + explore: 'Udforsk', + revealPage: 'Afslør side', resetPage: 'Nulstil side', - mark: 'Marker placering', + mark: 'Marker sted', unmark: 'Fjern markering', - name: 'Navn Hex', + name: 'Navngiv hexfelt', settings: 'Indstillinger', pageSettings: 'Sideindstillinger', status: 'Status', @@ -2633,45 +2663,45 @@ const HexplorationMod = (() => { calibrate: 'Kalibrer', calibrateReset: 'Nulstil kalibrering', help: 'Hjælp', - change: 'Forandring', + change: 'Skift', menu: 'Menu', clearOverrides: 'Ryd tilsidesættelser', - confirmReset: 'Ja, Fjern alle Hexes', + confirmReset: 'Ja, fjern alle hexfelter', }, prompts: { - name: 'Placeringsnavn (lad tom for at rydde)', + name: 'Stednavn (lad feltet være tomt for at rydde)', }, values: { - on: 'På', - off: 'Slukket', + on: 'Til', + off: 'Fra', none: 'Ingen', hexLayer: { auto: 'Auto (forgrund, hvis tilgængelig)', foreground: 'forgrundslaget', - objects: 'symbollag', + objects: 'tokenlaget', }, revealBy: { - players: 'Spillerpoletter', - characters: 'Karakter tokens', + players: 'Spillertokens', + characters: 'Karaktertokens', all: 'Alle tokens', }, revealMode: { - clear: 'Klar', + clear: 'Fjern', glimpse: 'Glimt', }, announce: { - all: 'Alle sammen', + all: 'Alle', gm: 'Kun GM', - off: 'Slukket', + off: 'Fra', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - conceal: 'Skjule', + conceal: 'Skjul', }, }, settings: { @@ -2680,11 +2710,11 @@ const HexplorationMod = (() => { desc: 'Sprog til menuer, beskeder og uddelingskopier.', }, hexLayer: { - label: 'Hex lag', - desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + label: 'Lag for hexfelter', + desc: 'Hvor nye hexfelter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', }, fillColor: { - label: 'Fyld farve', + label: 'Fyldfarve', desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { @@ -2692,19 +2722,19 @@ const HexplorationMod = (() => { desc: 'Farve på omridset af nye sekskanter.', }, labelColor: { - label: 'Etiket farve', + label: 'Etiketfarve', desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', }, glimpseColor: { - label: 'Glimt farve', - desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', + label: 'Glimtfarve', + desc: 'Den farve, hexfelter skifter til, når de skimtes (afsløringstilstanden Glimt). Brug en gennemsigtig rgba()-farve.', }, strokeWidth: { - label: 'Border Bredde', + label: 'Kantbredde', desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: 'Hex afsløre afstand', + label: 'Afsløringsafstand for hexfelter', desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { @@ -2712,20 +2742,20 @@ const HexplorationMod = (() => { desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', }, lineOfSight: { - label: 'Synslinie', + label: 'Synslinje', desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', }, revealPath: { - label: 'Afsløre langs stien', + label: 'Afslør langs ruten', desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', }, revealBy: { - label: 'Tokens, der afslører', + label: 'Afslørende tokens', desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { label: 'Afsløringstilstand', - desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', + desc: 'Fjern fjerner hexfelter inden for synsvidde. Glimt gør dem i stedet gennemsigtige; de fjernes, når et token går ind i dem.', }, announce: { label: 'Annoncer opdagelser', @@ -2741,16 +2771,16 @@ const HexplorationMod = (() => { }, }, status: { - engine: 'Spil motor', + engine: 'Spilmotor', grid: 'Gitter', - layer: 'Hex lag', - hexes: 'Hekser', - named: 'Navngivne hexes', - icons: 'Placeringstokens', - glimpsed: 'Glimpede sekskanter', - pending: 'Steder, der venter på udfyldning', + layer: 'Lag for hexfelter', + hexes: 'Hexfelter', + named: 'Navngivne hexfelter', + icons: 'Stedtokens', + glimpsed: 'Gennemsigtige hexfelter', + pending: 'Steder, der venter på fyld', calibrated: 'Kalibreret', - overrides: 'Side tilsidesætter', + overrides: 'Sidetilsidesættelser', undo: 'Fortryd tilgængelig', }, messages: { @@ -2777,11 +2807,11 @@ const HexplorationMod = (() => { 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: - 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', + 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', pruned: - 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + 'Gemte hexfelter, der ikke længere findes og er blevet glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Scan igen på siden for at finde dens hexfelter igen.', readyHint: - 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + 'Skriv !hexploration for at åbne menuen, eller åbn uddelingsarket "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -2845,16 +2875,15 @@ const HexplorationMod = (() => { 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', - journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + journal: 'Genopbyg uddelingsarkene Help og Command Deck.', help: 'Vis denne liste.', handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', }, deck: { - subtitle: 'Kommandodæk', drawDesc: - 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', + 'Tegn figurer rundt om et område, vælg dem, og fyld derefter. Fortryd fyld annullerer den sidste fyldning.', revealDesc: - 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', + 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', toolsDesc: @@ -2875,9 +2904,9 @@ const HexplorationMod = (() => { steps: [ 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', - 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', - 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', - 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', + 'Vælg figurerne, og klik på Fyld i Command Deck (eller skriv !hexploration fill). Figurerne erstattes af hexfelter.', + 'Valgfrit: Før du fylder, kan du vælge tokens for vigtige steder og klikke på Marker sted. De skjules under hexfelterne og annonceres, når de opdages.', + 'Flyt et spillertoken. Hvert hexfelt, det passerer igennem, og hexfelterne inden for dets Synsafstand afsløres.', ], }, commands: { @@ -2890,29 +2919,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Sådan fungerer afsløring', points: [ - 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', - 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', - 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', - 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', - 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter. Med Synslinje slået til afsløres et hexfelt kun, hvis der ikke ligger noget dækket hexfelt imellem.', + 'Afsløringsafstand for hexfelter gemmes på hexfelterne, når de tegnes. Disse hexfelter afsløres kun inden for så mange hexfelters afstand, uanset hvor langt et token kan se. Brug det til bjerge eller skove, der skjuler, hvad der ligger bag dem.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem.', + 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', + 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', ], }, locations: { heading: 'Navngivne Hekser og Steder', points: [ - 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', - 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', - 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], }, settings: { heading: 'Indstillinger', intro: - "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + 'Skift indstillinger med !hexploration set (eller knappen Indstillinger). Lag for hexfelter, Afslørende tokens og Sprog kan også indstilles på modens indstillingsside.', colKey: 'Nøgle', colName: 'Indstilling', colDesc: 'Beskrivelse', @@ -2922,9 +2951,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate og Legacy', points: [ 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', - 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', - 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', - "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + 'Når Lag for hexfelter er sat til Auto, tegnes hexfelter på forgrundslaget over tokens, så spillerne ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexfelter, som har en lidt anden form end Legacy-hexfelter. Hvis hexfelterne ikke flugter med en sides gitter, så fastgør et token til midten af et hexfelt, vælg det, og klik på Kalibrer. Vælg to tokens i nabohexfelter i samme række (Hex V) eller kolonne (Hex H) for også at rette hexfeltstørrelsen.', + 'Når en side eller et spil kopieres, får hexfelterne nye id’er. Kør Scan igen på siden for at finde dem igen sammen med deres navneetiketter og stedtokens.', ], }, upgrading: { @@ -2933,7 +2962,7 @@ const HexplorationMod = (() => { 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', - 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', + 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], colV1: 'Version 1 kommando', colV2: 'Version 2 kommando', @@ -2941,10 +2970,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Fejlfinding', points: [ - 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', - 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', - 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', - 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'Der sker ikke noget, når et token flytter sig: Kontroller, at tokenet ligger på tokenlaget og matcher Afslørende tokens, og at siden har hexfelter (!hexploration status).', + 'Hexfelterne er forskudt i forhold til gitteret: Brug Kalibrer, og kontroller derefter med et token på nogle få hexfelter rundt om på kortet.', + 'Hexfelterne holdt op med at blive afsløret efter kopiering af en side eller et spil: Kør Scan igen på siden.', + 'Fyld siger, at området ikke har nogen hexfeltcentre: Figuren skal indeholde midten af mindst ét hexfelt.', 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', ], }, @@ -2952,7 +2981,7 @@ const HexplorationMod = (() => { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', colLanguage: 'Sprog', - colNative: 'Indfødt navn', + colNative: 'Eget navn', colCode: 'Kode', }, credits: { @@ -2968,12 +2997,12 @@ const HexplorationMod = (() => { const TRANSLATION$h = { titles: { - ready: 'Hexploratie is klaar.', - settings: 'Hexploratie-instellingen', + ready: 'Hexploration is klaar.', + settings: 'Hexploration-instellingen', languages: 'Kies een taal', pageSettings: 'Pagina-instellingen: {page}', - status: 'Hverkenningsstatus: {page}', - help: 'Hexploratie-opdrachten', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdrachten', confirm: 'Bevestig alstublieft', }, discovery: { @@ -2984,7 +3013,7 @@ const HexplorationMod = (() => { reveal: 'Onthullen en verbergen', locations: 'Locaties', tools: 'Hulpmiddelen', - layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + layerInUse: 'Nieuwe zeshoeken worden getekend op de {layer}.', pageSettingsHelp: 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', }, @@ -2993,44 +3022,44 @@ const HexplorationMod = (() => { fillInverse: 'Omgekeerde vulling', undo: 'Vulling ongedaan maken', reveal: 'Onthullen', - conceal: 'Maskeren', - explore: 'Ontdekken', + conceal: 'Verbergen', + explore: 'Verkennen', revealPage: 'Pagina onthullen', resetPage: 'Pagina opnieuw instellen', - mark: 'Markeer locatie', + mark: 'Locatie markeren', unmark: 'Markering opheffen', - name: 'Naam Hex', + name: 'Zeshoek benoemen', settings: 'Instellingen', pageSettings: 'Pagina-instellingen', status: 'Status', rescan: 'Opnieuw scannen', calibrate: 'Kalibreren', calibrateReset: 'Kalibratie opnieuw instellen', - help: 'Hulp', - change: 'Wijziging', + help: 'Help', + change: 'Wijzigen', menu: 'Menu', - clearOverrides: 'Wis overschrijvingen', - confirmReset: 'Ja, verwijder alle vakjes', + clearOverrides: 'Overschrijvingen wissen', + confirmReset: 'Ja, verwijder alle zeshoeken', }, prompts: { name: 'Locatienaam (leeg laten om te wissen)', }, values: { - on: 'Op', + on: 'Aan', off: 'Uit', none: 'Geen', hexLayer: { auto: 'Automatisch (voorgrond indien beschikbaar)', - foreground: 'voorgrond laag', - objects: 'token laag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Spelerfiches', - characters: 'Karakterfiches', + players: 'Spelertokens', + characters: 'Personagetokens', all: 'Alle tokens', }, revealMode: { - clear: 'Duidelijk', + clear: 'Wissen', glimpse: 'Glimp', }, announce: { @@ -3039,13 +3068,13 @@ const HexplorationMod = (() => { off: 'Uit', }, orientation: { - vertical: 'Zeskant (V)', - horizontal: 'Zeskant (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vullen', fillInverse: 'Omgekeerde vulling', - conceal: 'Maskeren', + conceal: 'Verbergen', }, }, settings: { @@ -3054,8 +3083,8 @@ const HexplorationMod = (() => { desc: "Taal voor menu's, berichten en hand-outs.", }, hexLayer: { - label: 'Hex-laag', - desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + label: 'Laag voor zeshoeken', + desc: 'Waar nieuwe zeshoeken worden getekend. Automatisch probeert de voorgrondlaag (boven tokens) en valt terug op de tokenlaag als het spel die niet ondersteunt.', }, fillColor: { label: 'Vulkleur', @@ -3066,23 +3095,23 @@ const HexplorationMod = (() => { desc: 'Kleur van de omtrek van nieuwe vakjes.', }, labelColor: { - label: 'Etiketkleur', + label: 'Labelkleur', desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', }, glimpseColor: { - label: 'Glimp kleur', - desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + label: 'Glimpkleur', + desc: 'Kleur die zeshoeken krijgen wanneer er een glimp van wordt opgevangen (onthullingsmodus Glimp). Gebruik een doorzichtige rgba()-kleur.', }, strokeWidth: { label: 'Randbreedte', desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', }, maxDistance: { - label: 'Hex onthullen afstand', + label: 'Onthullingsafstand van zeshoeken', desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', }, revealDistance: { - label: 'Zicht afstand', + label: 'Zichtafstand', desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', }, lineOfSight: { @@ -3090,7 +3119,7 @@ const HexplorationMod = (() => { desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', }, revealPath: { - label: 'Onthul langs het pad', + label: 'Onthullen langs pad', desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { @@ -3099,30 +3128,30 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Onthullingsmodus', - desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + desc: 'Wissen verwijdert zeshoeken binnen het zicht. Glimp maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer een token ze betreedt.', }, announce: { label: 'Ontdekkingen aankondigen', desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', }, pingDiscoveries: { - label: 'Ping-ontdekkingen', + label: 'Ontdekkingen pingen', desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { - label: 'Verberg afgedekte tokens', + label: 'Bedekte tokens verbergen', desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { engine: 'Game-engine', grid: 'Rooster', - layer: 'Hex-laag', - hexes: 'Hexen', - named: 'Genoemde hexen', - icons: 'Locatiefiches', - glimpsed: 'Glimp van hexen', - pending: 'Locaties die wachten op vulling', + layer: 'Laag voor zeshoeken', + hexes: 'Zeshoeken', + named: 'Benoemde zeshoeken', + icons: 'Locatietokens', + glimpsed: 'Doorzichtige zeshoeken', + pending: 'Locaties die op een vulling wachten', calibrated: 'Gekalibreerd', overrides: 'Pagina-overschrijvingen', undo: 'Ongedaan maken beschikbaar', @@ -3151,11 +3180,11 @@ const HexplorationMod = (() => { 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: - 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', pruned: - 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + 'Opgeslagen zeshoeken die niet meer bestaan en zijn vergeten: {dropped}. Als dit spel of deze pagina is gekopieerd, voer dan Opnieuw scannen uit op de pagina om de zeshoeken weer op te pikken.', readyHint: - 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + 'Typ !hexploration voor het menu, of open de hand-out "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -3218,21 +3247,20 @@ const HexplorationMod = (() => { pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', rescan: - 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', - journal: 'Herbouw de Help- en Command Deck-hand-outs.', + journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', help: 'Laat deze lijst zien.', handout: 'Volledige instructies vindt u in de hand-out "{name}".', }, deck: { - subtitle: 'Commandodek', drawDesc: - 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + 'Teken vormen rond een gebied, selecteer ze en vul ze dan. Vulling ongedaan maken draait de laatste vulling terug.', revealDesc: - 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', toolsDesc: @@ -3253,9 +3281,9 @@ const HexplorationMod = (() => { steps: [ 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', - 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', - 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', - 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + 'Selecteer de vormen en klik in het Command Deck op Vullen (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze worden verborgen onder de zeshoeken en aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelertoken. Elke zeshoek waar het doorheen gaat, en de zeshoeken binnen zijn Zichtafstand, worden onthuld.', ], }, commands: { @@ -3268,29 +3296,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hoe onthullen werkt', points: [ - 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', - "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", - 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', - 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', - 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken. Als Zichtlijn aan staat, wordt een zeshoek alleen onthuld als er geen bedekte zeshoek tussen ligt.', + 'Onthullingsafstand van zeshoeken wordt bij het tekenen in de zeshoeken opgeslagen. Die zeshoeken worden alleen onthuld vanaf hooguit zoveel zeshoeken afstand, hoe ver een token ook kan kijken. Gebruik dit voor bergen of bossen die verbergen wat erachter ligt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt.', + 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', + 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', ], }, locations: { heading: 'Genoemde velden en locaties', points: [ - 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', - 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', - 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], }, settings: { heading: 'Instellingen', intro: - 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Laag voor zeshoeken, Tokens die onthullen en Taal kunnen ook worden ingesteld op de instellingenpagina van de mod.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beschrijving', @@ -3300,18 +3328,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate en erfenis', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', - 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', - 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', - "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige zeshoeken, die een iets andere vorm hebben dan Legacy-zeshoeken. Als de zeshoeken niet samenvallen met het raster van een pagina, zet dan een token vast op het midden van een zeshoek, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende zeshoeken van dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', + 'Wanneer een pagina of spel wordt gekopieerd, krijgen de zeshoeken nieuwe ID’s. Voer Opnieuw scannen uit op de pagina om ze weer op te pikken, samen met hun naamlabels en locatietokens.', ], }, upgrading: { heading: 'Upgraden vanaf versie 1', points: [ 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', - 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'Bestaande hexkaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch bijgewerkt.', 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', - 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + 'In versie 1 kon elk token dat een personage voorstelde zeshoeken onthullen. Stel Tokens die onthullen in op Personagetokens om dat gedrag te behouden.', ], colV1: 'Versie 1-opdracht', colV2: 'Versie 2-opdracht', @@ -3319,10 +3347,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Problemen oplossen', points: [ - 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', - 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', - 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', - 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Er gebeurt niets wanneer een token beweegt: controleer of het token op de tokenlaag staat en overeenkomt met Tokens die onthullen, en of de pagina zeshoeken heeft (!hexploration status).', + 'Zeshoeken zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer daarna met een token op een paar zeshoeken verspreid over de kaart.', + 'Zeshoeken worden niet meer onthuld na het kopiëren van een pagina of spel: voer Opnieuw scannen uit op de pagina.', + 'Vullen meldt dat het gebied geen middelpunten van zeshoeken bevat: de vorm moet het middelpunt van ten minste één zeshoek bevatten.', 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', ], }, @@ -3330,7 +3358,7 @@ const HexplorationMod = (() => { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Eigen naam', colCode: 'Code', }, credits: { @@ -3599,7 +3627,6 @@ const HexplorationMod = (() => { handout: 'Full instructions are in the "{name}" handout.', }, deck: { - subtitle: 'Command Deck', drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', revealDesc: 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', @@ -3717,48 +3744,48 @@ const HexplorationMod = (() => { const TRANSLATION$g = { titles: { ready: 'Hexploration on valmis.', - settings: 'Tutkimusasetukset', + settings: 'Hexploration-asetukset', languages: 'Valitse kieli', pageSettings: 'Sivuasetukset: {page}', - status: 'Tutkimuksen tila: {page}', - help: 'Hexploration komennot', - confirm: 'Ole hyvä ja vahvista', + status: 'Hexploration-tila: {page}', + help: 'Hexploration-komennot', + confirm: 'Vahvista', }, discovery: { title: 'Sijainti löydetty', }, menu: { - draw: 'Piirrä', + draw: 'Piirto', reveal: 'Paljasta ja piilota', locations: 'Sijainnit', tools: 'Työkalut', - layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + layerInUse: 'Uudet heksat piirretään tasolle: {layer}.', pageSettingsHelp: 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', }, buttons: { - fill: 'Täyttää', + fill: 'Täytä', fillInverse: 'Käänteinen täyttö', undo: 'Kumoa täyttö', - reveal: 'Paljastaa', - conceal: 'Salata', - explore: 'Tutkia', + reveal: 'Paljasta', + conceal: 'Peitä', + explore: 'Tutki', revealPage: 'Paljasta sivu', resetPage: 'Nollaa sivu', mark: 'Merkitse sijainti', unmark: 'Poista merkintä', - name: 'Nimi Hex', + name: 'Nimeä heksa', settings: 'Asetukset', - pageSettings: 'Sivun asetukset', - status: 'Status', + pageSettings: 'Sivuasetukset', + status: 'Tila', rescan: 'Skannaa uudelleen', - calibrate: 'Kalibroida', + calibrate: 'Kalibroi', calibrateReset: 'Nollaa kalibrointi', - help: 'Auttaa', - change: 'Muuttaa', + help: 'Ohje', + change: 'Muuta', menu: 'Valikko', clearOverrides: 'Tyhjennä ohitukset', - confirmReset: 'Kyllä, poista kaikki heksit', + confirmReset: 'Kyllä, poista kaikki heksat', }, prompts: { name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', @@ -3768,18 +3795,18 @@ const HexplorationMod = (() => { off: 'Pois', none: 'Ei mitään', hexLayer: { - auto: 'Automaattinen (etualalla, jos saatavilla)', - foreground: 'etualan kerros', - objects: 'merkkikerros', + auto: 'Automaattinen (etuala, jos saatavilla)', + foreground: 'etualan taso', + objects: 'merkkitaso', }, revealBy: { - players: 'Pelaajan merkit', - characters: 'Hahmomerkit', + players: 'Pelaajien merkit', + characters: 'Hahmojen merkit', all: 'Kaikki merkit', }, revealMode: { - clear: 'Selkeä', - glimpse: 'Vilkkaus', + clear: 'Poisto', + glimpse: 'Vilkaisu', }, announce: { all: 'Kaikki', @@ -3791,9 +3818,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Täyttää', + fill: 'Täyttö', fillInverse: 'Käänteinen täyttö', - conceal: 'Salata', + conceal: 'Peitto', }, }, settings: { @@ -3802,31 +3829,31 @@ const HexplorationMod = (() => { desc: 'Valikkojen, viestien ja monisteiden kieli.', }, hexLayer: { - label: 'Hex kerros', - desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + label: 'Heksataso', + desc: 'Mihin uudet heksat piirretään. Automaattinen kokeilee etualan tasoa (merkkien yläpuolella) ja käyttää merkkitasoa, jos peli ei tue sitä.', }, fillColor: { label: 'Täyttöväri', desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Reunuksen väri', + label: 'Reunan väri', desc: 'Uusien kuusioiden ääriviivan väri.', }, labelColor: { - label: 'Etiketin väri', + label: 'Nimilappujen väri', desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + label: 'Vilkaisun väri', + desc: 'Väri, jonka heksat saavat Vilkaisu-tilassa. Käytä läpikuultavaa rgba()-väriä.', }, strokeWidth: { label: 'Reunan leveys', desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', }, maxDistance: { - label: 'Hex paljastaa etäisyyttä', + label: 'Heksojen paljastusetäisyys', desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', }, revealDistance: { @@ -3834,46 +3861,46 @@ const HexplorationMod = (() => { desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', }, lineOfSight: { - label: 'Näkökenttä', + label: 'Näköyhteys', desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', }, revealPath: { - label: 'Paljasta polun varrella', + label: 'Paljasta reitin varrelta', desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { - label: 'Tokenit jotka paljastavat', + label: 'Paljastavat merkit', desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', }, revealMode: { label: 'Paljastustila', - desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + desc: 'Poisto poistaa näköetäisyydellä olevat heksat. Vilkaisu tekee niistä sen sijaan läpikuultavia; ne poistetaan, kun merkki astuu niihin.', }, announce: { - label: 'Ilmoita löydökset', + label: 'Ilmoita löydöt', desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', }, pingDiscoveries: { - label: 'Ping löydöt', + label: 'Pingaa löydöt', desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', }, hideCoveredTokens: { - label: 'Piilota peitetyt rahakkeet', + label: 'Piilota peitetyt merkit', desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', }, }, status: { - engine: 'Pelin moottori', + engine: 'Pelimoottori', grid: 'Ruudukko', - layer: 'Hex kerros', - hexes: 'Hexes', + layer: 'Heksataso', + hexes: 'Heksat', named: 'Nimetyt heksat', - icons: 'Sijaintitunnukset', - glimpsed: 'Näytetyt kuusiot', - pending: 'Täyttöä odottavat paikat', + icons: 'Sijaintimerkit', + glimpsed: 'Vilkaistut heksat', + pending: 'Täyttöä odottavat sijainnit', calibrated: 'Kalibroitu', overrides: 'Sivun ohitukset', - undo: 'Kumoa käytettävissä', + undo: 'Kumoaminen käytettävissä', }, messages: { filled: @@ -3899,10 +3926,11 @@ const HexplorationMod = (() => { 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: - 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', pruned: - 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', - readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla Skannaa uudelleen, jotta sen heksat löytyvät taas.', + readyHint: + 'Kirjoita !hexploration avataksesi valikon, tai avaa moniste "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -3930,7 +3958,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', - notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + notHex: 'Aseta sivun ruudukoksi Hex (V) tai Hex (H) sivun asetuksista.', noPolygons: 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', @@ -3940,7 +3968,7 @@ const HexplorationMod = (() => { unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: - 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', @@ -3963,23 +3991,22 @@ const HexplorationMod = (() => { pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: - 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', - journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', help: 'Näytä tämä luettelo.', handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', }, deck: { - subtitle: 'Komentolevy', drawDesc: - 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + 'Piirrä muotoja alueen ympärille, valitse ne ja napsauta Täytä. Kumoa täyttö peruu viimeisimmän täytön.', revealDesc: - 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + 'Valitse heksoja, muotoja tai merkkejä paljastaaksesi ne tai peittääksesi ne uudelleen. Tutki paljastaa valittujen merkkien ympäristön ikään kuin ne olisivat juuri siirtyneet sinne.', locationsDesc: - 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + 'Valitse merkit piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksoja tai merkkejä nimetäksesi heksan.', toolsDesc: 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', footer: 'Katso täydelliset ohjeet monisteesta "{help}".', @@ -3998,9 +4025,9 @@ const HexplorationMod = (() => { steps: [ 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', - 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', - 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', - 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + 'Valitse muodot ja napsauta Command Deck -monisteessa Täytä (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: valitse ennen täyttöä merkit tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan heksojen alle, ja niistä ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajan merkkiä. Jokainen heksa, jonka läpi se kulkee, ja sen Näköetäisyyden sisällä olevat heksat paljastetaan.', ], }, commands: { @@ -4013,29 +4040,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Kuinka paljastaminen toimii', points: [ - 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', - 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', - 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', - 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', - 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat. Kun Näköyhteys on päällä, heksa paljastetaan vain, jos välissä ei ole peitettyä heksaa.', + 'Heksojen paljastusetäisyys tallennetaan heksoihin niitä piirrettäessä. Nämä heksat paljastuvat vain enintään näin monen heksan päästä, vaikka merkki näkisi kauemmas. Käytä sitä vuorille tai metsille, jotka kätkevät taakseen jäävän.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin.', + 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', + 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', ], }, locations: { heading: 'Nimetty Heksit ja sijainnit', points: [ - 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', - 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', - 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], }, settings: { heading: 'Asetukset', intro: - 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + 'Muuta asetuksia komennolla !hexploration set (tai Asetukset-painikkeella). Heksatason, Paljastavat merkit ja Kielen voi asettaa myös modin asetussivulla.', colKey: 'Avain', colName: 'Asetus', colDesc: 'Kuvaus', @@ -4045,18 +4072,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate ja Legacy', points: [ 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', - 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', - 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', - 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + 'Kun Heksataso on Automaattinen, heksat piirretään etualan tasolle merkkien yläpuolelle, joten pelaajat eivät näe, mitä alla on. Jos etualan taso ei ole käytettävissä, käytetään merkkitasoa.', + 'Jumpgate piirtää matemaattisesti säännöllisiä heksoja, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksat eivät osu sivun ruudukkoon, kiinnitä merkki heksan keskipisteeseen, valitse se ja napsauta Kalibroi. Korjaa myös heksan koko valitsemalla kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) vierekkäisistä heksoista.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnisteet. Suorita sivulla Skannaa uudelleen, jotta ne löytyvät taas nimilappuineen ja sijaintimerkkeineen.', ], }, upgrading: { heading: 'Päivitys versiosta 1', points: [ 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', - 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Nykyiset heksakartat, nimet, sijaintimerkit ja asetukset päivitetään automaattisesti ensimmäisellä käynnistyksellä.', 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', - 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + 'Versiossa 1 mikä tahansa hahmoa edustava merkki paljasti heksoja. Säilytä tämä toiminta asettamalla Paljastavat merkit arvoon Hahmojen merkit.', ], colV1: 'Version 1 komento', colV2: 'Version 2 komento', @@ -4064,23 +4091,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Vianetsintä', points: [ - 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', - 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', - 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', - 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkitasolla ja vastaa Paljastavat merkit -asetusta ja että sivulla on heksoja (!hexploration status).', + 'Heksat ovat siirtyneet ruudukosta: käytä Kalibroi-toimintoa ja tarkista sitten merkillä muutama heksa eri puolilta karttaa.', + 'Heksat lakkasivat paljastumasta sivun tai pelin kopioinnin jälkeen: suorita sivulla Skannaa uudelleen.', + 'Täytä ilmoittaa, ettei alueella ole heksojen keskipisteitä: muodon on sisällettävä vähintään yhden heksan keskipiste.', 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', ], }, languages: { heading: 'Kielet', - body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + body: 'Valitse kieli komennolla !hexploration set language. Käytettävissä olevat kielet:', colLanguage: 'Kieli', - colNative: 'Alkuperäinen nimi', + colNative: 'Oma nimi', colCode: 'Koodi', }, credits: { heading: 'Krediitit', - original: 'Alkuperäinen mod', + original: 'Alkuperäisen modin tekijä', maintainer: 'Versio 2 ylläpitäjä', marketplace: 'Adan taidepaketit Roll20 Marketplacessa', support: @@ -4091,12 +4118,12 @@ const HexplorationMod = (() => { const TRANSLATION$f = { titles: { - ready: "L'exploration est prête.", - settings: "Paramètres d'exploration", + ready: 'Hexploration est prêt.', + settings: "Paramètres d'Hexploration", languages: 'Choisissez une langue', pageSettings: 'Paramètres de la page : {page}', - status: "Statut d'exploration : {page}", - help: "Commandes d'exploration", + status: "État d'Hexploration : {page}", + help: "Commandes d'Hexploration", confirm: 'Veuillez confirmer', }, discovery: { @@ -4119,18 +4146,18 @@ const HexplorationMod = (() => { conceal: 'Cacher', explore: 'Explorer', revealPage: 'Révéler la page', - resetPage: 'Page de réinitialisation', + resetPage: 'Réinitialiser la page', mark: "Marquer l'emplacement", - unmark: 'Décocher', - name: 'Nom Hex', + unmark: 'Démarquer', + name: "Nommer l'hexagone", settings: 'Paramètres', - pageSettings: 'Paramètres des pages', + pageSettings: 'Paramètres de la page', status: 'Statut', rescan: 'Nouvelle analyse', - calibrate: 'Étalonner', - calibrateReset: "Réinitialiser l'étalonnage", + calibrate: 'Calibrer', + calibrateReset: 'Réinitialiser le calibrage', help: 'Aide', - change: 'Changement', + change: 'Modifier', menu: 'Menu', clearOverrides: 'Effacer les remplacements', confirmReset: 'Oui, supprimer tous les hexagones', @@ -4139,13 +4166,13 @@ const HexplorationMod = (() => { name: 'Nom du lieu (laissez vide pour effacer)', }, values: { - on: 'Sur', + on: 'Activé', off: 'Désactivé', none: 'Aucun', hexLayer: { auto: 'Auto (premier plan si disponible)', foreground: 'calque de premier plan', - objects: 'couche de jetons', + objects: 'calque des jetons', }, revealBy: { players: 'Jetons de joueur', @@ -4153,12 +4180,12 @@ const HexplorationMod = (() => { all: 'Tous les jetons', }, revealMode: { - clear: 'Clair', + clear: 'Effacer', glimpse: 'Aperçu', }, announce: { all: 'Tout le monde', - gm: 'GM uniquement', + gm: 'MJ uniquement', off: 'Désactivé', }, orientation: { @@ -4177,7 +4204,7 @@ const HexplorationMod = (() => { desc: 'Langue des menus, des messages et des documents.', }, hexLayer: { - label: 'Couche hexagonale', + label: 'Calque des hexagones', desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', }, fillColor: { @@ -4193,15 +4220,15 @@ const HexplorationMod = (() => { desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', }, glimpseColor: { - label: 'Aperçu de la couleur', - desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + label: "Couleur d'aperçu", + desc: 'Couleur que prennent les hexagones aperçus (mode de révélation Aperçu). Utilisez une couleur rgba() transparente.', }, strokeWidth: { label: 'Largeur de la bordure', desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', }, maxDistance: { - label: 'Distance de révélation hexagonale', + label: 'Distance de révélation des hexagones', desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", }, revealDistance: { @@ -4217,19 +4244,19 @@ const HexplorationMod = (() => { desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { - label: 'Des jetons qui révèlent', + label: 'Jetons révélateurs', desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", }, revealMode: { - label: 'Mode Révéler', - desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + label: 'Mode de révélation', + desc: "Effacer supprime les hexagones à portée de vue. Aperçu les rend plutôt transparents ; ils sont supprimés lorsqu'un jeton y entre.", }, announce: { - label: 'Annoncer des découvertes', + label: 'Annoncer les découvertes', desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", }, pingDiscoveries: { - label: 'Découvertes Ping', + label: 'Pinger les découvertes', desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", }, hideCoveredTokens: { @@ -4240,19 +4267,19 @@ const HexplorationMod = (() => { status: { engine: 'Moteur de jeu', grid: 'Grille', - layer: 'Couche hexagonale', + layer: 'Calque des hexagones', hexes: 'Hexagones', - named: 'Hexs nommés', - icons: 'Jetons de localisation', - glimpsed: 'Hexs aperçus', - pending: "Emplacements en attente d'un remplissage", + named: 'Hexagones nommés', + icons: "Jetons d'emplacement", + glimpsed: 'Hexagones aperçus', + pending: 'Emplacements en attente de remplissage', calibrated: 'Calibré', overrides: 'Remplacements de page', - undo: 'Annuler disponible', + undo: 'Annulation disponible', }, messages: { filled: - 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', revealed: 'Hexs révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: @@ -4278,7 +4305,7 @@ const HexplorationMod = (() => { pruned: "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: - 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -4349,16 +4376,15 @@ const HexplorationMod = (() => { 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', status: 'Montre ce que Hexploration sait de la page actuelle.', - journal: "Reconstruisez les documents d'aide et de commande.", + journal: 'Reconstruisez les documents Help et Command Deck.', help: 'Montrez cette liste.', handout: 'Les instructions complètes se trouvent dans le document « {name} ».', }, deck: { - subtitle: 'Pont de commandement', drawDesc: - "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez. Annuler le remplissage annule le dernier remplissage.", revealDesc: - "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir. Explorer révèle les alentours des jetons sélectionnés comme s'ils venaient de s'y déplacer.", locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: @@ -4379,7 +4405,7 @@ const HexplorationMod = (() => { steps: [ 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', - 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", ], @@ -4394,29 +4420,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Comment fonctionne la révélation', points: [ - 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", - 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', - "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "La distance de vue révèle les hexagones autour de chacun de ces hexagones. Avec Ligne de vue activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre les deux.", + "La distance de révélation des hexagones est enregistrée sur les hexagones au moment où ils sont dessinés. Ces hexagones ne sont révélés que depuis ce nombre d'hexagones au plus, quelle que soit la distance à laquelle un jeton peut voir. Utilisez-la pour des montagnes ou des forêts qui cachent ce qui se trouve derrière elles.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", - "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", ], }, locations: { heading: 'Hexs et emplacements nommés', points: [ - 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", - "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", - "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], }, settings: { heading: 'Paramètres', intro: - 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). Calque des hexagones, Jetons révélateurs et Langue peuvent aussi être définis sur la page de paramètres du mod.', colKey: 'Clé', colName: 'Paramètre', colDesc: 'Description', @@ -4426,7 +4452,7 @@ const HexplorationMod = (() => { heading: 'Jumpgate et héritage', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", - "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", ], @@ -4437,7 +4463,7 @@ const HexplorationMod = (() => { "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', - "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + 'La version 1 permettait à tout jeton représentant un personnage de révéler des hexagones. Réglez Jetons révélateurs sur Jetons de personnage pour conserver ce comportement.', ], colV1: 'Commande version 1', colV2: 'Commande version 2', @@ -4445,10 +4471,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Dépannage', points: [ - "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", - "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], }, @@ -4456,7 +4482,7 @@ const HexplorationMod = (() => { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', colLanguage: 'Langue', - colNative: 'Nom natif', + colNative: "Nom d'origine", colCode: 'Code', }, credits: { @@ -4472,49 +4498,49 @@ const HexplorationMod = (() => { const TRANSLATION$e = { titles: { - ready: 'Hexploration ist fertig.', - settings: 'Erkundungseinstellungen', - languages: 'Wählen Sie eine Sprache', + ready: 'Hexploration ist bereit.', + settings: 'Hexploration-Einstellungen', + languages: 'Sprache wählen', pageSettings: 'Seiteneinstellungen: {page}', - status: 'Erkundungsstatus: {page}', - help: 'Erkundungsbefehle', + status: 'Hexploration-Status: {page}', + help: 'Hexploration-Befehle', confirm: 'Bitte bestätigen', }, discovery: { title: 'Standort entdeckt', }, menu: { - draw: 'Ziehen', - reveal: 'Enthüllen und Verstecken', + draw: 'Zeichnen', + reveal: 'Aufdecken und Verdecken', locations: 'Standorte', tools: 'Werkzeuge', - layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + layerInUse: 'Neue Hexfelder werden auf der {layer} gezeichnet.', pageSettingsHelp: 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', }, buttons: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', undo: 'Füllung rückgängig machen', reveal: 'Aufdecken', conceal: 'Verbergen', explore: 'Erkunden', - revealPage: 'Seite enthüllen', + revealPage: 'Seite aufdecken', resetPage: 'Seite zurücksetzen', mark: 'Standort markieren', unmark: 'Markierung aufheben', - name: 'Name Hex', + name: 'Hexfeld benennen', settings: 'Einstellungen', pageSettings: 'Seiteneinstellungen', status: 'Status', rescan: 'Erneut scannen', calibrate: 'Kalibrieren', calibrateReset: 'Kalibrierung zurücksetzen', - help: 'Helfen', + help: 'Hilfe', change: 'Ändern', - menu: 'Speisekarte', + menu: 'Menü', clearOverrides: 'Überschreibungen löschen', - confirmReset: 'Ja, alle Verhexungen entfernen', + confirmReset: 'Ja, alle Hexfelder entfernen', }, prompts: { name: 'Standortname (zum Löschen leer lassen)', @@ -4522,11 +4548,11 @@ const HexplorationMod = (() => { values: { on: 'An', off: 'Aus', - none: 'Keiner', + none: 'Keine', hexLayer: { auto: 'Auto (Vordergrund, falls verfügbar)', foreground: 'Vordergrundebene', - objects: 'Token-Schicht', + objects: 'Token-Ebene', }, revealBy: { players: 'Spielertoken', @@ -4534,8 +4560,8 @@ const HexplorationMod = (() => { all: 'Alle Token', }, revealMode: { - clear: 'Klar', - glimpse: 'Blick', + clear: 'Entfernen', + glimpse: 'Durchsicht', }, announce: { all: 'Alle', @@ -4544,11 +4570,11 @@ const HexplorationMod = (() => { }, orientation: { vertical: 'Hex (V)', - horizontal: 'Sechskant (H)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', conceal: 'Verbergen', }, }, @@ -4558,8 +4584,8 @@ const HexplorationMod = (() => { desc: 'Sprache für Menüs, Nachrichten und Handouts.', }, hexLayer: { - label: 'Hex-Ebene', - desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + label: 'Hexfeld-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. „Auto“ versucht es mit der Vordergrundebene (über den Token) und weicht auf die Token-Ebene aus, wenn das Spiel sie nicht unterstützt.', }, fillColor: { label: 'Füllfarbe', @@ -4570,19 +4596,19 @@ const HexplorationMod = (() => { desc: 'Farbe der Umrisse neuer Hexfelder.', }, labelColor: { - label: 'Etikettenfarbe', + label: 'Beschriftungsfarbe', desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', }, glimpseColor: { - label: 'Einblick in die Farbe', - desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + label: 'Durchsicht-Farbe', + desc: 'Farbe, die Hexfelder annehmen, wenn sie durchsichtig werden (Aufdeckmodus „Durchsicht“). Verwenden Sie eine durchsichtige rgba()-Farbe.', }, strokeWidth: { label: 'Randbreite', desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', }, maxDistance: { - label: 'Hex-Enthüllungsabstand', + label: 'Aufdeckungsdistanz für Hexfelder', desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', }, revealDistance: { @@ -4594,23 +4620,23 @@ const HexplorationMod = (() => { desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', }, revealPath: { - label: 'Auf dem Weg enthüllen', + label: 'Entlang des Wegs aufdecken', desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', }, revealBy: { - label: 'Zeichen, die offenbaren', + label: 'Aufdeckende Token', desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', }, revealMode: { - label: 'Reveal-Modus', - desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + label: 'Aufdeckmodus', + desc: '„Entfernen“ entfernt Hexfelder in Sichtweite. „Durchsicht“ macht sie stattdessen durchsichtig; sie werden entfernt, sobald ein Token sie betritt.', }, announce: { - label: 'Kündigen Sie Entdeckungen an', + label: 'Entdeckungen ankündigen', desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', }, pingDiscoveries: { - label: 'Ping-Entdeckungen', + label: 'Entdeckungen anpingen', desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', }, hideCoveredTokens: { @@ -4620,16 +4646,16 @@ const HexplorationMod = (() => { }, status: { engine: 'Spiel-Engine', - grid: 'Netz', - layer: 'Hex-Schicht', - hexes: 'Verhexungen', - named: 'Benannte Verhexungen', - icons: 'Standorttoken', - glimpsed: 'Gesehene Verhexungen', - pending: 'Orte, die auf eine Besetzung warten', + grid: 'Raster', + layer: 'Hexfeld-Ebene', + hexes: 'Hexfelder', + named: 'Benannte Hexfelder', + icons: 'Standort-Token', + glimpsed: 'Durchsichtige Hexfelder', + pending: 'Standorte, die auf eine Füllung warten', calibrated: 'Kalibriert', overrides: 'Seitenüberschreibungen', - undo: 'Rückgängig machen verfügbar', + undo: 'Rückgängig möglich', }, messages: { filled: @@ -4655,11 +4681,11 @@ const HexplorationMod = (() => { 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: - 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', pruned: - 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + 'Gespeicherte Hexfelder, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie auf der Seite „Erneut scannen“ aus, um ihre Hexfelder wieder zu erfassen.', readyHint: - 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + 'Geben Sie !hexploration ein, um das Menü aufzurufen, oder öffnen Sie das Handout "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -4736,16 +4762,15 @@ const HexplorationMod = (() => { 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', - journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', help: 'Diese Liste anzeigen.', handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', }, deck: { - subtitle: 'Kommandodeck', drawDesc: - 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie dann. „Füllung rückgängig machen“ macht die letzte Füllung rückgängig.', revealDesc: - 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: @@ -4766,9 +4791,9 @@ const HexplorationMod = (() => { steps: [ 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', - 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', - 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', - 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf Füllen (oder geben Sie !hexploration fill ein). Die Formen werden durch Hexfelder ersetzt.', + 'Optional: Wählen Sie vor dem Füllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie werden unter den Hexfeldern versteckt und bei ihrer Entdeckung angekündigt.', + 'Bewegen Sie einen Spieler-Token. Jedes Hexfeld, das er durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', ], }, commands: { @@ -4781,29 +4806,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Wie Offenlegung funktioniert', points: [ - 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', - 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', - 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', - 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', - 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', - 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nur aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Zeichnen in den Hexfeldern gespeichert. Diese Hexfelder werden nur aus höchstens so vielen Hexfeldern Entfernung aufgedeckt, egal wie weit ein Token sehen kann. Nutzen Sie dies für Berge oder Wälder, die verbergen, was dahinter liegt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt.', + 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', ], }, locations: { heading: 'Benannte Hexfelder und Orte', points: [ - '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', - 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', - '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', ], }, settings: { heading: 'Einstellungen', intro: - 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + 'Ändern Sie Einstellungen mit !hexploration set (oder über die Schaltfläche „Einstellungen“). „Hexfeld-Ebene“, „Aufdeckende Token“ und „Sprache“ lassen sich auch auf der Einstellungsseite des Mods festlegen.', colKey: 'Schlüssel', colName: 'Einstellung', colDesc: 'Beschreibung', @@ -4813,9 +4838,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate und Legacy', points: [ 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', - 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', - 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', - 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + 'Ist „Hexfeld-Ebene“ auf „Auto“ gesetzt, werden Hexfelder auf der Vordergrundebene über den Token gezeichnet, sodass Spieler nicht sehen können, was darunter liegt. Ist die Vordergrundebene nicht verfügbar, wird stattdessen die Token-Ebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Hexfelder, deren Form leicht von Legacy-Hexfeldern abweicht. Wenn die Hexfelder nicht mit dem Raster einer Seite übereinstimmen, rasten Sie einen Token in der Mitte eines Hexfelds ein, wählen Sie ihn aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Token in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie auf der Seite „Erneut scannen“ aus, um sie zusammen mit ihren Namensbeschriftungen und Standort-Token wieder zu erfassen.', ], }, upgrading: { @@ -4824,7 +4849,7 @@ const HexplorationMod = (() => { 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', - 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], colV1: 'Befehl der Version 1', colV2: 'Befehl der Version 2', @@ -4832,10 +4857,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Fehlerbehebung', points: [ - 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', - 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', - 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', - 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Nichts passiert, wenn sich ein Token bewegt: Prüfen Sie, ob der Token auf der Token-Ebene liegt und zu „Aufdeckende Token“ passt und ob die Seite Hexfelder hat (!hexploration status).', + 'Hexfelder sind gegenüber dem Raster versetzt: Verwenden Sie „Kalibrieren“ und prüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Hexfelder werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr aufgedeckt: Führen Sie auf der Seite „Erneut scannen“ aus.', + '„Füllen“ meldet, dass der Bereich keine Hexfeld-Mittelpunkte enthält: Die Form muss den Mittelpunkt von mindestens einem Hexfeld enthalten.', 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', ], }, @@ -4843,7 +4868,7 @@ const HexplorationMod = (() => { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', colLanguage: 'Sprache', - colNative: 'Einheimischer Name', + colNative: 'Eigenbezeichnung', colCode: 'Code', }, credits: { @@ -4859,19 +4884,19 @@ const HexplorationMod = (() => { const TRANSLATION$d = { titles: { - ready: 'Η εξερεύνηση είναι έτοιμη.', - settings: 'Ρυθμίσεις εξερεύνησης', + ready: 'Το Hexploration είναι έτοιμο.', + settings: 'Ρυθμίσεις Hexploration', languages: 'Επιλέξτε μια γλώσσα', pageSettings: 'Ρυθμίσεις σελίδας: {page}', - status: 'Κατάσταση εξερεύνησης: {page}', - help: 'Εντολές Εξερεύνησης', + status: 'Κατάσταση Hexploration: {page}', + help: 'Εντολές Hexploration', confirm: 'Επιβεβαιώστε', }, discovery: { title: 'Ανακαλύφθηκε τοποθεσία', }, menu: { - draw: 'Ισοπαλία', + draw: 'Σχεδίαση', reveal: 'Αποκάλυψη και απόκρυψη', locations: 'Τοποθεσίες', tools: 'Εργαλεία', @@ -4882,52 +4907,52 @@ const HexplorationMod = (() => { buttons: { fill: 'Γέμισμα', fillInverse: 'Αντίστροφο γέμισμα', - undo: 'Αναίρεση συμπλήρωσης', - reveal: 'Αποκαλύπτω', + undo: 'Αναίρεση γεμίσματος', + reveal: 'Αποκάλυψη', conceal: 'Απόκρυψη', - explore: 'Εξερευνώ', + explore: 'Εξερεύνηση', revealPage: 'Αποκάλυψη σελίδας', resetPage: 'Επαναφορά σελίδας', mark: 'Επισήμανση τοποθεσίας', unmark: 'Κατάργηση επισήμανσης', - name: 'Όνομα Hex', + name: 'Ονομασία εξαγώνου', settings: 'Ρυθμίσεις', pageSettings: 'Ρυθμίσεις σελίδας', status: 'Κατάσταση', - rescan: 'Εκ νέου σάρωση', - calibrate: 'Μετρώ την διάμετρο', + rescan: 'Επανασάρωση', + calibrate: 'Βαθμονόμηση', calibrateReset: 'Επαναφορά βαθμονόμησης', help: 'Βοήθεια', change: 'Αλλαγή', menu: 'Μενού', - clearOverrides: 'Εκκαθάριση παρακάμψεων', - confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + clearOverrides: 'Κατάργηση παρακάμψεων', + confirmReset: 'Ναι, αφαίρεση όλων των εξαγώνων', }, prompts: { name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', }, values: { - on: 'Επί', - off: 'Μακριά από', - none: 'Κανένας', + on: 'Ενεργό', + off: 'Ανενεργό', + none: 'Κανένα', hexLayer: { - auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', - foreground: 'στρώμα πρώτου πλάνου', - objects: 'συμβολικό στρώμα', + auto: 'Αυτόματο (πρώτο πλάνο, αν είναι διαθέσιμο)', + foreground: 'επίπεδο πρώτου πλάνου', + objects: 'επίπεδο διακριτικών', }, revealBy: { - players: 'Μαρκάρια παίκτη', - characters: 'Μαρκάρια χαρακτήρων', - all: 'Όλες οι μάρκες', + players: 'Διακριτικά παικτών', + characters: 'Διακριτικά χαρακτήρων', + all: 'Όλα τα διακριτικά', }, revealMode: { - clear: 'Σαφής', + clear: 'Καθαρισμός', glimpse: 'Ματιά', }, announce: { - all: 'Καθένας', + all: 'Όλοι', gm: 'Μόνο GM', - off: 'Μακριά από', + off: 'Ανενεργό', }, orientation: { vertical: 'Hex (V)', @@ -4945,8 +4970,8 @@ const HexplorationMod = (() => { desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', }, hexLayer: { - label: 'Εξάγωνο στρώμα', - desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + label: 'Επίπεδο εξαγώνων', + desc: 'Πού σχεδιάζονται τα νέα εξάγωνα. Το «Αυτόματο» δοκιμάζει το επίπεδο πρώτου πλάνου (πάνω από τα διακριτικά) και, αν το παιχνίδι δεν το υποστηρίζει, χρησιμοποιεί το επίπεδο διακριτικών.', }, fillColor: { label: 'Χρώμα πλήρωσης', @@ -4957,19 +4982,19 @@ const HexplorationMod = (() => { desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', }, labelColor: { - label: 'Χρώμα ετικέτας', + label: 'Χρώμα ετικετών', desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', }, glimpseColor: { - label: 'Χρώμα Glimpse', - desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + label: 'Χρώμα Ματιάς', + desc: 'Το χρώμα που παίρνουν τα εξάγωνα στη λειτουργία «Ματιά». Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', }, strokeWidth: { label: 'Πλάτος περιγράμματος', desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', }, maxDistance: { - label: 'Εξάγωνο αποκαλύπτουν απόσταση', + label: 'Απόσταση αποκάλυψης εξαγώνων', desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', }, revealDistance: { @@ -4985,37 +5010,37 @@ const HexplorationMod = (() => { desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', }, revealBy: { - label: 'Tokens που αποκαλύπτουν', + label: 'Διακριτικά που αποκαλύπτουν', desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', - desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + desc: "Ο «Καθαρισμός» αφαιρεί τα εξάγωνα εντός όρασης. Η «Ματιά» τα κάνει αντί γι' αυτό διαφανή· αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.", }, announce: { - label: 'Ανακοινώστε Ανακαλύψεις', + label: 'Ανακοίνωση ανακαλύψεων', desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', }, pingDiscoveries: { - label: 'Ping ανακαλύψεις', + label: 'Ping στις ανακαλύψεις', desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', }, hideCoveredTokens: { - label: 'Απόκρυψη καλυμμένων κουπονιών', + label: 'Απόκρυψη καλυμμένων διακριτικών', desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { engine: 'Μηχανή παιχνιδιού', grid: 'Πλέγμα', - layer: 'Εξάγωνο στρώμα', + layer: 'Επίπεδο εξαγώνων', hexes: 'Εξάγωνα', named: 'Ονομασμένα εξάγωνα', - icons: 'Διακριτικά τοποθεσίας', - glimpsed: 'Καθαρά εξάγωνα', + icons: 'Διακριτικά τοποθεσιών', + glimpsed: 'Εξάγωνα σε Ματιά', pending: 'Τοποθεσίες που περιμένουν γέμισμα', calibrated: 'Βαθμονομημένο', - overrides: 'Σελίδα παρακάμπτει', + overrides: 'Παρακάμψεις σελίδας', undo: 'Αναίρεση διαθέσιμη', }, messages: { @@ -5042,11 +5067,11 @@ const HexplorationMod = (() => { 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: - 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', pruned: - 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πια και ξεχάστηκαν: {dropped}. Αν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά τα εξάγωνά της.', readyHint: - 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + 'Πληκτρολογήστε !hexploration για να ανοίξει το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -5058,7 +5083,7 @@ const HexplorationMod = (() => { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', - emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', @@ -5108,21 +5133,20 @@ const HexplorationMod = (() => { pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: - 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', - journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', help: 'Εμφάνιση αυτής της λίστας.', handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', }, deck: { - subtitle: 'Κατάστρωμα εντολών', drawDesc: - 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και κάντε «Γέμισμα». Η «Αναίρεση γεμίσματος» αναιρεί το τελευταίο γέμισμα.', revealDesc: - 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: @@ -5143,9 +5167,9 @@ const HexplorationMod = (() => { steps: [ 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', - 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', - 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', - 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Γέμισμα στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν από το γέμισμα, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην «Επισήμανση τοποθεσίας». Κρύβονται κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και τα εξάγωνα εντός της «Απόστασης όρασης» του, αποκαλύπτονται.', ], }, commands: { @@ -5158,29 +5182,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Πώς λειτουργεί η αποκάλυψη', points: [ - 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', - 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', - 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', - 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', - 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο αποκαλύπτεται μόνο αν δεν παρεμβάλλεται καλυμμένο εξάγωνο.', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται στα εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται μόνο από απόσταση έως τόσα εξάγωνα, όσο μακριά κι αν βλέπει ένα διακριτικό. Χρησιμοποιήστε την για βουνά ή δάση που κρύβουν ό,τι βρίσκεται πίσω τους.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.', + 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', + 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', ], }, locations: { heading: 'Με όνομα Hexes and Locations', points: [ - 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', - 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', - 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], }, settings: { heading: 'Ρυθμίσεις', intro: - 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', colName: 'Σύνθεση', colDesc: 'Περιγραφή', @@ -5190,18 +5214,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate και Legacy', points: [ 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', - 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', - 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', - 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', + 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', ], }, upgrading: { heading: 'Αναβάθμιση από την έκδοση 1', points: [ 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', - 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι υπάρχοντες εξαγωνικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσιών και οι ρυθμίσεις αναβαθμίζονται αυτόματα στην πρώτη εκκίνηση.', 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', - 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + 'Η έκδοση 1 επέτρεπε σε κάθε διακριτικό που αντιπροσώπευε χαρακτήρα να αποκαλύπτει εξάγωνα. Ορίστε τα «Διακριτικά που αποκαλύπτουν» σε «Διακριτικά χαρακτήρων» για να διατηρήσετε αυτή τη συμπεριφορά.', ], colV1: 'Εντολή έκδοσης 1', colV2: 'Εντολή έκδοσης 2', @@ -5209,10 +5233,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Αντιμετώπιση προβλημάτων', points: [ - 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', - 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', - 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', - 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Δεν συμβαίνει τίποτα όταν μετακινείται ένα διακριτικό: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο διακριτικών και ταιριάζει με τη ρύθμιση «Διακριτικά που αποκαλύπτουν», και ότι η σελίδα έχει εξάγωνα (!hexploration status).', + 'Τα εξάγωνα είναι μετατοπισμένα από το πλέγμα: χρησιμοποιήστε τη «Βαθμονόμηση» και μετά ελέγξτε με ένα διακριτικό μερικά εξάγωνα σε διάφορα σημεία του χάρτη.', + 'Τα εξάγωνα σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε «Επανασάρωση» στη σελίδα.', + 'Το «Γέμισμα» αναφέρει ότι η περιοχή δεν έχει κέντρα εξαγώνων: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξαγώνου.', 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', ], }, @@ -5220,7 +5244,7 @@ const HexplorationMod = (() => { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', - colNative: 'Εγγενές όνομα', + colNative: 'Όνομα στη γλώσσα της', colCode: 'Κώδικας', }, credits: { @@ -5236,93 +5260,93 @@ const HexplorationMod = (() => { const TRANSLATION$c = { titles: { - ready: 'החקירה מוכנה.', - settings: 'הגדרות החקירה', - languages: 'בחר שפה', + ready: 'Hexploration מוכן.', + settings: 'הגדרות Hexploration', + languages: 'בחירת שפה', pageSettings: 'הגדרות דף: {page}', - status: 'סטטוס החקירה: {page}', - help: 'פקודות החקירה', - confirm: 'אנא אשר', + status: 'מצב Hexploration: {page}', + help: 'פקודות Hexploration', + confirm: 'נא לאשר', }, discovery: { title: 'מיקום התגלה', }, menu: { - draw: 'לִמְשׁוֹך', - reveal: 'לגלות ולהסתיר', + draw: 'ציור', + reveal: 'חשיפה והסתרה', locations: 'מיקומים', - tools: 'כְּלֵי עֲבוֹדָה', - layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + tools: 'כלים', + layerInUse: 'משושים חדשים מצוירים על {layer}.', pageSettingsHelp: 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', }, buttons: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - undo: 'בטל מילוי', - reveal: 'לְגַלוֹת', - conceal: 'לְהַסתִיר', - explore: 'לַחקוֹר', - revealPage: 'גלה עמוד', - resetPage: 'אפס דף', - mark: 'סמן מיקום', - unmark: 'בטל את הסימון', - name: 'שם הקס', + undo: 'ביטול מילוי', + reveal: 'חשיפה', + conceal: 'הסתרה', + explore: 'חקירה', + revealPage: 'חשיפת הדף', + resetPage: 'איפוס הדף', + mark: 'סימון מיקום', + unmark: 'ביטול סימון', + name: 'מתן שם למשושה', settings: 'הגדרות', - pageSettings: 'הגדרות עמוד', - status: 'סטָטוּס', - rescan: 'סרוק מחדש', - calibrate: 'לְדַרֵג', + pageSettings: 'הגדרות דף', + status: 'מצב', + rescan: 'סריקה מחדש', + calibrate: 'כיול', calibrateReset: 'אפס כיול', - help: 'עֶזרָה', - change: 'לְשַׁנוֹת', - menu: 'תַפרִיט', - clearOverrides: 'נקה עקיפות', + help: 'עזרה', + change: 'שינוי', + menu: 'תפריט', + clearOverrides: 'ניקוי עקיפות', confirmReset: 'כן, הסר את כל המשושים', }, prompts: { name: 'שם המיקום (השאירו ריק כדי לנקות)', }, values: { - on: 'עַל', + on: 'מופעל', off: 'כבוי', - none: 'אַף לֹא אֶחָד', + none: 'ללא', hexLayer: { - auto: 'אוטומטי (בחזית אם זמין)', - foreground: 'שכבת חזית', - objects: 'שכבת אסימונים', + auto: 'אוטומטי (שכבת החזית אם זמינה)', + foreground: 'שכבת החזית', + objects: 'שכבת האסימונים', }, revealBy: { - players: 'אסימוני שחקן', - characters: 'אסימוני תווים', + players: 'אסימוני שחקנים', + characters: 'אסימוני דמויות', all: 'כל האסימונים', }, revealMode: { - clear: 'בָּרוּר', - glimpse: 'הֲצָצָה', + clear: 'הסרה', + glimpse: 'הצצה', }, announce: { - all: 'כֹּל אֶחָד', + all: 'כולם', gm: 'GM בלבד', off: 'כבוי', }, orientation: { - vertical: 'משושה (V)', - horizontal: 'משושה (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - conceal: 'לְהַסתִיר', + conceal: 'הסתרה', }, }, settings: { language: { - label: 'שָׂפָה', + label: 'שפה', desc: 'שפה לתפריטים, הודעות ודפי מידע.', }, hexLayer: { - label: 'שכבת משושה', + label: 'שכבת המשושים', desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', }, fillColor: { @@ -5330,23 +5354,23 @@ const HexplorationMod = (() => { desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { - label: 'צבע גבול', + label: 'צבע מסגרת', desc: 'צבע קווי המתאר של משושות חדשות.', }, labelColor: { - label: 'צבע התווית', + label: 'צבע תווית', desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', }, glimpseColor: { label: 'צבע הצצה', - desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + desc: 'הצבע שאליו משושים משתנים בעת הצצה (מצב החשיפה הצצה). השתמש בצבע rgba() שקוף.', }, strokeWidth: { - label: 'רוחב גבול', + label: 'עובי מסגרת', desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', }, maxDistance: { - label: 'מרחק חשיפת משושה', + label: 'מרחק חשיפת משושים', desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', }, revealDistance: { @@ -5358,42 +5382,42 @@ const HexplorationMod = (() => { desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', }, revealPath: { - label: 'גלה לאורך הנתיב', + label: 'חשיפה לאורך המסלול', desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', }, revealBy: { - label: 'אסימונים שחושפים', + label: 'אסימונים חושפים', desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', }, revealMode: { label: 'מצב חשיפה', - desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + desc: 'הסרה מסירה משושים שבטווח הראייה. הצצה הופכת אותם לשקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', }, announce: { - label: 'הכריזו על תגליות', + label: 'הכרזה על תגליות', desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", }, pingDiscoveries: { - label: 'פינג תגליות', + label: 'פינג לתגליות', desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', }, hideCoveredTokens: { label: 'הסתר אסימונים מכוסים', - desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + desc: 'Roll20 מצייר שמות, פסים והילות מעל משושים. כשההגדרה מופעלת, השם, הפסים וההילות הגלויים לשחקנים של אסימונים שמתחת למשושה מכוסה נכבים, ומופעלים שוב כשהם נחשפים.', }, }, status: { engine: 'מנוע משחק', - grid: 'רֶשֶׁת', - layer: 'שכבת משושה', + grid: 'רשת', + layer: 'שכבת המשושים', hexes: 'משושים', - named: 'ששים בשם', + named: 'משושים עם שם', icons: 'אסימוני מיקום', - glimpsed: 'משושים נוצצים', + glimpsed: 'משושים בהצצה', pending: 'מיקומים ממתינים למילוי', - calibrated: 'מְכוּיָל', - overrides: 'עקיפת עמוד', - undo: 'בטל זמין', + calibrated: 'מכויל', + overrides: 'עקיפות דף', + undo: 'ניתן לבטל', }, messages: { filled: @@ -5417,11 +5441,11 @@ const HexplorationMod = (() => { 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: - 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', readyHint: - 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -5483,17 +5507,16 @@ const HexplorationMod = (() => { calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', - journal: 'בנה מחדש את דפי העזרה והפקודה.', + journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', help: 'הצג רשימה זו.', handout: 'ההנחיות המלאות נמצאות בדף "{name}".', }, deck: { - subtitle: 'סיפון פיקוד', - drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. ביטול מילוי מבטל את המילוי האחרון.', revealDesc: - 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + 'בחר משושים, צורות או אסימונים כדי לחשוף אותם או לכסות אותם שוב. חקירה חושפת את הסביבה של האסימונים הנבחרים כאילו הם זזו לשם.', locationsDesc: - 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר משושים או אסימונים כדי לתת שם למשושה.', toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', footer: 'עיין בדף "{help}" להנחיות מלאות.', }, @@ -5503,7 +5526,7 @@ const HexplorationMod = (() => { footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', - body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + body: 'Hexploration מכסה מפת משושים במשושים אטומים. כשהחבורה זזה, המשושים שהיא עוברת דרכם (ואם תרצו, גם המשושים שסביבה) מוסרים, כך שהמפה נחשפת משושה אחר משושה. אפשר להציב מיקומים מוסתרים מתחת למשושים, והם מוכרזים כשהם נמצאים. הכלי עובד במשחקי Jumpgate ו-Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', demo: 'צפו בהדגמה קצרה (מגרסה 1)', }, quickStart: { @@ -5511,9 +5534,9 @@ const HexplorationMod = (() => { steps: [ 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', - 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', - 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', - 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות במשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סימון מיקום. הם מוסתרים מתחת למשושים ומוכרזים כשהם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והמשושים שבתוך מרחק הראייה שלו, נחשפים.', ], }, commands: { @@ -5526,40 +5549,40 @@ const HexplorationMod = (() => { revealing: { heading: 'איך עובד גילוי', points: [ - 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', - 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', - 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'מרחק חשיפת משושים נשמר על המשושים בזמן שהם מצוירים. משושים אלה נחשפים רק מטווח של מספר המשושים הזה, לא משנה כמה רחוק אסימון יכול לראות. השתמש בו להרים או ליערות שמסתירים את מה שמאחוריהם.', 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', + 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', ], }, locations: { heading: 'בשם משושים ומיקומים', points: [ - 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', - 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', - 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], }, settings: { heading: 'הגדרות', intro: - 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', colName: 'סְבִיבָה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, jumpgate: { - heading: 'Jumpgate ומורשת', + heading: 'Jumpgate ו-Legacy', points: [ - 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', - 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', - 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'Hexploration מזהה באיזה מנוע המשחק משתמש ומצייר את סוג הצורה המתאים. אפשר למלא צורות שצוירו בכל אחד משני העורכים.', + 'כששכבת המשושים מוגדרת לאוטומטי, משושים מצוירים בשכבת החזית, מעל האסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימונים במקום זאת.', + 'Jumpgate מצייר משושים משוכללים מתמטית, שצורתם שונה מעט ממשושי Legacy. אם המשושים אינם מתיישרים עם הרשת של הדף, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים במשושים שכנים באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', ], }, @@ -5569,7 +5592,7 @@ const HexplorationMod = (() => { 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', - 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], colV1: 'פקודה גרסה 1', colV2: 'פקודה גרסה 2', @@ -5577,9 +5600,9 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'פתרון בעיות', points: [ - 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', - 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', - 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', + 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', + 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], @@ -5588,7 +5611,7 @@ const HexplorationMod = (() => { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', colLanguage: 'שָׂפָה', - colNative: 'שם יליד', + colNative: 'שם בשפת המקור', colCode: 'קוד', }, credits: { @@ -5604,61 +5627,61 @@ const HexplorationMod = (() => { const TRANSLATION$b = { titles: { - ready: 'A hexploration készen áll.', - settings: 'Hexexploration beállítások', + ready: 'A Hexploration készen áll.', + settings: 'Hexploration-beállítások', languages: 'Válasszon nyelvet', pageSettings: 'Oldalbeállítások: {page}', - status: 'Heti feltárás állapota: {page}', + status: 'Hexploration-állapot: {page}', help: 'Hexploration parancsok', confirm: 'Kérjük, erősítse meg', }, discovery: { - title: 'Hely felfedezve', + title: 'Helyszín felfedezve', }, menu: { - draw: 'Rajzolj', - reveal: 'Felfedni és elrejteni', + draw: 'Rajzolás', + reveal: 'Felfedés és elrejtés', locations: 'Helyszínek', tools: 'Eszközök', - layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + layerInUse: 'Az új hatszögek ide kerülnek: {layer}.', pageSettingsHelp: 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', }, buttons: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', undo: 'Kitöltés visszavonása', - reveal: 'Felfedni', - conceal: 'Elrejteni', - explore: 'Fedezze fel', - revealPage: 'Oldal feltárása', + reveal: 'Felfedés', + conceal: 'Lefedés', + explore: 'Felderítés', + revealPage: 'Oldal felfedése', resetPage: 'Oldal visszaállítása', - mark: 'Hely megjelölése', - unmark: 'Törölje a jelölést', - name: 'Név Hex', - settings: 'Beállítások elemre', + mark: 'Helyszín megjelölése', + unmark: 'Jelölés törlése', + name: 'Hatszög elnevezése', + settings: 'Beállítások', pageSettings: 'Oldalbeállítások', status: 'Állapot', rescan: 'Újraszkennelés', - calibrate: 'Kalibrálni', + calibrate: 'Kalibrálás', calibrateReset: 'Kalibrálás visszaállítása', help: 'Segítség', - change: 'Változás', + change: 'Módosítás', menu: 'Menü', clearOverrides: 'Felülbírálások törlése', - confirmReset: 'Igen, távolítsa el az összes hexát', + confirmReset: 'Igen, minden hatszög eltávolítása', }, prompts: { name: 'Helynév (a törléshez hagyja üresen)', }, values: { - on: 'On', - off: 'Le', - none: 'Egyik sem', + on: 'Be', + off: 'Ki', + none: 'Nincs', hexLayer: { - auto: 'Automatikus (előtérben, ha elérhető)', - foreground: 'előtér réteg', - objects: 'token réteg', + auto: 'Automatikus (előtér, ha elérhető)', + foreground: 'előtérréteg', + objects: 'tokenréteg', }, revealBy: { players: 'Játékos tokenek', @@ -5666,22 +5689,22 @@ const HexplorationMod = (() => { all: 'Minden token', }, revealMode: { - clear: 'Világos', + clear: 'Eltávolítás', glimpse: 'Bepillantás', }, announce: { all: 'Mindenki', - gm: 'Csak GM', - off: 'Le', + gm: 'Csak a GM', + off: 'Ki', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', - conceal: 'Elrejteni', + conceal: 'Lefedés', }, }, settings: { @@ -5690,8 +5713,8 @@ const HexplorationMod = (() => { desc: 'A menük, üzenetek és tájékoztatók nyelve.', }, hexLayer: { - label: 'Hatlapos réteg', - desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + label: 'Hatszögek rétege', + desc: 'Hová kerülnek az új hatszögek. Az Automatikus az előtérréteggel próbálkozik (a tokenek fölött), és ha a játék ezt nem támogatja, a tokenréteget használja.', }, fillColor: { label: 'Kitöltés színe', @@ -5706,15 +5729,15 @@ const HexplorationMod = (() => { desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + label: 'Bepillantás színe', + desc: 'Az a szín, amelyre a hatszögek bepillantáskor váltanak (Bepillantás felfedési mód). Használjon átlátszó rgba() színt.', }, strokeWidth: { - label: 'Határ szélessége', + label: 'Szegély szélessége', desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', }, maxDistance: { - label: 'Hex Reveal távolság', + label: 'Hatszögek felfedési távolsága', desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', }, revealDistance: { @@ -5726,42 +5749,42 @@ const HexplorationMod = (() => { desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', }, revealPath: { - label: 'Fedezd fel az ösvényen', + label: 'Felfedés az útvonal mentén', desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', }, revealBy: { - label: 'Tokenek, amelyek felfedik', + label: 'Felfedő tokenek', desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', }, revealMode: { - label: 'Felfedezési mód', - desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + label: 'Felfedési mód', + desc: 'Az Eltávolítás mód eltávolítja a látótávolságon belüli hatszögeket. A Bepillantás mód ehelyett átlátszóvá teszi őket; akkor tűnnek el, amikor egy token belép beléjük.', }, announce: { - label: 'Hirdesse a felfedezéseket', + label: 'Felfedezések bejelentése', desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', }, pingDiscoveries: { - label: 'Ping felfedezések', + label: 'Felfedezések pingelése', desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', }, hideCoveredTokens: { - label: 'Fedett tokenek elrejtése', + label: 'Lefedett tokenek elrejtése', desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', }, }, status: { - engine: 'Játék motor', + engine: 'Játékmotor', grid: 'Rács', - layer: 'Hatlapos réteg', - hexes: 'Hexák', - named: 'Elnevezett hexák', - icons: 'Helyjelzők', - glimpsed: 'Megpillantott hatszögek', - pending: 'Betöltésre váró helyek', + layer: 'Hatszögek rétege', + hexes: 'Hatszögek', + named: 'Elnevezett hatszögek', + icons: 'Helyszíntokenek', + glimpsed: 'Bepillantott hatszögek', + pending: 'Kitöltésre váró helyszínek', calibrated: 'Kalibrálva', - overrides: 'Oldal felülbírálása', - undo: 'Visszavonás elérhető', + overrides: 'Oldalszintű felülbírálások', + undo: 'Visszavonható', }, messages: { filled: @@ -5787,11 +5810,11 @@ const HexplorationMod = (() => { 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', migrated: - 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: - 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + 'Mentett hatszögek, amelyek már nem léteznek, és törlődtek a nyilvántartásból: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraszkennelést az oldalon, hogy újra felvegye a hatszögeit.', readyHint: - 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + 'A menühöz írja be a !hexploration parancsot, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', }, warnings: { foregroundUnavailable: @@ -5802,7 +5825,7 @@ const HexplorationMod = (() => { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', notHex: 'Ez az oldal nem használ hatszögletű rácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', - emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', nothingToReveal: @@ -5832,7 +5855,7 @@ const HexplorationMod = (() => { calibrateNeedsTokens: 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', calibrateFailed: - 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + 'A két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hex H) kell lennie, egymástól legalább egy hatszögnyire.', unexpected: 'A részletek az API-konzol naplójában találhatók.', }, help: { @@ -5845,7 +5868,7 @@ const HexplorationMod = (() => { revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', conceal: 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', - explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', @@ -5853,22 +5876,20 @@ const HexplorationMod = (() => { set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', pageClear: 'Távolítsa el az aktuális oldal felülírásait.', - rescan: - 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', - journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', help: 'Mutasd ezt a listát.', handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', }, deck: { - subtitle: 'Parancsnoki pakli', drawDesc: 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', revealDesc: - 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', toolsDesc: @@ -5881,7 +5902,7 @@ const HexplorationMod = (() => { footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', - body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', }, quickStart: { @@ -5889,8 +5910,8 @@ const HexplorationMod = (() => { steps: [ 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', - 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', - 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', + 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', ], }, @@ -5904,29 +5925,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hogyan működik a feltárás', points: [ - 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', - 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', - 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', - 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', - 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel. Ha a Látóvonal be van kapcsolva, egy hatszög csak akkor fedődik fel, ha nincs közte és a token között lefedett hatszög.', + 'A Hatszögek felfedési távolsága a hatszögek megrajzolásakor kerül tárolásra rajtuk. Ezek a hatszögek csak ennyi hatszögnyi távolságon belülről fedhetők fel, bármilyen messzire lát is egy token. Hegyekhez vagy erdőkhöz használja, amelyek eltakarják, ami mögöttük van.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és akkor tűnnek el, amikor egy token belép beléjük.', + 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', + 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', ], }, locations: { heading: 'Hexák és helyek neve', points: [ - 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', - 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', - 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { heading: 'Beállítások elemre', intro: - 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', colKey: 'Kulcsfontosságú', colName: 'Beállítás', colDesc: 'Leírás', @@ -5936,9 +5957,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate és Legacy', points: [ 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', - 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', - 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', - 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', + 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', ], }, upgrading: { @@ -5947,7 +5968,7 @@ const HexplorationMod = (() => { 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', - 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], colV1: '1-es verzió parancs', colV2: '2-es verzió parancs', @@ -5955,23 +5976,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Hibaelhárítás', points: [ - 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, megfelel-e a Felfedő tokenek beállításnak, és vannak-e hatszögek az oldalon (!hexploration status).', 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', - 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', ], }, languages: { heading: 'Nyelvek', - body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + body: 'Nyelvet a !hexploration set language paranccsal választhat. Elérhető nyelvek:', colLanguage: 'Nyelv', - colNative: 'Natív név', + colNative: 'Saját név', colCode: 'Kód', }, credits: { heading: 'Kredit', - original: 'Eredeti mod által', + original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: @@ -5982,43 +6003,43 @@ const HexplorationMod = (() => { const TRANSLATION$a = { titles: { - ready: "L'esplorazione è pronta.", - settings: 'Impostazioni di esplorazione', + ready: 'Hexploration è pronto.', + settings: 'Impostazioni di Hexploration', languages: 'Scegli una lingua', pageSettings: 'Impostazioni pagina: {page}', - status: 'Stato esplorazione: {page}', - help: 'Comandi di esplorazione', - confirm: 'Per favore conferma', + status: 'Stato di Hexploration: {page}', + help: 'Comandi di Hexploration', + confirm: 'Conferma', }, discovery: { title: 'Posizione scoperta', }, menu: { - draw: 'Disegno', - reveal: 'Rivelare e nascondere', + draw: 'Disegna', + reveal: 'Rivela e nascondi', locations: 'Posizioni', - tools: 'Utensili', - layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + tools: 'Strumenti', + layerInUse: 'I nuovi esagoni vengono disegnati sul {layer}.', pageSettingsHelp: 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', }, buttons: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', undo: 'Annulla riempimento', - reveal: 'Svelare', - conceal: 'Nascondere', - explore: 'Esplorare', + reveal: 'Rivela', + conceal: 'Nascondi', + explore: 'Esplora', revealPage: 'Rivela pagina', resetPage: 'Reimposta pagina', mark: 'Segna posizione', - unmark: 'Deseleziona', - name: 'Nome esadecimale', + unmark: 'Rimuovi segno', + name: 'Nomina esagono', settings: 'Impostazioni', - pageSettings: 'Impostazioni della pagina', + pageSettings: 'Impostazioni pagina', status: 'Stato', rescan: 'Nuova scansione', - calibrate: 'Calibrare', + calibrate: 'Calibra', calibrateReset: 'Ripristina calibrazione', help: 'Aiuto', change: 'Modifica', @@ -6030,36 +6051,36 @@ const HexplorationMod = (() => { name: 'Nome della posizione (lascia vuoto per cancellare)', }, values: { - on: 'SU', - off: 'Spento', + on: 'Attivo', + off: 'Disattivo', none: 'Nessuno', hexLayer: { auto: 'Automatico (in primo piano se disponibile)', - foreground: 'strato di primo piano', - objects: 'strato di token', + foreground: 'livello in primo piano', + objects: 'livello dei segnalini', }, revealBy: { - players: 'Gettoni del giocatore', - characters: 'Segnalini personaggio', - all: 'Tutti i gettoni', + players: 'Segnalini dei giocatori', + characters: 'Segnalini dei personaggi', + all: 'Tutti i segnalini', }, revealMode: { - clear: 'Chiaro', - glimpse: 'Occhiata', + clear: 'Elimina', + glimpse: 'Intravedi', }, announce: { all: 'Tutti', - gm: 'Solo GM', - off: 'Spento', + gm: 'Solo il GM', + off: 'Disattivo', }, orientation: { - vertical: 'Esadecimale (V)', - horizontal: 'Esadecimale (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', - conceal: 'Nascondere', + conceal: 'Nascondi', }, }, settings: { @@ -6068,12 +6089,12 @@ const HexplorationMod = (() => { desc: 'Lingua per menu, messaggi e dispense.', }, hexLayer: { - label: 'Strato esagonale', - desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + label: 'Livello degli esagoni', + desc: 'Dove vengono disegnati i nuovi esagoni. Automatico prova il livello in primo piano (sopra i segnalini) e ripiega sul livello dei segnalini se il gioco non lo supporta.', }, fillColor: { label: 'Colore riempimento', - desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + desc: 'Colore dei nuovi esagoni. Usa rgba() per esagoni trasparenti, ad esempio rgba(0,0,0,0.8).', }, strokeColor: { label: 'Colore del bordo', @@ -6084,19 +6105,19 @@ const HexplorationMod = (() => { desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', }, glimpseColor: { - label: 'Colore scorcio', - desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + label: 'Colore degli esagoni intravisti', + desc: 'Colore che assumono gli esagoni intravisti (modalità di rivelazione Intravedi). Usa un colore rgba() trasparente.', }, strokeWidth: { label: 'Larghezza del bordo', desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', }, maxDistance: { - label: 'Distanza di rivelazione esadecimale', + label: 'Distanza di rivelazione degli esagoni', desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', }, revealDistance: { - label: 'Distanza visiva', + label: 'Distanza di vista', desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', }, lineOfSight: { @@ -6112,40 +6133,40 @@ const HexplorationMod = (() => { desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', }, revealMode: { - label: 'Modalità Rivela', - desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + label: 'Modalità di rivelazione', + desc: 'Elimina rimuove gli esagoni in vista. Intravedi invece li rende trasparenti; vengono rimossi quando un segnalino vi entra.', }, announce: { - label: 'Annunciare le scoperte', + label: 'Annuncia le scoperte', desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', }, pingDiscoveries: { - label: 'Scoperte del ping', + label: 'Ping sulle scoperte', desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', }, hideCoveredTokens: { - label: 'Nascondi i token coperti', + label: 'Nascondi i segnalini coperti', desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', }, }, status: { engine: 'Motore di gioco', grid: 'Griglia', - layer: 'Strato esagonale', + layer: 'Livello degli esagoni', hexes: 'Esagoni', named: 'Esagoni con nome', - icons: 'Gettoni di posizione', + icons: 'Segnalini di posizione', glimpsed: 'Esagoni intravisti', pending: 'Posizioni in attesa di riempimento', calibrated: 'Calibrato', - overrides: "La pagina esegue l'override", - undo: 'Annulla disponibile', + overrides: 'Sostituzioni di pagina', + undo: 'Annullamento disponibile', }, messages: { filled: 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', - revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', @@ -6165,11 +6186,11 @@ const HexplorationMod = (() => { 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: - 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', pruned: - 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Nuova scansione sulla pagina per riprenderne gli esagoni.', readyHint: - 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + 'Digita !hexploration per il menu, oppure apri la dispensa "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -6179,9 +6200,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Impossibile trovare la pagina su cui lavorare.', - notHex: 'Questa pagina non utilizza una griglia esadecimale.', + notHex: 'Questa pagina non usa una griglia esagonale.', noPolygons: 'Seleziona una o più forme disegnate da riempire.', - emptyArea: "L'area selezionata non contiene centri esadecimali.", + emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', @@ -6198,8 +6219,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', - notHex: - 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + notHex: 'Imposta la griglia della pagina su Hex (V) o Hex (H) nelle Impostazioni pagina.', noPolygons: "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", emptyArea: @@ -6210,7 +6230,7 @@ const HexplorationMod = (() => { unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: - 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', @@ -6233,21 +6253,20 @@ const HexplorationMod = (() => { pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: - "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', - journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', handout: 'Le istruzioni complete si trovano nel volantino "{name}".', }, deck: { - subtitle: 'Mazzo di comando', drawDesc: - "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla riempimento annulla l'ultimo riempimento.", revealDesc: - 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', toolsDesc: @@ -6268,9 +6287,9 @@ const HexplorationMod = (() => { steps: [ 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", - 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', - 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', - 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + 'Seleziona le forme e fai clic su Riempi nel Command Deck (oppure digita !hexploration fill). Le forme vengono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i segnalini dei luoghi importanti e fai clic su Segna posizione. Vengono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un segnalino giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di vista, vengono rivelati.', ], }, commands: { @@ -6283,29 +6302,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Come funziona la rivelazione', points: [ - 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', - 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', - 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', - "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", - 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + "La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con Linea di vista attiva, un esagono viene rivelato solo se in mezzo non c'è alcun esagono coperto.", + "La Distanza di rivelazione degli esagoni viene memorizzata sugli esagoni nel momento in cui vengono disegnati. Quegli esagoni vengono rivelati solo da non più di quel numero di esagoni di distanza, per quanto lontano possa vedere un segnalino. Usala per montagne o foreste che nascondono ciò che c'è dietro.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra.', + 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', + "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", ], }, locations: { heading: 'Esagoni e posizioni con nome', points: [ - 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', - "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", - "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], }, settings: { heading: 'Impostazioni', intro: - 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', colName: 'Collocamento', colDesc: 'Descrizione', @@ -6315,18 +6334,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legacy', points: [ "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", - "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", - "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", - 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", + 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', ], }, upgrading: { heading: 'Aggiornamento dalla versione 1', points: [ 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', - 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'Le mappe a esagoni, i nomi, i segnalini di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', - 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + 'La versione 1 permetteva a qualsiasi segnalino che rappresentasse un personaggio di rivelare esagoni. Imposta Segnalini che rivelano su Segnalini dei personaggi per mantenere quel comportamento.', ], colV1: 'Comando della versione 1', colV2: 'Comando della versione 2', @@ -6334,10 +6353,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Risoluzione dei problemi', points: [ - 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', - 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', - 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', - "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Non succede nulla quando un segnalino si muove: controlla che il segnalino sia sul livello dei segnalini e corrisponda a Segnalini che rivelano, e che la pagina abbia esagoni (!hexploration status).', + 'Gli esagoni sono sfalsati rispetto alla griglia: usa Calibra, poi controlla con un segnalino su alcuni esagoni in vari punti della mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Nuova scansione sulla pagina.', + "Riempi indica che l'area non contiene centri di esagono: la forma deve contenere il centro di almeno un esagono.", 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', ], }, @@ -6345,7 +6364,7 @@ const HexplorationMod = (() => { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", colLanguage: 'Lingua', - colNative: 'Nome nativo', + colNative: 'Nome originale', colCode: 'Codice', }, credits: { @@ -6361,61 +6380,61 @@ const HexplorationMod = (() => { const TRANSLATION$9 = { titles: { - ready: 'H探索の準備は完了です。', - settings: 'H探索設定', - languages: '言語を選択してください', + ready: 'Hexploration の準備ができました。', + settings: 'Hexploration 設定', + languages: '言語の選択', pageSettings: 'ページ設定: {page}', - status: 'H探索ステータス: {page}', - help: 'H探索コマンド', + status: 'Hexploration ステータス: {page}', + help: 'Hexploration コマンド', confirm: 'ご確認ください', }, discovery: { title: '場所が発見されました', }, menu: { - draw: '描く', + draw: '描画', reveal: '表示と非表示', - locations: '所在地', + locations: '場所', tools: 'ツール', layerInUse: '新しいヘクスが {layer} に描画されています。', pageSettingsHelp: 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', }, buttons: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', undo: '塗りつぶしを元に戻す', - reveal: '明らかにする', + reveal: '表示', conceal: '隠す', - explore: '探検する', - revealPage: 'ページを公開', + explore: '探索', + revealPage: 'ページを全表示', resetPage: 'ページをリセット', - mark: '位置をマークする', - unmark: 'マークを外す', - name: '名前の 16 進数', + mark: '場所としてマーク', + unmark: 'マーク解除', + name: 'ヘクスに名前を付ける', settings: '設定', pageSettings: 'ページ設定', - status: '状態', + status: 'ステータス', rescan: '再スキャン', - calibrate: '校正する', - calibrateReset: 'キャリブレーションをリセットする', + calibrate: '調整', + calibrateReset: '調整をリセット', help: 'ヘルプ', - change: '変化', + change: '変更', menu: 'メニュー', - clearOverrides: 'オーバーライドのクリア', - confirmReset: 'はい、すべてのヘクスを削除します', + clearOverrides: '上書きを解除', + confirmReset: 'はい、すべてのヘクスを削除', }, prompts: { name: '場所の名前 (クリアするには空白のままにします)', }, values: { - on: 'の上', + on: 'オン', off: 'オフ', none: 'なし', hexLayer: { - auto: '自動 (利用可能な場合は前景)', + auto: '自動（可能なら前景レイヤー）', foreground: '前景レイヤー', - objects: 'トークン層', + objects: 'トークンレイヤー', }, revealBy: { players: 'プレイヤートークン', @@ -6423,21 +6442,21 @@ const HexplorationMod = (() => { all: 'すべてのトークン', }, revealMode: { - clear: 'クリア', - glimpse: '垣間見る', + clear: '除去', + glimpse: '透過', }, announce: { - all: 'みんな', + all: '全員', gm: 'GMのみ', off: 'オフ', }, orientation: { - vertical: 'ヘックス(V)', - horizontal: '六角(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', conceal: '隠す', }, }, @@ -6447,8 +6466,8 @@ const HexplorationMod = (() => { desc: 'メニュー、メッセージ、配布資料の言語。', }, hexLayer: { - label: 'ヘックスレイヤー', - desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + label: 'ヘクスのレイヤー', + desc: '新しいヘクスを描画する場所。自動では前景レイヤー（トークンの上）を試し、ゲームが対応していない場合はトークンレイヤーを使用します。', }, fillColor: { label: '塗りつぶしの色', @@ -6463,19 +6482,19 @@ const HexplorationMod = (() => { desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', }, glimpseColor: { - label: '垣間見える色', - desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + label: '透過色', + desc: '透過したときにヘクスが変わる色（表示モード「透過」）。半透明の rgba() カラーを使用してください。', }, strokeWidth: { label: '枠線の幅', desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', }, maxDistance: { - label: '16進数の表示距離', + label: 'ヘクスの公開距離', desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', }, revealDistance: { - label: '視距離', + label: '視界距離', desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', }, lineOfSight: { @@ -6483,42 +6502,42 @@ const HexplorationMod = (() => { desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', }, revealPath: { - label: 'パスに沿って表示', + label: '経路に沿って表示', desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', }, revealBy: { - label: '明らかにするトークン', - desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + label: '公開するトークン', + desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { - label: 'リビールモード', - desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + label: '公開モード', + desc: '除去は視界内のヘクスを取り除きます。透過は代わりにヘクスを半透明にし、トークンが入ると取り除きます。', }, announce: { - label: '発見の発表', + label: '発見を通知', desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', }, pingDiscoveries: { - label: 'Ping の発見', + label: '発見地点をピン', desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', }, hideCoveredTokens: { - label: 'カバーされたトークンを非表示にする', + label: '覆われたトークンを隠す', desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', }, }, status: { engine: 'ゲームエンジン', grid: 'グリッド', - layer: 'ヘックスレイヤー', + layer: 'ヘクスレイヤー', hexes: 'ヘクス', named: '名前付きヘクス', - icons: '位置トークン', - glimpsed: '垣間見えるヘクス', - pending: '埋まりを待っている場所', - calibrated: '校正済み', + icons: '場所トークン', + glimpsed: '透過中のヘクス', + pending: '塗りつぶし待ちの場所', + calibrated: '調整済み', overrides: 'ページの上書き', - undo: '元に戻すことが可能', + undo: '元に戻せる操作', }, messages: { filled: @@ -6526,7 +6545,7 @@ const HexplorationMod = (() => { revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', @@ -6544,11 +6563,11 @@ const HexplorationMod = (() => { 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: - 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + 'メニューを開くには !hexploration と入力するか、配布資料 "Hexploration - Command Deck" を開きます。', }, warnings: { foregroundUnavailable: @@ -6558,7 +6577,7 @@ const HexplorationMod = (() => { }, errors: { noPage: '作業するページが見つかりませんでした。', - notHex: 'このページでは 16 進グリッドは使用されていません。', + notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', emptyArea: '選択した領域には六角中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', @@ -6577,7 +6596,7 @@ const HexplorationMod = (() => { }, hints: { noPage: '作業したいページを開くか、ページ上で何かを選択します。', - notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + notHex: 'ページ設定でページのグリッドを Hex (V) または Hex (H) に設定してください。', noPolygons: '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', @@ -6586,9 +6605,9 @@ const HexplorationMod = (() => { unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', calibrateNeedsTokens: - 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + 'トークンをヘクスの中心にスナップして選択します。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにスナップした 2 つ目のトークンも選択すると、ヘクスのサイズも補正されます。', calibrateFailed: - '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + '2 つのトークンは同じ行 (Hex V) または同じ列 (Hex H) にあり、少なくとも 1 ヘクス離れている必要があります。', unexpected: '詳細は API コンソールのログに記載されています。', }, help: { @@ -6607,21 +6626,20 @@ const HexplorationMod = (() => { set: '設定を変更するか、すべての設定を表示します。', pageSet: '現在のページでのみ公開設定をオーバーライドします。', pageClear: '現在のページのオーバーライドを削除します。', - rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', - journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + journal: 'ヘルプと Command Deck の配布資料を再構築します。', help: 'このリストを表示します。', handout: '完全な手順は配布資料「{name}」に記載されています。', }, deck: { - subtitle: 'コマンドデッキ', drawDesc: - '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + '領域の周囲に図形を描き、選択して塗りつぶします。「塗りつぶしを元に戻す」で最後の塗りつぶしを取り消せます。', revealDesc: - 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: @@ -6630,21 +6648,21 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'バージョン', - subtitle: 'Roll20 のヘックスごとの探索', + subtitle: 'Roll20 のヘクスごとの探索', footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', overview: { heading: '概要', - body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + body: 'Hexploration は、ヘクスマップを不透明なヘクスで覆います。パーティが移動すると、通過したヘクス（必要に応じてその周囲のヘクスも）が取り除かれ、マップが 1 ヘクスずつ明らかになります。隠し場所をヘクスの下に配置でき、見つかるとアナウンスされます。Jumpgate と Legacy の両方のゲームで、任意のサイズの Hex (V) および Hex (H) グリッドで動作します。', demo: '短いデモを見る (バージョン 1 から)', }, quickStart: { heading: 'クイックスタート', steps: [ - 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + 'グリッドが Hex (V) または Hex (H) に設定されたページを開きます。', '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', - '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', - 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', - 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + '図形を選択し、Command Deck の「塗りつぶし」をクリックします（または !hexploration fill と入力します）。図形がヘクスに置き換わります。', + '任意: 塗りつぶす前に、重要な場所のトークンを選択して「場所としてマーク」をクリックします。それらはヘクスの下に隠され、発見されるとアナウンスされます。', + 'プレイヤートークンを移動します。通過したすべてのヘクスと、その視界距離内のヘクスが表示されます。', ], }, commands: { @@ -6657,40 +6675,40 @@ const HexplorationMod = (() => { revealing: { heading: '暴露の仕組み', points: [ - 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', - 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', - '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', - 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', - 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', + 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを表示します。「視線」がオンの場合、間に覆われたヘクスがないときだけヘクスが表示されます。', + '「ヘクスの公開距離」は、ヘクスを描画するときにそのヘクスに保存されます。それらのヘクスは、トークンがどれだけ遠くまで見えても、その数のヘクス以内からしか表示されません。背後を隠す山や森に使用します。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。', + 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', + 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', ], }, locations: { heading: '名前付きヘクスと場所', points: [ - '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', - 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', - '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], }, settings: { heading: '設定', intro: - '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', colKey: '鍵', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', }, jumpgate: { - heading: 'ジャンプゲートとレガシー', + heading: 'Jumpgate と Legacy', points: [ 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', - 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', - 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + '「ヘクスのレイヤー」が「自動」の場合、ヘクスは前景レイヤー（トークンの上）に描画されるため、プレイヤーはその下にあるものを見ることができません。前景レイヤーが使用できない場合は、代わりにトークンレイヤーが使用されます。', + 'Jumpgate は数学的に正確な正六角形のヘクスを描画するため、Legacy のヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃わない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにある 2 つのトークンを選択すると、ヘクスのサイズも補正されます。', 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', ], }, @@ -6698,9 +6716,9 @@ const HexplorationMod = (() => { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', - 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], colV1: 'バージョン1のコマンド', colV2: 'バージョン 2 コマンド', @@ -6708,10 +6726,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'トラブルシューティング', points: [ - 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', - 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', - 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', - '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'トークンを動かしても何も起こらない: トークンがトークンレイヤー上にあり「公開するトークン」の設定に合っていること、ページにヘクスがあること（!hexploration status）を確認してください。', + 'ヘクスがグリッドからずれている: 「調整」を使い、マップ上のいくつかのヘクスにトークンを置いて確認してください。', + 'ページまたはゲームをコピーした後、ヘクスが表示されなくなりました。ページで再スキャンを実行してください。', + '「塗りつぶし」で領域にヘクスの中心がないと表示される: 図形には少なくとも 1 つのヘクスの中心が含まれている必要があります。', 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', ], }, @@ -6719,12 +6737,12 @@ const HexplorationMod = (() => { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', colLanguage: '言語', - colNative: 'ネイティブネーム', + colNative: '現地語での名称', colCode: 'コード', }, credits: { heading: 'クレジット', - original: 'オリジナルMODによる', + original: 'オリジナル版の作者', maintainer: 'バージョン 2 の保守者', marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', support: @@ -6735,19 +6753,19 @@ const HexplorationMod = (() => { const TRANSLATION$8 = { titles: { - ready: '탐색이 준비되었습니다.', - settings: '탐색 설정', - languages: '언어를 선택하세요', + ready: 'Hexploration이 준비되었습니다.', + settings: 'Hexploration 설정', + languages: '언어 선택', pageSettings: '페이지 설정: {page}', - status: '탐색 상태: {page}', - help: '탐색 명령', + status: 'Hexploration 상태: {page}', + help: 'Hexploration 명령어', confirm: '확인해주세요', }, discovery: { - title: '발견된 위치', + title: '위치 발견', }, menu: { - draw: '그리다', + draw: '그리기', reveal: '공개 및 숨기기', locations: '위치', tools: '도구', @@ -6756,35 +6774,35 @@ const HexplorationMod = (() => { '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', }, buttons: { - fill: '채우다', - fillInverse: '역 채우기', - undo: '채우기 실행 취소', - reveal: '드러내다', - conceal: '숨기다', - explore: '탐구하다', - revealPage: '페이지 공개', - resetPage: '페이지 재설정', + fill: '채우기', + fillInverse: '반전 채우기', + undo: '채우기 취소', + reveal: '공개', + conceal: '숨기기', + explore: '탐색', + revealPage: '페이지 전체 공개', + resetPage: '페이지 초기화', mark: '위치 표시', unmark: '표시 해제', - name: '이름 헥스', + name: '헥스 이름 지정', settings: '설정', pageSettings: '페이지 설정', status: '상태', rescan: '다시 스캔', - calibrate: '교정', - calibrateReset: '교정 재설정', - help: '돕다', - change: '변화', + calibrate: '보정', + calibrateReset: '보정 초기화', + help: '도움말', + change: '변경', menu: '메뉴', clearOverrides: '재정의 지우기', - confirmReset: '예, 모든 16진수를 제거합니다.', + confirmReset: '예, 모든 헥스 제거', }, prompts: { name: '위치 이름(지우려면 비워 두세요)', }, values: { - on: '~에', - off: '끄다', + on: '켜짐', + off: '꺼짐', none: '없음', hexLayer: { auto: '자동(사용 가능한 경우 전경)', @@ -6797,22 +6815,22 @@ const HexplorationMod = (() => { all: '모든 토큰', }, revealMode: { - clear: '분명한', - glimpse: '일견', + clear: '제거', + glimpse: '반투명', }, announce: { - all: '모든 사람', + all: '모두', gm: 'GM 전용', - off: '끄다', + off: '꺼짐', }, orientation: { - vertical: '16진수(V)', - horizontal: '16진수(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '채우다', - fillInverse: '역 채우기', - conceal: '숨기다', + fill: '채우기', + fillInverse: '반전 채우기', + conceal: '숨기기', }, }, settings: { @@ -6821,12 +6839,12 @@ const HexplorationMod = (() => { desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', }, hexLayer: { - label: '육각 레이어', - desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + label: '헥스 레이어', + desc: '새 헥스를 그릴 위치입니다. 자동은 전경 레이어(토큰 위)를 먼저 시도하고, 게임이 지원하지 않으면 토큰 레이어를 사용합니다.', }, fillColor: { label: '채우기 색상', - desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + desc: '새 헥스의 색상입니다. 비쳐 보이는 헥스를 원하면 rgba()를 사용하세요(예: rgba(0,0,0,0.8)).', }, strokeColor: { label: '테두리 색상', @@ -6837,19 +6855,19 @@ const HexplorationMod = (() => { desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', }, glimpseColor: { - label: '미리보기 색상', - desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + label: '반투명 색상', + desc: '반투명 상태가 된 헥스의 색상입니다(반투명 공개 모드). 비쳐 보이는 rgba() 색상을 사용하세요.', }, strokeWidth: { label: '테두리 너비', desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', }, maxDistance: { - label: '16진수 공개 거리', + label: '헥스 공개 거리', desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', }, revealDistance: { - label: '시거리', + label: '시야 거리', desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', }, lineOfSight: { @@ -6861,36 +6879,36 @@ const HexplorationMod = (() => { desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', }, revealBy: { - label: '공개되는 토큰', - desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + label: '공개하는 토큰', + desc: '토큰 레이어의 어떤 토큰이 헥스를 공개할지 정합니다: 플레이어가 조종하는 토큰, 캐릭터를 나타내는 토큰 또는 모든 토큰.', }, revealMode: { label: '공개 모드', - desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + desc: '제거는 시야 안의 헥스를 없앱니다. 반투명은 대신 헥스를 비쳐 보이게 하며, 토큰이 들어가면 제거합니다.', }, announce: { - label: '발견 발표', + label: '발견 알림', desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', }, pingDiscoveries: { - label: '핑 발견', + label: '발견 위치 핑', desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', }, hideCoveredTokens: { - label: '적용 토큰 숨기기', - desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + label: '덮인 토큰 숨기기', + desc: 'Roll20은 이름, 막대, 오라를 헥스 위에 그립니다. 켜져 있으면 덮인 헥스 아래에 있는 토큰의 플레이어에게 보이는 이름, 막대, 오라를 끄고, 덮개가 벗겨지면 다시 켭니다.', }, }, status: { engine: '게임 엔진', grid: '그리드', - layer: '육각층', + layer: '헥스 레이어', hexes: '헥스', named: '명명된 헥스', icons: '위치 토큰', - glimpsed: '살짝 엿본 육각형', + glimpsed: '반투명 헥스', pending: '채우기를 기다리는 위치', - calibrated: '교정됨', + calibrated: '보정됨', overrides: '페이지 재정의', undo: '실행 취소 가능', }, @@ -6898,16 +6916,16 @@ const HexplorationMod = (() => { filled: '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', revealed: '공개된 헥스: {count}.', - revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + revealedPage: '페이지의 모든 헥스를 공개했습니다({count}).', confirmReset: - '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', - resetPage: '페이지에서 제거된 16진수: {count}.', + '"{page}"의 모든 헥스({count})를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 이 작업은 실행 취소로 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거한 헥스: {count}.', undone: - '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + '마지막 채우기를 취소했습니다. 제거한 헥스: {removed}. 원래 스타일로 복원한 헥스: {restored}.', named: '"{name}"이라는 헥스: {count}.', unnamed: '지워진 이름: {count}.', marked: - '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + '기존 헥스 아래에 숨긴 위치: {attached}. 이 위치를 덮을 다음 채우기를 기다리는 위치: {pending}.', unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: @@ -6918,10 +6936,11 @@ const HexplorationMod = (() => { '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: - 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', pruned: - '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', - readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + '더 이상 존재하지 않아 잊어버린 저장된 헥스: {dropped}. 이 게임이나 페이지를 복사했다면 해당 페이지에서 다시 스캔을 실행해 헥스를 다시 인식시키세요.', + readyHint: + '메뉴를 보려면 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 여세요.', }, warnings: { foregroundUnavailable: @@ -6932,7 +6951,7 @@ const HexplorationMod = (() => { noPage: '작업할 페이지를 찾을 수 없습니다.', notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', - emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', @@ -6949,18 +6968,18 @@ const HexplorationMod = (() => { }, hints: { noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', - notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + notHex: '페이지 설정에서 페이지 격자를 Hex (V) 또는 Hex (H)로 설정하세요.', noPolygons: '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', - unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', - unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: - '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + '토큰 하나를 헥스 중심에 스냅한 뒤 선택하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 스냅한 두 번째 토큰도 선택하면 헥스 크기까지 보정합니다.', calibrateFailed: - '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + '두 토큰은 같은 행(Hex V) 또는 같은 열(Hex H)에 있어야 하며, 적어도 헥스 한 칸 이상 떨어져 있어야 합니다.', unexpected: '세부정보는 API 콘솔 로그에 있습니다.', }, help: { @@ -6969,53 +6988,52 @@ const HexplorationMod = (() => { fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', - revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', - conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', - resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + resetPage: '페이지의 모든 헥스를 제거합니다(먼저 확인합니다).', name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', set: '설정을 변경하거나 모든 설정을 표시합니다.', pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', pageClear: '현재 페이지의 재정의를 제거합니다.', - rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', - calibrate: - '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + rescan: + '페이지의 헥스 목록을 다시 만듭니다. 예를 들어 페이지나 게임을 복사한 뒤에 사용합니다.', + calibrate: '헥스 중심에 스냅된 토큰 한두 개를 선택해 헥스 격자를 맞춥니다.', calibrateReset: '현재 페이지의 보정을 제거합니다.', - status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', - journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + status: '현재 페이지에 대해 Hexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 Command Deck 유인물을 다시 만듭니다.', help: '이 목록을 보여주세요.', handout: '전체 지침은 "{name}" 유인물에 있습니다.', }, deck: { - subtitle: '커맨드 덱', drawDesc: - '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + '영역 주위에 도형을 그리고 선택한 다음 채웁니다. 채우기 취소는 마지막 채우기를 되돌립니다.', revealDesc: - '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + '헥스, 도형 또는 토큰을 선택해 공개하거나 다시 덮습니다. 탐색은 선택한 토큰이 그곳으로 막 이동한 것처럼 주변을 공개합니다.', locationsDesc: - '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + '토큰을 선택해 헥스 아래의 위치로 숨기세요. 헥스나 토큰을 선택해 헥스에 이름을 붙이세요.', toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', footer: '전체 지침은 "{help}" 유인물을 참조하세요.', }, handout: { versionLabel: '버전', - subtitle: 'Roll20의 16진수 탐색', + subtitle: 'Roll20용 헥스 단위 탐험', footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', overview: { heading: '개요', - body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + body: 'Hexploration은 헥스 지도를 불투명한 헥스로 덮습니다. 파티가 이동하면 지나간 헥스(원하면 주변 헥스도)가 제거되어 지도가 한 헥스씩 드러납니다. 숨겨진 위치를 헥스 아래에 둘 수 있으며, 발견되면 알려줍니다. Jumpgate와 Legacy 게임 모두에서, 모든 크기의 Hex (V) 및 Hex (H) 그리드에서 작동합니다.', demo: '짧은 데모 보기(버전 1부터)', }, quickStart: { heading: '빠른 시작', steps: [ - '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '격자가 Hex (V) 또는 Hex (H)로 설정된 페이지를 엽니다.', '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', - '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', - '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', - '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !hexploration fill 입력). 모양이 헥스로 바뀝니다.', + '선택 사항: 채우기 전에 중요한 장소의 토큰을 선택하고 위치 표시를 클릭하세요. 토큰은 헥스 아래에 숨겨지고 발견되면 알려집니다.', + '플레이어 토큰을 움직입니다. 토큰이 지나가는 모든 헥스와 시야 거리 안의 헥스가 공개됩니다.', ], }, commands: { @@ -7028,40 +7046,40 @@ const HexplorationMod = (() => { revealing: { heading: '공개 작동 방식', points: [ - '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', - 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', - 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + '헥스 공개 거리는 헥스를 그릴 때 그 헥스에 저장됩니다. 그런 헥스는 토큰이 얼마나 멀리 볼 수 있든 그 헥스 수 이내에서만 공개됩니다. 뒤에 있는 것을 가리는 산이나 숲에 사용하세요.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다.', + 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { heading: '명명된 육각형 및 위치', points: [ - 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', - 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', - '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', ], }, settings: { heading: '설정', intro: - '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', colKey: '열쇠', colName: '환경', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, jumpgate: { - heading: '점프게이트와 레거시', + heading: 'Jumpgate와 Legacy', points: [ - 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', - 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', - 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + 'Hexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 어느 편집기에서 그린 도형이든 채울 수 있습니다.', + '헥스 레이어를 자동으로 설정하면 헥스가 토큰 위의 전경 레이어에 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없으면 대신 토큰 레이어를 사용합니다.', + 'Jumpgate는 수학적으로 정확한 정육각형 헥스를 그리므로 Legacy 헥스와 모양이 약간 다릅니다. 헥스가 페이지 격자와 맞지 않으면 토큰 하나를 헥스 중심에 스냅하고 선택한 뒤 보정을 클릭하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 있는 토큰 두 개를 선택하면 헥스 크기까지 보정합니다.', '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', ], }, @@ -7069,9 +7087,9 @@ const HexplorationMod = (() => { heading: '버전 1에서 업그레이드', points: [ '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', - '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', - 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', - '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + '기존 헥스 지도, 이름, 위치 토큰과 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Hexploration_menu 매크로를 포함한 버전 1 명령은 여전히 작동합니다.', + '버전 1에서는 캐릭터를 나타내는 토큰이면 무엇이든 헥스를 공개할 수 있었습니다. 이 동작을 유지하려면 공개하는 토큰을 캐릭터 토큰으로 설정하세요.', ], colV1: '버전 1 명령', colV2: '버전 2 명령', @@ -7079,23 +7097,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: '문제 해결', points: [ - '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', - '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', - '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', - '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '토큰을 움직여도 아무 일도 일어나지 않음: 토큰이 토큰 레이어에 있고 공개하는 토큰 설정과 일치하는지, 페이지에 헥스가 있는지(!hexploration status) 확인하세요.', + '헥스가 격자에서 어긋남: 보정을 사용한 다음, 지도 곳곳의 몇몇 헥스에 토큰을 놓아 확인하세요.', + '페이지나 게임을 복사한 뒤 헥스가 더 이상 공개되지 않음: 해당 페이지에서 다시 스캔을 실행하세요.', + '채우기에서 영역에 헥스 중심이 없다고 나옴: 모양 안에 적어도 헥스 하나의 중심이 들어 있어야 합니다.', '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', ], }, languages: { heading: '언어', - body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', - colNative: '본명', + colNative: '현지어 이름', colCode: '암호', }, credits: { heading: '크레딧', - original: '원본 모드 작성자:', + original: '원본 모드 제작자', maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', support: @@ -7106,84 +7124,84 @@ const HexplorationMod = (() => { const TRANSLATION$7 = { titles: { - ready: 'Heksploracja jest gotowa.', - settings: 'Ustawienia Heksploracji', + ready: 'Hexploration jest gotowy.', + settings: 'Ustawienia Hexploration', languages: 'Wybierz język', pageSettings: 'Ustawienia strony: {page}', - status: 'Stan heksploracji: {page}', - help: 'Komendy Heksploracji', + status: 'Stan Hexploration: {page}', + help: 'Polecenia Hexploration', confirm: 'Proszę potwierdzić', }, discovery: { - title: 'Lokalizacja odkryta', + title: 'Odkryto lokalizację', }, menu: { - draw: 'Rysować', - reveal: 'Odkryj i ukryj', + draw: 'Rysowanie', + reveal: 'Odkrywanie i ukrywanie', locations: 'Lokalizacje', tools: 'Narzędzia', - layerInUse: 'Nowe heksy są rysowane na {layer}.', + layerInUse: 'Warstwa, na której rysowane są nowe heksy: {layer}.', pageSettingsHelp: 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', }, buttons: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', undo: 'Cofnij wypełnienie', - reveal: 'Ujawnić', - conceal: 'Ukryć', - explore: 'Badać', + reveal: 'Odkryj', + conceal: 'Zakryj', + explore: 'Eksploruj', revealPage: 'Odkryj stronę', resetPage: 'Zresetuj stronę', - mark: 'Zaznacz lokalizację', - unmark: 'Odznacz', - name: 'Imię Hex', + mark: 'Oznacz lokalizację', + unmark: 'Usuń oznaczenie', + name: 'Nazwij heks', settings: 'Ustawienia', pageSettings: 'Ustawienia strony', status: 'Status', rescan: 'Skanuj ponownie', - calibrate: 'Kalibrować', + calibrate: 'Kalibruj', calibrateReset: 'Zresetuj kalibrację', help: 'Pomoc', - change: 'Zmiana', + change: 'Zmień', menu: 'Menu', - clearOverrides: 'Wyczyść zastąpienia', + clearOverrides: 'Usuń nadpisania', confirmReset: 'Tak, usuń wszystkie heksy', }, prompts: { name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', }, values: { - on: 'NA', - off: 'Wyłączony', - none: 'Nic', + on: 'Włączone', + off: 'Wyłączone', + none: 'Brak', hexLayer: { auto: 'Auto (pierwszy plan, jeśli jest dostępny)', foreground: 'warstwa pierwszego planu', - objects: 'warstwa tokenów', + objects: 'warstwa żetonów', }, revealBy: { players: 'Żetony graczy', characters: 'Żetony postaci', - all: 'Wszystkie tokeny', + all: 'Wszystkie żetony', }, revealMode: { - clear: 'Jasne', - glimpse: 'Dojrzeć', + clear: 'Usuwanie', + glimpse: 'Przebłysk', }, announce: { all: 'Wszyscy', - gm: "Tylko GM'a", - off: 'Wyłączony', + gm: 'Tylko MG', + off: 'Wyłączone', }, orientation: { - vertical: 'Sześciokąt (V)', - horizontal: 'Sześciokąt (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', - conceal: 'Ukryć', + conceal: 'Zakryj', }, }, settings: { @@ -7192,8 +7210,8 @@ const HexplorationMod = (() => { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa szesnastkowa', - desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + label: 'Warstwa heksagonów', + desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { label: 'Kolor wypełnienia', @@ -7209,18 +7227,18 @@ const HexplorationMod = (() => { }, glimpseColor: { label: 'Kolor przebłysku', - desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + desc: 'Kolor, jaki przyjmują heksy objęte przebłyskiem (tryb odkrywania Przebłysk). Użyj przezroczystego koloru rgba().', }, strokeWidth: { label: 'Szerokość obramowania', desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość ujawnienia heksadecymalnego', + label: 'Odległość odkrywania heksagonów', desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', }, revealDistance: { - label: 'Odległość wzroku', + label: 'Zasięg wzroku', desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', }, lineOfSight: { @@ -7228,42 +7246,42 @@ const HexplorationMod = (() => { desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', }, revealPath: { - label: 'Odkryj wzdłuż ścieżki', + label: 'Odkrywaj wzdłuż ścieżki', desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { - label: 'Żetony, które ujawniają', + label: 'Żetony odkrywające', desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', }, revealMode: { - label: 'Tryb ujawnienia', - desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + label: 'Tryb odkrywania', + desc: 'Usuwanie usuwa heksy w zasięgu wzroku. Przebłysk zamiast tego czyni je przezroczystymi; są usuwane, gdy wejdzie na nie żeton.', }, announce: { - label: 'Ogłoś odkrycia', + label: 'Ogłaszaj odkrycia', desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', }, pingDiscoveries: { - label: 'Odkrycia pingowe', + label: 'Pinguj odkrycia', desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', }, hideCoveredTokens: { - label: 'Ukryj zakryte tokeny', + label: 'Ukrywaj zakryte żetony', desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', }, }, status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa sześciokątna', + layer: 'Warstwa heksagonów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', - glimpsed: 'Prześwietlone heksy', - pending: 'Lokalizacje oczekujące na zapełnienie', - calibrated: 'Kalibrowane', - overrides: 'Zastąpienia strony', - undo: 'Cofnij dostępne', + glimpsed: 'Heksy w przebłysku', + pending: 'Lokalizacje czekające na wypełnienie', + calibrated: 'Skalibrowano', + overrides: 'Nadpisania strony', + undo: 'Można cofnąć', }, messages: { filled: @@ -7289,10 +7307,11 @@ const HexplorationMod = (() => { 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: - 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', pruned: - 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', - readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom „Skanuj ponownie” na stronie, aby ponownie odnaleźć jej heksy.', + readyHint: + 'Wpisz !hexploration, aby otworzyć menu, lub otwórz materiał informacyjny "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -7302,9 +7321,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', - notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + notHex: 'Ta strona nie używa siatki heksowej.', noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', - emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + emptyArea: 'Zaznaczony obszar nie zawiera żadnych środków heksów.', tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', @@ -7348,25 +7367,24 @@ const HexplorationMod = (() => { resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', mark: 'Zamień wybrane żetony w ukryte lokalizacje.', - unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + unmark: 'Spraw, by zaznaczone żetony przestały być ukrytymi lokalizacjami.', set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', pageClear: 'Usuń zastąpienia bieżącej strony.', - rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + rescan: 'Odbuduj listę heksów strony, na przykład po skopiowaniu strony lub gry.', calibrate: 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', calibrateReset: 'Usuń kalibrację bieżącej strony.', - status: 'Pokaż, co Heexploration wie o bieżącej stronie.', - journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + status: 'Pokaż, co Hexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne „Pomoc” i „Command Deck”.', help: 'Pokaż tę listę.', handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', }, deck: { - subtitle: 'Pokład dowodzenia', drawDesc: 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', revealDesc: - 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + 'Zaznacz heksy, kształty lub żetony, aby je odkryć lub ponownie zakryć. „Eksploruj” odkrywa okolicę zaznaczonych żetonów, jakby właśnie się przesunęły.', locationsDesc: 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', toolsDesc: @@ -7388,28 +7406,28 @@ const HexplorationMod = (() => { steps: [ 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', - 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', - 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', - 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + 'Zaznacz kształty i kliknij „Wypełnij” w Command Deck (lub wpisz !hexploration fill). Kształty zostaną zastąpione heksami.', + 'Opcjonalnie: przed wypełnieniem zaznacz żetony ważnych miejsc i kliknij „Oznacz lokalizację”. Zostaną ukryte pod heksami i ogłoszone po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przejdzie, oraz heksy w jego zasięgu wzroku (ustawienie „Zasięg wzroku”) zostaną odkryte.', ], }, commands: { heading: 'Polecenia', intro: 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', - colCommand: 'Rozkaz', + colCommand: 'Polecenie', colDesc: 'Co to robi', }, revealing: { heading: 'Jak działa odkrywanie', points: [ - 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', - 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', - 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', - 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', - 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów. Gdy „Linia wzroku” jest włączona, heks zostaje odkryty tylko wtedy, gdy między nim a żetonem nie leży żaden zakryty heks.', + '„Odległość odkrywania heksagonów” jest zapisywana na heksach w chwili ich rysowania. Takie heksy można odkryć tylko z odległości najwyżej tylu heksów, niezależnie od tego, jak daleko widzi żeton. Używaj jej dla gór lub lasów, które zasłaniają to, co jest za nimi.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', + 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', ], }, locations: { @@ -7418,15 +7436,15 @@ const HexplorationMod = (() => { 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', - 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', - colKey: 'Klawisz', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', @@ -7435,9 +7453,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate i Dziedzictwo', points: [ 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', - 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', - 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', + 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], }, upgrading: { @@ -7445,8 +7463,8 @@ const HexplorationMod = (() => { points: [ 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', - 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', - 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + 'Polecenia wersji 1, w tym makro Hexploration_menu, nadal działają.', + 'W wersji 1 heksy mógł odkrywać każdy żeton reprezentujący postać. Aby zachować to zachowanie, ustaw „Żetony odkrywające” na „Żetony postaci”.', ], colV1: 'Polecenie wersji 1', colV2: 'Polecenie wersji 2', @@ -7454,18 +7472,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Rozwiązywanie problemów', points: [ - 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Nic się nie dzieje, gdy żeton się porusza: sprawdź, czy żeton jest na warstwie żetonów i pasuje do ustawienia „Żetony odkrywające” oraz czy strona ma heksy (!hexploration status).', 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', - 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', - 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'Heksy przestały się odkrywać po skopiowaniu strony lub gry: uruchom „Skanuj ponownie” na stronie.', + '„Wypełnij” zgłasza, że obszar nie zawiera środków heksów: kształt musi zawierać środek co najmniej jednego heksu.', 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', ], }, languages: { heading: 'Języki', - body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + body: 'Wybierz język poleceniem !hexploration set language. Dostępne języki:', colLanguage: 'Język', - colNative: 'Imię rodzime', + colNative: 'Nazwa rodzima', colCode: 'Kod', }, credits: { @@ -7481,46 +7499,46 @@ const HexplorationMod = (() => { const TRANSLATION$6 = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Definições do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Definições da página: {page}', - status: 'Estado de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Estado do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + layerInUse: 'Os novos hexágonos estão a ser desenhados na {layer}.', pageSettingsHelp: 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', - settings: 'Configurações', - pageSettings: 'Configurações de página', - status: 'Estatuto', - rescan: 'Digitalizar novamente', + name: 'Nomear hexágono', + settings: 'Definições', + pageSettings: 'Definições da página', + status: 'Estado', + rescan: 'Reanalisar', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -7529,26 +7547,26 @@ const HexplorationMod = (() => { name: 'Nome do local (deixar em branco para limpar)', }, values: { - on: 'Em', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de fichas', }, revealBy: { - players: 'Tokens de jogador', + players: 'Fichas de jogador', characters: 'Fichas de personagem', - all: 'Todos os tokens', + all: 'Todas as fichas', }, revealMode: { - clear: 'Claro', - glimpse: 'Relance', + clear: 'Limpar', + glimpse: 'Vislumbre', }, announce: { all: 'Toda a gente', - gm: 'Apenas GM', + gm: 'Apenas o GM', off: 'Desligado', }, orientation: { @@ -7557,8 +7575,8 @@ const HexplorationMod = (() => { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { @@ -7567,8 +7585,8 @@ const HexplorationMod = (() => { desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', - desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + label: 'Camada dos hexágonos', + desc: 'Onde são desenhados os novos hexágonos. Automático tenta a camada de primeiro plano (acima das fichas) e recorre à camada de fichas se o jogo não a suportar.', }, fillColor: { label: 'Cor de preenchimento', @@ -7583,15 +7601,15 @@ const HexplorationMod = (() => { desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Utilize uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -7607,37 +7625,37 @@ const HexplorationMod = (() => { desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', }, revealBy: { - label: 'Tokens que revelam', + label: 'Fichas que revelam', desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre torna-os transparentes; são removidos quando uma ficha entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', }, hideCoveredTokens: { - label: 'Ocultar tokens cobertos', + label: 'Ocultar fichas cobertas', desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', }, }, status: { engine: 'Motor de jogo', - grid: 'Rede', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + grid: 'Grelha', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Fichas de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Fichas de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais a aguardar preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -7646,7 +7664,7 @@ const HexplorationMod = (() => { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -7664,10 +7682,11 @@ const HexplorationMod = (() => { 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos guardados que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute Reanalisar na página para recuperar os seus hexágonos.', + readyHint: + 'Escreva !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -7677,9 +7696,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não utiliza uma grelha hexadecimal.', + notHex: 'Esta página não utiliza uma grelha hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -7690,7 +7709,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', unexpected: 'Algo correu mal: {message}', }, @@ -7706,9 +7725,9 @@ const HexplorationMod = (() => { unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe uma ficha no centro de um hexágono e selecione-a. Selecione uma segunda ficha encaixada num hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'As duas fichas têm de estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log da consola da API.', }, help: { @@ -7720,8 +7739,9 @@ const HexplorationMod = (() => { 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: + 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -7729,34 +7749,33 @@ const HexplorationMod = (() => { pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grelha hexagonal com uma ou duas fichas selecionadas encaixadas em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: - 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + 'Selecione hexágonos, formas ou fichas para os revelar ou voltar a cobrir. Explorar revela à volta das fichas selecionadas como se se tivessem movido.', locationsDesc: - 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Utilize o folheto "{deck}" para controlos de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se desloca, os hexágonos por onde passa (e, se quiser, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Podem ser colocados locais escondidos sob os hexágonos, que são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -7764,9 +7783,9 @@ const HexplorationMod = (() => { steps: [ 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione fichas de locais importantes e clique em Marcar local. Ficam escondidas sob os hexágonos e são anunciadas quando descobertas.', + 'Mova uma ficha de jogador. Cada hexágono por onde passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -7779,29 +7798,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + 'A Distância de revelação dos hexágonos é guardada nos hexágonos quando são desenhados. Esses hexágonos só são revelados a, no máximo, esse número de hexágonos de distância, por mais longe que uma ficha consiga ver. Utilize-a para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + 'Altere as definições com !hexploration set (ou com o botão Definições). Camada dos hexágonos, Fichas que revelam e Idioma também podem ser definidos na página de definições do Mod.', colKey: 'Chave', colName: 'Definição', colDesc: 'Descrição', @@ -7811,18 +7830,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com uma forma ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não ficarem alinhados com a grelha da página, encaixe uma ficha no centro de um hexágono, selecione-a e clique em Calibrar. Selecione duas fichas em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Reanalisar na página para os voltar a apanhar, juntamente com as suas etiquetas de nome e fichas de local.', ], }, upgrading: { heading: 'Atualização da versão 1', points: [ 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', - 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, fichas de localização e definições existentes são atualizados automaticamente no primeiro arranque.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + 'A versão 1 permitia que qualquer ficha que representasse uma personagem revelasse hexágonos. Defina Fichas que revelam como Fichas de personagem para manter este comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -7830,10 +7849,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', - 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', - 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Nada acontece quando uma ficha se move: verifique se a ficha está na camada de fichas e corresponde a Fichas que revelam, e se a página tem hexágonos (!hexploration status).', + 'Os hexágonos estão desalinhados com a grelha: use Calibrar e verifique depois com uma ficha em alguns hexágonos do mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute Reanalisar na página.', + 'Preencher indica que a área não tem centros de hexágonos: a forma tem de conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', ], }, @@ -7841,7 +7860,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Idioma', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { @@ -7857,46 +7876,46 @@ const HexplorationMod = (() => { const TRANSLATION$5 = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Configurações do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Configurações da página: {page}', - status: 'Status de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Status do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { - draw: 'Empate', + draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + layerInUse: 'Novos hexágonos estão sendo desenhados na {layer}.', pageSettingsHelp: 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', + name: 'Nomear hexágono', settings: 'Configurações', - pageSettings: 'Configurações de página', + pageSettings: 'Configurações da página', status: 'Status', - rescan: 'Digitalizar novamente', + rescan: 'Reescanear', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -7905,21 +7924,21 @@ const HexplorationMod = (() => { name: 'Nome do local (deixe em branco para limpar)', }, values: { - on: 'Sobre', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de tokens', }, revealBy: { players: 'Tokens de jogador', - characters: 'Fichas de personagem', + characters: 'Tokens de personagem', all: 'Todos os tokens', }, revealMode: { - clear: 'Claro', + clear: 'Limpar', glimpse: 'Vislumbre', }, announce: { @@ -7933,17 +7952,17 @@ const HexplorationMod = (() => { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { language: { - label: 'Linguagem', + label: 'Idioma', desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', + label: 'Camada dos hexágonos', desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', }, fillColor: { @@ -7955,19 +7974,19 @@ const HexplorationMod = (() => { desc: 'Cor do contorno dos novos hexágonos.', }, labelColor: { - label: 'Cor da etiqueta', + label: 'Cor do rótulo', desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Use uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -7988,14 +8007,14 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre os torna transparentes; eles são removidos quando um token entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', }, hideCoveredTokens: { @@ -8006,14 +8025,14 @@ const HexplorationMod = (() => { status: { engine: 'Motor de jogo', grid: 'Grade', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Tokens de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Tokens de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais aguardando preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -8022,7 +8041,7 @@ const HexplorationMod = (() => { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -8040,10 +8059,11 @@ const HexplorationMod = (() => { 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute Reescanear na página para recuperar seus hexágonos.', + readyHint: + 'Digite !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8053,9 +8073,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não usa uma grade hexadecimal.', + notHex: 'Esta página não usa uma grade hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -8066,7 +8086,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', unexpected: 'Algo deu errado: {message}', }, @@ -8082,13 +8102,13 @@ const HexplorationMod = (() => { unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token encaixado em um hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'Os dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log do console da API.', }, help: { - menu: 'Mostre o cardápio.', + menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', @@ -8096,8 +8116,9 @@ const HexplorationMod = (() => { 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: + 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta antes).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -8105,34 +8126,33 @@ const HexplorationMod = (() => { pageSet: 'Substituir uma configuração de revelação somente na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grade hexagonal com um ou dois tokens selecionados encaixados em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + 'Selecione hexágonos, formas ou tokens para revelá-los ou cobri-los novamente. Explorar revela ao redor dos tokens selecionados como se eles tivessem se movido.', locationsDesc: - 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Use o folheto "{deck}" para controles de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais ele passa (e, se você quiser, os hexágonos ao redor) são removidos, de modo que o mapa é descoberto um hexágono por vez. Locais ocultos podem ser colocados sob os hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -8140,9 +8160,9 @@ const HexplorationMod = (() => { steps: [ 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar local. Eles ficam ocultos sob os hexágonos e são anunciados quando descobertos.', + 'Mova um token de jogador. Cada hexágono pelo qual ele passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -8155,31 +8175,31 @@ const HexplorationMod = (() => { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', + 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A Distância de revelação dos hexágonos é gravada nos hexágonos quando eles são desenhados. Esses hexágonos só são revelados a no máximo essa quantidade de hexágonos de distância, por mais longe que um token consiga ver. Use-a para montanhas ou florestas que escondem o que há atrás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles.', + 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + 'Altere as configurações com !hexploration set (ou com o botão Configurações). Camada dos hexágonos, Tokens que revelam e Idioma também podem ser definidos na página de configurações do Mod.', colKey: 'Chave', - colName: 'Contexto', + colName: 'Configuração', colDesc: 'Descrição', perPage: '(Pode ser definido por página.)', }, @@ -8187,18 +8207,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com um formato ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não se alinharem com a grade da página, encaixe um token no centro de um hexágono, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Reescanear na página para recuperá-los, junto com seus rótulos de nome e tokens de local.', ], }, upgrading: { heading: 'Atualizando da versão 1', points: [ 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', - 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + 'A versão 1 permitia que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que revelam como Tokens de personagem para manter esse comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -8206,10 +8226,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', - 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', + 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', ], }, @@ -8217,7 +8237,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Linguagem', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { @@ -8233,84 +8253,84 @@ const HexplorationMod = (() => { const TRANSLATION$4 = { titles: { - ready: 'Геразведка готова.', + ready: 'Hexploration готова.', settings: 'Настройки Hexploration', languages: 'Выберите язык', pageSettings: 'Настройки страницы: {page}', - status: 'Статус гексоразведки: {page}', - help: 'Команды гексоразведки', + status: 'Статус Hexploration: {page}', + help: 'Команды Hexploration', confirm: 'Пожалуйста, подтвердите', }, discovery: { - title: 'Местоположение обнаружено', + title: 'Локация обнаружена', }, menu: { - draw: 'Рисовать', - reveal: 'Показать и скрыть', + draw: 'Рисование', + reveal: 'Раскрытие и скрытие', locations: 'Локации', tools: 'Инструменты', - layerInUse: 'Новые гексы рисуются на {layer}.', + layerInUse: 'Новые гексы рисуются на этом слое: {layer}.', pageSettingsHelp: 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', }, buttons: { - fill: 'Наполнять', + fill: 'Заполнить', fillInverse: 'Обратная заливка', undo: 'Отменить заливку', - reveal: 'Раскрывать', + reveal: 'Раскрыть', conceal: 'Скрыть', explore: 'Исследовать', - revealPage: 'Открыть страницу', + revealPage: 'Раскрыть страницу', resetPage: 'Сбросить страницу', - mark: 'Отметить местоположение', + mark: 'Отметить локацию', unmark: 'Снять отметку', - name: 'Шестнадцатеричное имя', + name: 'Назвать гекс', settings: 'Настройки', pageSettings: 'Настройки страницы', status: 'Статус', - rescan: 'Повторное сканирование', - calibrate: 'Калибровка', - calibrateReset: 'Сброс калибровки', - help: 'Помощь', - change: 'Изменять', + rescan: 'Пересканировать', + calibrate: 'Калибровать', + calibrateReset: 'Сбросить калибровку', + help: 'Справка', + change: 'Изменить', menu: 'Меню', - clearOverrides: 'Очистить переопределения', - confirmReset: 'Да, удалить все шестигранники', + clearOverrides: 'Сбросить переопределения', + confirmReset: 'Да, удалить все гексы', }, prompts: { name: 'Название местоположения (оставьте пустым, чтобы очистить)', }, values: { - on: 'На', - off: 'Выключенный', - none: 'Никто', + on: 'Вкл.', + off: 'Выкл.', + none: 'Нет', hexLayer: { - auto: 'Авто (на переднем плане, если доступно)', - foreground: 'передний слой', + auto: 'Авто (передний план, если доступен)', + foreground: 'слой переднего плана', objects: 'слой токенов', }, revealBy: { - players: 'Жетоны игроков', - characters: 'Жетоны персонажей', + players: 'Токены игроков', + characters: 'Токены персонажей', all: 'Все токены', }, revealMode: { - clear: 'Прозрачный', - glimpse: 'Случайно заметить', + clear: 'Очистка', + glimpse: 'Проблеск', }, announce: { - all: 'Каждый', - gm: 'только ГМ', - off: 'Выключенный', + all: 'Все', + gm: 'Только ГМ', + off: 'Выкл.', }, orientation: { - vertical: 'Шестигранник (В)', - horizontal: 'Шестигранник (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Наполнять', + fill: 'Заливка', fillInverse: 'Обратная заливка', - conceal: 'Скрыть', + conceal: 'Скрытие', }, }, settings: { @@ -8319,8 +8339,8 @@ const HexplorationMod = (() => { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Шестнадцатеричный слой', - desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + label: 'Слой шестиугольников', + desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', @@ -8331,19 +8351,19 @@ const HexplorationMod = (() => { desc: 'Цвет контура новых гексов.', }, labelColor: { - label: 'Цвет этикетки', + label: 'Цвет меток', desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', }, glimpseColor: { - label: 'Взгляд цвета', - desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + label: 'Цвет проблеска', + desc: 'Цвет, который принимают гексы в режиме «Проблеск». Используйте полупрозрачный цвет rgba().', }, strokeWidth: { label: 'Ширина границы', desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Расстояние раскрытия шестигранника', + label: 'Дальность раскрытия шестиугольников', desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -8355,50 +8375,50 @@ const HexplorationMod = (() => { desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', }, revealPath: { - label: 'Показать вдоль пути', + label: 'Раскрывать вдоль пути', desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', }, revealBy: { - label: 'Жетоны, которые раскрывают', + label: 'Раскрывающие токены', desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', }, revealMode: { label: 'Режим раскрытия', - desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + desc: '«Очистка» удаляет гексы в пределах видимости. «Проблеск» вместо этого делает их полупрозрачными; они удаляются, когда в них входит токен.', }, announce: { label: 'Объявлять об открытиях', desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', }, pingDiscoveries: { - label: 'Пинг-открытия', + label: 'Пинговать находки', desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', }, hideCoveredTokens: { - label: 'Скрыть покрытые токены', + label: 'Скрывать токены под гексами', desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', }, }, status: { engine: 'Игровой движок', grid: 'Сетка', - layer: 'Шестнадцатеричный слой', - hexes: 'шестиугольники', - named: 'Именованные шестигранники', - icons: 'Жетоны местоположения', - glimpsed: 'Замеченные гексы', - pending: 'Места, ожидающие заполнения', - calibrated: 'Калиброванный', - overrides: 'Переопределения страниц', - undo: 'Отмена доступна', + layer: 'Слой гексов', + hexes: 'Гексы', + named: 'Именованные гексы', + icons: 'Токены локаций', + glimpsed: 'Гексы в проблеске', + pending: 'Локации, ожидающие заливки', + calibrated: 'Откалибровано', + overrides: 'Переопределения страницы', + undo: 'Доступна отмена', }, messages: { filled: 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', revealed: 'Обнаружены гексы: {count}.', - revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: - 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', resetPage: 'Со страницы удалены шестигранники: {count}.', undone: 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', @@ -8416,11 +8436,11 @@ const HexplorationMod = (() => { 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: - 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', pruned: - 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + 'Забыты сохранённые гексы, которых больше нет: {dropped}. Если эта игра или страница была скопирована, выполните «Пересканировать» на странице, чтобы снова найти её гексы.', readyHint: - 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + 'Введите !hexploration, чтобы открыть меню, или откройте раздаточный материал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8460,9 +8480,9 @@ const HexplorationMod = (() => { unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: - 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Привяжите токен к центру гекса и выделите его. Чтобы заодно исправить размер гекса, выделите второй токен, привязанный к соседнему гексу в той же строке (Hex V) или в том же столбце (Hex H).', calibrateFailed: - 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + 'Два токена должны находиться в одной строке (Hex V) или в одном столбце (Hex H) на расстоянии не менее одного гекса друг от друга.', unexpected: 'Подробности в журнале консоли API.', }, help: { @@ -8474,29 +8494,27 @@ const HexplorationMod = (() => { revealPage: 'Раскройте каждый гекс на странице без объявлений.', conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', - resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', pageSet: 'Переопределить настройку отображения только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', - rescan: - 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', - journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', help: 'Покажите этот список.', handout: 'Полные инструкции приведены в раздаточном материале «{name}».', }, deck: { - subtitle: 'Командная колода', drawDesc: - 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + 'Обведите область фигурами, выделите их и нажмите «Заполнить». «Отменить заливку» отменяет последнюю заливку.', revealDesc: - 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + 'Выделите гексы, фигуры или токены, чтобы раскрыть их или снова скрыть. «Исследовать» раскрывает гексы вокруг выбранных токенов, как если бы они туда переместились.', locationsDesc: 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', toolsDesc: @@ -8505,11 +8523,11 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Версия', - subtitle: 'Шестнадцатеричное исследование для Roll20', + subtitle: 'Исследование гекс за гексом для Roll20', footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', overview: { heading: 'Обзор', - body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + body: 'Hexploration закрывает гексовую карту непрозрачными гексами. По мере продвижения группы гексы, через которые она проходит (и, при желании, гексы вокруг них), удаляются, так что карта открывается гекс за гексом. Под гексами можно разместить скрытые локации — при обнаружении о них будет объявлено. Работает в играх Jumpgate и Legacy, на сетках Hex (V) и Hex (H) любого размера.', demo: 'Посмотрите короткую демонстрацию (из версии 1)', }, quickStart: { @@ -8517,9 +8535,9 @@ const HexplorationMod = (() => { steps: [ 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', - 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', - 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', - 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + 'Выделите фигуры и нажмите «Заполнить» в Command Deck (или введите !hexploration fill). Фигуры заменятся гексами.', + 'Необязательно: перед заливкой выделите токены важных мест и нажмите «Отметить локацию». Они будут спрятаны под гексами, а при обнаружении о них будет объявлено.', + 'Переместите токен игрока. Каждый гекс, через который он проходит, и гексы в пределах его «Расстояния обзора» раскрываются.', ], }, commands: { @@ -8532,29 +8550,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Как работает выявление', points: [ - 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', - 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', - 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', - 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', - 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', + 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов. При включённой «Линии видимости» гекс раскрывается, только если между ним и токеном нет закрытого гекса.', + '«Дальность раскрытия шестиугольников» сохраняется в гексах при их рисовании. Такие гексы раскрываются только с расстояния не больше этого числа гексов, как бы далеко ни видел токен. Используйте её для гор или лесов, скрывающих то, что за ними.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен.', + 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', + 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', ], }, locations: { heading: 'Именованные гексы и локации', points: [ - 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', - 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', @@ -8564,18 +8582,18 @@ const HexplorationMod = (() => { heading: 'Джампгейт и Наследие', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', - 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', - 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', + 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], }, upgrading: { heading: 'Обновление с версии 1', points: [ 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', - 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Существующие гексовые карты, имена, токены локаций и настройки обновляются автоматически при первом запуске.', 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', - 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + 'В версии 1 гексы мог раскрывать любой токен, представляющий персонажа. Чтобы сохранить такое поведение, установите для «Раскрывающие токены» значение «Токены персонажей».', ], colV1: 'Команда версии 1', colV2: 'Команда версии 2', @@ -8583,18 +8601,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Поиск неисправностей', points: [ - 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', - 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', - 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', - 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токенов и подходит под настройку «Раскрывающие токены», а на странице есть гексы (!hexploration status).', + 'Гексы смещены относительно сетки: нажмите «Калибровать», затем проверьте токеном несколько гексов в разных частях карты.', + 'Гексы перестали раскрываться после копирования страницы или игры: выполните «Пересканировать» на странице.', + '«Заполнить» сообщает, что в области нет центров гексов: фигура должна содержать центр хотя бы одного гекса.', 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', ], }, languages: { heading: 'Языки', - body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + body: 'Выберите язык командой !hexploration set language. Доступные языки:', colLanguage: 'Язык', - colNative: 'Родное имя', + colNative: 'Самоназвание', colCode: 'Код', }, credits: { @@ -8610,13 +8628,13 @@ const HexplorationMod = (() => { const TRANSLATION$3 = { titles: { - ready: 'La hexploración está lista.', - settings: 'Configuración de hexploración', + ready: 'Hexploration está listo.', + settings: 'Configuración de Hexploration', languages: 'Elige un idioma', pageSettings: 'Configuración de página: {page}', - status: 'Estado de exploración: {page}', - help: 'Comandos de hexploración', - confirm: 'Por favor confirme', + status: 'Estado de Hexploration: {page}', + help: 'Comandos de Hexploration', + confirm: 'Por favor, confirme', }, discovery: { title: 'Ubicación descubierta', @@ -8626,12 +8644,12 @@ const HexplorationMod = (() => { reveal: 'Revelar y ocultar', locations: 'Ubicaciones', tools: 'Herramientas', - layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + layerInUse: 'Se están dibujando nuevos hexágonos en la {layer}.', pageSettingsHelp: 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', }, buttons: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', undo: 'Deshacer relleno', reveal: 'Revelar', @@ -8641,8 +8659,8 @@ const HexplorationMod = (() => { resetPage: 'Restablecer página', mark: 'Marcar ubicación', unmark: 'Desmarcar', - name: 'Nombre hexadecimal', - settings: 'Ajustes', + name: 'Nombrar hexágono', + settings: 'Configuración', pageSettings: 'Configuración de página', status: 'Estado', rescan: 'Volver a escanear', @@ -8658,34 +8676,34 @@ const HexplorationMod = (() => { name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', }, values: { - on: 'En', - off: 'Apagado', + on: 'Activado', + off: 'Desactivado', none: 'Ninguno', hexLayer: { auto: 'Auto (primer plano si está disponible)', foreground: 'capa de primer plano', - objects: 'capa de token', + objects: 'capa de fichas', }, revealBy: { - players: 'fichas de jugador', + players: 'Fichas de jugador', characters: 'Fichas de personaje', all: 'Todas las fichas', }, revealMode: { - clear: 'Claro', + clear: 'Despejar', glimpse: 'Vistazo', }, announce: { all: 'Todos', - gm: 'solo GM', - off: 'Apagado', + gm: 'Solo el DJ', + off: 'Desactivado', }, orientation: { - vertical: 'Hexágono (V)', - horizontal: 'Hexagonal (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', conceal: 'Ocultar', }, @@ -8696,7 +8714,7 @@ const HexplorationMod = (() => { desc: 'Idioma para menús, mensajes y folletos.', }, hexLayer: { - label: 'Capa hexagonal', + label: 'Capa de hexágonos', desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', }, fillColor: { @@ -8712,15 +8730,15 @@ const HexplorationMod = (() => { desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', }, glimpseColor: { - label: 'Color de vislumbre', - desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + label: 'Color de vistazo', + desc: 'Color que toman los hexágonos al vislumbrarse (modo de revelación Vistazo). Use un color rgba() transparente.', }, strokeWidth: { label: 'Ancho del borde', desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', }, maxDistance: { - label: 'Distancia de revelación hexagonal', + label: 'Distancia de revelación de hexágonos', desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', }, revealDistance: { @@ -8740,38 +8758,38 @@ const HexplorationMod = (() => { desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', }, revealMode: { - label: 'Modo revelar', - desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + label: 'Modo de revelación', + desc: 'Despejar elimina los hexágonos a la vista. Vistazo, en cambio, los vuelve transparentes; se eliminan cuando una ficha entra en ellos.', }, announce: { label: 'Anunciar descubrimientos', desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', }, pingDiscoveries: { - label: 'Descubrimientos de ping', + label: 'Hacer ping a los descubrimientos', desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', }, hideCoveredTokens: { - label: 'Ocultar tokens cubiertos', + label: 'Ocultar fichas cubiertas', desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', }, }, status: { - engine: 'motor de juego', - grid: 'Red', - layer: 'capa hexagonal', + engine: 'Motor de juego', + grid: 'Cuadrícula', + layer: 'Capa de hexágonos', hexes: 'Hexágonos', named: 'Hexágonos con nombre', icons: 'Fichas de ubicación', glimpsed: 'Hexágonos vislumbrados', - pending: 'Ubicaciones esperando ser llenadas', + pending: 'Ubicaciones pendientes de relleno', calibrated: 'Calibrado', overrides: 'Anulaciones de página', undo: 'Deshacer disponible', }, messages: { filled: - 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + 'Relleno completado. Hexágonos dibujados: {created}. Con nuevo estilo: {restyled}. Ubicaciones ocultas: {icons}.', revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: @@ -8793,11 +8811,11 @@ const HexplorationMod = (() => { 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: - 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', pruned: 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', readyHint: - 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + 'Escriba !hexploration para ver el menú o abra el folleto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8807,9 +8825,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'No se pudo encontrar la página para trabajar.', - notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + notHex: 'Esta página no utiliza una cuadrícula hexagonal.', noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', - emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + emptyArea: 'El área seleccionada no contiene ningún centro de hexágono.', tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', @@ -8820,7 +8838,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuración desconocida: {key}', unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', invalidValue: '"{value}" no es un valor válido para {key}.', - calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateNeedsTokens: 'Seleccione una o dos fichas ajustadas a centros de hexágonos.', calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', unexpected: 'Algo salió mal: {message}', }, @@ -8862,21 +8880,20 @@ const HexplorationMod = (() => { pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: - 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', - journal: 'Reconstruya los folletos de Ayuda y Comando.', + journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', help: 'Muestra esta lista.', handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', }, deck: { - subtitle: 'Cubierta de mando', drawDesc: - 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + 'Dibuja formas alrededor de un área, selecciónalas y luego rellena. Deshacer relleno revierte el último relleno.', revealDesc: - 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + 'Selecciona hexágonos, formas o fichas para revelarlos o volver a cubrirlos. Explorar revela alrededor de las fichas seleccionadas como si se hubieran movido.', locationsDesc: 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', toolsDesc: @@ -8897,7 +8914,7 @@ const HexplorationMod = (() => { steps: [ 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', - 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], @@ -8912,29 +8929,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Cómo funciona la revelación', points: [ - 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', + 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', ], }, locations: { heading: 'Hexágonos y ubicaciones con nombre', points: [ - 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', - 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', - 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], }, settings: { heading: 'Ajustes', intro: - 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', colKey: 'Llave', colName: 'Configuración', colDesc: 'Descripción', @@ -8944,18 +8961,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate y legado', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', - 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', - 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', - 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, cuya forma es ligeramente distinta de la de los hexágonos de Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha al centro de un hexágono, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos, junto con sus etiquetas de nombre y fichas de ubicación.', ], }, upgrading: { heading: 'Actualización desde la versión 1', points: [ 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', - 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los mapas de hexágonos, nombres, fichas de ubicación y ajustes existentes se actualizan automáticamente la primera vez que se inicia.', 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', - 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + 'La versión 1 permitía que cualquier ficha que representara a un personaje revelara hexágonos. Ajuste Fichas que revelan a Fichas de personaje para mantener ese comportamiento.', ], colV1: 'Comando versión 1', colV2: 'Comando versión 2', @@ -8963,10 +8980,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solución de problemas', points: [ - 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'No pasa nada cuando una ficha se mueve: compruebe que la ficha está en la capa de fichas y coincide con Fichas que revelan, y que la página tiene hexágonos (!hexploration status).', 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', - 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', - 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Los hexágonos dejaron de revelarse tras copiar una página o un juego: ejecute Volver a escanear en la página.', + 'Rellenar dice que el área no tiene centros de hexágono: la forma debe contener el centro de al menos un hexágono.', 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', ], }, @@ -8974,7 +8991,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', colLanguage: 'Idioma', - colNative: 'nombre nativo', + colNative: 'Nombre original', colCode: 'Código', }, credits: { @@ -8991,37 +9008,37 @@ const HexplorationMod = (() => { const TRANSLATION$2 = { titles: { ready: 'Hexploration är redo.', - settings: 'Heexploration Inställningar', + settings: 'Hexploration-inställningar', languages: 'Välj ett språk', pageSettings: 'Sidinställningar: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandon', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandon', confirm: 'Vänligen bekräfta', }, discovery: { title: 'Plats upptäckt', }, menu: { - draw: 'Dra', - reveal: 'Avslöja och göm', + draw: 'Rita', + reveal: 'Avslöja och dölj', locations: 'Platser', tools: 'Verktyg', - layerInUse: 'Nya sexkanter ritas på {layer}.', + layerInUse: 'Nya hexar ritas på {layer}.', pageSettingsHelp: 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', }, buttons: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - undo: 'Ångra Fyll', + undo: 'Ångra fyllning', reveal: 'Avslöja', - conceal: 'Dölja', + conceal: 'Dölj', explore: 'Utforska', - revealPage: 'Avslöja sidan', + revealPage: 'Avslöja sida', resetPage: 'Återställ sida', mark: 'Markera plats', unmark: 'Avmarkera', - name: 'Namn Hex', + name: 'Namnge hex', settings: 'Inställningar', pageSettings: 'Sidinställningar', status: 'Status', @@ -9043,12 +9060,12 @@ const HexplorationMod = (() => { none: 'Ingen', hexLayer: { auto: 'Auto (förgrund om tillgängligt)', - foreground: 'förgrundsskikt', - objects: 'symbollager', + foreground: 'förgrundslagret', + objects: 'tokenlagret', }, revealBy: { - players: 'Spelarpoletter', - characters: 'Karaktärspoletter', + players: 'Spelartokens', + characters: 'Rollpersonstokens', all: 'Alla tokens', }, revealMode: { @@ -9065,9 +9082,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - conceal: 'Dölja', + conceal: 'Dölj', }, }, settings: { @@ -9076,12 +9093,12 @@ const HexplorationMod = (() => { desc: 'Språk för menyer, meddelanden och åhörarkopior.', }, hexLayer: { - label: 'Hexlager', + label: 'Lager för hexar', desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', - desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + desc: 'Färg på nya hexar. Använd rgba() för genomskinliga hexar, till exempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfärg', @@ -9092,15 +9109,15 @@ const HexplorationMod = (() => { desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', }, glimpseColor: { - label: 'Glimt färg', - desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + label: 'Glimtfärg', + desc: 'Färgen som hexar byter till när de skymtas (avslöjandeläget Glimt). Använd en genomskinlig rgba()-färg.', }, strokeWidth: { label: 'Kantbredd', desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', }, maxDistance: { - label: 'Hexavslöjande avstånd', + label: 'Avslöjandeavstånd för hexar', desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', }, revealDistance: { @@ -9108,7 +9125,7 @@ const HexplorationMod = (() => { desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', }, lineOfSight: { - label: 'Synlinje', + label: 'Siktlinje', desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', }, revealPath: { @@ -9120,33 +9137,33 @@ const HexplorationMod = (() => { desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', }, revealMode: { - label: 'Avslöjande läge', - desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + label: 'Avslöjandeläge', + desc: 'Rensa tar bort hexar inom synhåll. Glimt gör dem i stället genomskinliga; de tas bort när en token går in i dem.', }, announce: { label: 'Tillkännage upptäckter', desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', }, pingDiscoveries: { - label: 'Ping upptäckter', + label: 'Pinga upptäckter', desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', }, hideCoveredTokens: { - label: 'Dölj täckta polletter', + label: 'Dölj täckta tokens', desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', }, }, status: { engine: 'Spelmotor', grid: 'Rutnät', - layer: 'Hexskikt', - hexes: 'Hex', + layer: 'Hexlager', + hexes: 'Hexar', named: 'Namngivna hexar', - icons: 'Platsskyltar', - glimpsed: 'Glimmade hexar', + icons: 'Platstokens', + glimpsed: 'Genomskinliga hexar', pending: 'Platser som väntar på fyllning', calibrated: 'Kalibrerad', - overrides: 'Sida åsidosätter', + overrides: 'Sidåsidosättningar', undo: 'Ångra tillgängligt', }, messages: { @@ -9157,11 +9174,11 @@ const HexplorationMod = (() => { 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', resetPage: 'Hexen har tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', named: 'Hex med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: - 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: @@ -9172,11 +9189,11 @@ const HexplorationMod = (() => { 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: - 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', pruned: - 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + 'Sparade hexar som inte längre finns och har glömts bort: {dropped}. Om det här spelet eller sidan kopierades kör du Skanna igen på sidan för att hitta dess hexar igen.', readyHint: - 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + 'Skriv !hexploration för menyn, eller öppna handouten "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -9215,7 +9232,7 @@ const HexplorationMod = (() => { calibrateNeedsTokens: 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', calibrateFailed: - 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + 'Två tokens måste ligga i samma rad (Hex V) eller samma kolumn (Hex H), minst en hex från varandra.', unexpected: 'Detaljer finns i API-konsolloggen.', }, help: { @@ -9239,16 +9256,15 @@ const HexplorationMod = (() => { calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', - journal: 'Bygg om hjälp- och kommandodäcken.', + journal: 'Bygg om handouterna Help och Command Deck.', help: 'Visa den här listan.', handout: 'Fullständiga instruktioner finns i "{name}" handout.', }, deck: { - subtitle: 'Kommandodäck', drawDesc: - 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + 'Rita former runt ett område, markera dem och fyll sedan. Ångra fyllning tar bort den senaste fyllningen.', revealDesc: - 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', toolsDesc: @@ -9269,9 +9285,9 @@ const HexplorationMod = (() => { steps: [ 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', - 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', - 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, commands: { @@ -9284,13 +9300,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Hur avslöjande fungerar', points: [ - 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', - 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', - 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', - 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', - 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar. Med Siktlinje på avslöjas en hex bara om ingen täckt hex ligger emellan.', + 'Avslöjandeavstånd för hexar lagras på hexarna när de ritas. Dessa hexar avslöjas bara inom så många hexars avstånd, hur långt en token än kan se. Använd det för berg eller skogar som döljer vad som finns bakom dem.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem.', + 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', + 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', ], }, locations: { @@ -9299,14 +9315,14 @@ const HexplorationMod = (() => { 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', - 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', - 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], }, settings: { heading: 'Inställningar', intro: - 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', colName: 'Miljö', colDesc: 'Beskrivning', @@ -9316,18 +9332,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate och Legacy', points: [ 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', - 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', - 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', - 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + 'När Lager för hexar är inställt på Auto ritas hexar på förgrundslagret, ovanför tokens, så att spelarna inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret i stället.', + 'Jumpgate ritar matematiskt regelbundna hexar, som har en något annan form än Legacy-hexar. Om hexarna inte stämmer med en sidas rutnät, fäst en token i mitten av en hex, markera den och klicka på Kalibrera. Markera två tokens i angränsande hexar i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID:n. Kör Skanna igen på sidan för att hitta dem igen, tillsammans med deras namnetiketter och platstokens.', ], }, upgrading: { heading: 'Uppgraderar från version 1', points: [ 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', - 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Befintliga hexkartor, namn, platstokens och inställningar uppgraderas automatiskt vid första starten.', 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', - 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + 'I version 1 kunde varje token som representerade en rollperson avslöja hexar. Ställ in Tokens som avslöjar på Rollpersonstokens för att behålla det beteendet.', ], colV1: 'Kommandot version 1', colV2: 'Kommandot version 2', @@ -9335,10 +9351,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Felsökning', points: [ - 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', - 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', - 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', + 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', ], }, @@ -9346,7 +9362,7 @@ const HexplorationMod = (() => { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', colLanguage: 'Språk', - colNative: 'Inhemskt namn', + colNative: 'Eget namn', colCode: 'Koda', }, credits: { @@ -9362,46 +9378,46 @@ const HexplorationMod = (() => { const TRANSLATION$1 = { titles: { - ready: 'Keşif hazır.', - settings: 'Keşif Ayarları', + ready: 'Hexploration hazır.', + settings: 'Hexploration Ayarları', languages: 'Bir Dil Seçin', pageSettings: 'Sayfa Ayarları: {page}', - status: 'Keşif Durumu: {page}', - help: 'Keşif Komutları', + status: 'Hexploration Durumu: {page}', + help: 'Hexploration Komutları', confirm: 'Lütfen Onaylayın', }, discovery: { title: 'Konum Keşfedildi', }, menu: { - draw: 'Çizmek', - reveal: 'Göster ve Gizle', + draw: 'Çizim', + reveal: 'Açığa Çıkarma ve Gizleme', locations: 'Konumlar', - tools: 'Aletler', - layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + tools: 'Araçlar', + layerInUse: 'Yeni altıgenler şu katmana çiziliyor: {layer}.', pageSettingsHelp: 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', }, buttons: { - fill: 'Doldurmak', - fillInverse: 'Ters Doldurma', + fill: 'Doldur', + fillInverse: 'Ters Doldur', undo: 'Doldurmayı Geri Al', - reveal: 'Ortaya çıkarmak', + reveal: 'Açığa Çıkar', conceal: 'Gizle', - explore: 'Keşfetmek', - revealPage: 'Sayfayı Göster', + explore: 'Keşfet', + revealPage: 'Sayfayı Açığa Çıkar', resetPage: 'Sayfayı Sıfırla', mark: 'Konumu İşaretle', - unmark: 'İşareti kaldır', - name: 'Ad Hex', + unmark: 'İşareti Kaldır', + name: 'Altıgeni Adlandır', settings: 'Ayarlar', pageSettings: 'Sayfa Ayarları', status: 'Durum', - rescan: 'Yeniden tara', - calibrate: 'Kalibre et', + rescan: 'Yeniden Tara', + calibrate: 'Kalibre Et', calibrateReset: 'Kalibrasyonu Sıfırla', help: 'Yardım', - change: 'Değiştirmek', + change: 'Değiştir', menu: 'Menü', clearOverrides: 'Geçersiz Kılmaları Temizle', confirmReset: 'Evet, Tüm Altıgenleri Kaldır', @@ -9414,18 +9430,18 @@ const HexplorationMod = (() => { off: 'Kapalı', none: 'Hiçbiri', hexLayer: { - auto: 'Otomatik (varsa ön planda)', + auto: 'Otomatik (varsa ön plan)', foreground: 'ön plan katmanı', - objects: 'belirteç katmanı', + objects: 'jeton katmanı', }, revealBy: { players: 'Oyuncu jetonları', - characters: 'Karakter belirteçleri', + characters: 'Karakter jetonları', all: 'Tüm jetonlar', }, revealMode: { - clear: 'Temizlemek', - glimpse: 'Kısa bakış', + clear: 'Temizleme', + glimpse: 'Bakış', }, announce: { all: 'Herkes', @@ -9433,23 +9449,23 @@ const HexplorationMod = (() => { off: 'Kapalı', }, orientation: { - vertical: 'Altıgen (V)', - horizontal: 'Altıgen (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Doldurmak', + fill: 'Doldurma', fillInverse: 'Ters Doldurma', - conceal: 'Gizle', + conceal: 'Gizleme', }, }, settings: { language: { label: 'Dil', - desc: 'Menüler, mesajlar ve bildiriler için dil.', + desc: 'Menüler, mesajlar ve broşürler için dil.', }, hexLayer: { - label: 'Altıgen Katman', - desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + label: 'Altıgen Katmanı', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (jetonların üstünde) dener; oyun bunu desteklemiyorsa jeton katmanına geri döner.', }, fillColor: { label: 'Dolgu Rengi', @@ -9465,14 +9481,14 @@ const HexplorationMod = (() => { }, glimpseColor: { label: 'Bakış Rengi', - desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + desc: 'Altıgenlerin Bakış modunda aldığı renk. Yarı saydam bir rgba() rengi kullanın.', }, strokeWidth: { - label: 'Kenar Genişliği', + label: 'Kenarlık Kalınlığı', desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', }, maxDistance: { - label: 'Hex Ortaya Çıkma Mesafesi', + label: 'Altıgen Açığa Çıkarma Mesafesi', desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', }, revealDistance: { @@ -9484,42 +9500,42 @@ const HexplorationMod = (() => { desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', }, revealPath: { - label: 'Yol Boyunca Ortaya Çıkar', + label: 'Yol Boyunca Açığa Çıkar', desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', }, revealBy: { - label: 'Ortaya Çıkan Tokenlar', + label: 'Açığa Çıkaran Jetonlar', desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', }, revealMode: { - label: 'Ortaya Çıkarma Modu', - desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + label: 'Açığa Çıkarma Modu', + desc: 'Temizleme, görüş alanındaki altıgenleri kaldırır. Bakış ise onları yarı saydam yapar; içlerine bir jeton girdiğinde kaldırılırlar.', }, announce: { - label: 'Keşifleri Duyurun', + label: 'Keşifleri Duyur', desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', }, pingDiscoveries: { - label: 'Ping Keşifleri', + label: 'Keşifleri Pingle', desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', }, hideCoveredTokens: { - label: 'Kapalı Jetonları Gizle', + label: 'Örtülü Jetonları Gizle', desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', }, }, status: { engine: 'Oyun motoru', grid: 'Izgara', - layer: 'Altıgen katman', + layer: 'Altıgen katmanı', hexes: 'Altıgenler', named: 'Adlandırılmış altıgenler', - icons: 'Konum belirteçleri', - glimpsed: 'Kısa bir bakış altıgenler', - pending: 'Doldurulmayı bekleyen yerler', + icons: 'Konum jetonları', + glimpsed: 'Bakış altındaki altıgenler', + pending: 'Doldurma bekleyen konumlar', calibrated: 'Kalibre edildi', overrides: 'Sayfa geçersiz kılmaları', - undo: 'Geri alma seçeneği mevcut', + undo: 'Geri alma mevcut', }, messages: { filled: @@ -9528,7 +9544,7 @@ const HexplorationMod = (() => { revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', - resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', named: '"{name}" adlı altıgenler: {count}.', @@ -9543,12 +9559,12 @@ const HexplorationMod = (() => { 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', calibrationReset: 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', - journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + journalRebuilt: '"{help}" ve "{deck}" broşürleri yeniden oluşturuldu.', migrated: - 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + "Hexploration 1.x altıgen haritalarınız yükseltildi. Bu oyun bir Legacy oyunundan kopyalandıysa, her altıgen harita sayfasında Yeniden Tara'yı çalıştırın.", pruned: - "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", - readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + "Artık var olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenlerini yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + readyHint: 'Menü için !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', }, warnings: { foregroundUnavailable: @@ -9587,9 +9603,9 @@ const HexplorationMod = (() => { unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: - 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgene tutturulmuş ikinci bir jeton seçin.', calibrateFailed: - 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir altıgen aralıkla olması gerekir.', unexpected: 'Ayrıntılar API konsolu günlüğündedir.', }, help: { @@ -9610,21 +9626,20 @@ const HexplorationMod = (() => { pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: - 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', calibrate: 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', - status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", - journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + status: "Hexploration'ın geçerli sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Command Deck broşürlerini yeniden oluşturun.', help: 'Bu listeyi göster.', handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', }, deck: { - subtitle: 'Komut Güvertesi', drawDesc: - 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + "Bir alanın çevresine şekiller çizin, onları seçin ve Doldur'a tıklayın. Doldurmayı Geri Al, son doldurmayı geri alır.", revealDesc: - 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', toolsDesc: @@ -9637,7 +9652,7 @@ const HexplorationMod = (() => { footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', - body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + body: 'Hexploration, bir altıgen haritayı opak altıgenlerle kaplar. Grup ilerledikçe içinden geçtiği altıgenler (ve isterseniz çevresindeki altıgenler) kaldırılır; böylece harita altıgen altıgen ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduklarında duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', demo: "Kısa bir demo izleyin (versiyon 1'den)", }, quickStart: { @@ -9645,7 +9660,7 @@ const HexplorationMod = (() => { steps: [ 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', - "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "Şekilleri seçin ve Command Deck'te Doldur'a tıklayın (veya !hexploration fill yazın). Şekiller altıgenlerle değiştirilir.", "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', ], @@ -9660,13 +9675,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Açığa Çıkarma Nasıl Çalışır?', points: [ - 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', - 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', - 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', - 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', - 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', + 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri açığa çıkarır. Görüş Hattı açıkken bir altıgen yalnızca arada örtülü bir altıgen yoksa açığa çıkar.', + 'Altıgen Açığa Çıkarma Mesafesi, altıgenler çizilirken onlara kaydedilir. Bu altıgenler, bir jeton ne kadar uzağı görürse görsün, yalnızca o kadar altıgen mesafeden açığa çıkar. Arkasındakini gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır.', + 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', + "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", ], }, locations: { @@ -9675,14 +9690,14 @@ const HexplorationMod = (() => { 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', - "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", - "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], }, settings: { heading: 'Ayarlar', intro: - '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + "Ayarları !hexploration set ile (veya Ayarlar düğmesiyle) değiştirin. Altıgen Katmanı, Açığa Çıkaran Jetonlar ve Dil, Mod'un ayarlar sayfasından da ayarlanabilir.", colKey: 'Anahtar', colName: 'Ayar', colDesc: 'Tanım', @@ -9691,10 +9706,10 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate ve Eski', points: [ - 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', - 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', - "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", - "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', + 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', + "Jumpgate matematiksel olarak düzgün altıgenler çizer; bunların şekli Legacy altıgenlerinden biraz farklıdır. Altıgenler sayfanın ızgarasıyla hizalı değilse bir altıgenin merkezine bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerde iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Onları ad etiketleri ve konum jetonlarıyla birlikte yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", ], }, upgrading: { @@ -9702,8 +9717,8 @@ const HexplorationMod = (() => { points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', - 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', - 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', + "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], colV1: 'Sürüm 1 komutu', colV2: 'Sürüm 2 komutu', @@ -9711,23 +9726,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Sorun giderme', points: [ - 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', - "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", - "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", - 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu ve Açığa Çıkaran Jetonlar ayarına uyduğunu, sayfada da altıgenler bulunduğunu (!hexploration status) kontrol edin.', + "Altıgenler ızgaradan kaymış: Kalibre Et'i kullanın, ardından haritanın farklı yerlerindeki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra altıgenler açığa çıkmıyor: sayfada Yeniden Tara'yı çalıştırın.", + 'Doldur, alanda altıgen merkezi olmadığını söylüyor: şeklin en az bir altıgenin merkezini içermesi gerekir.', 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', ], }, languages: { heading: 'Diller', - body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + body: '!hexploration set language ile bir dil seçin. Mevcut diller:', colLanguage: 'Dil', colNative: 'Yerel ad', colCode: 'Kod', }, credits: { heading: 'Kredi', - original: 'Orijinal mod', + original: 'Orijinal modun yapımcısı', maintainer: 'Versiyon 2 tarafından sürdürülen', marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: @@ -9741,20 +9756,20 @@ const HexplorationMod = (() => { ready: 'Hexploration готовий.', settings: 'Налаштування Hexploration', languages: 'Виберіть мову', - pageSettings: 'Параметри сторінки: {page}', - status: 'Статус дослідження: {page}', + pageSettings: 'Налаштування сторінки: {page}', + status: 'Статус Hexploration: {page}', help: 'Команди Hexploration', confirm: 'Будь ласка, підтвердьте', }, discovery: { - title: 'Розташування виявлено', + title: 'Локацію виявлено', }, menu: { - draw: 'малювати', - reveal: 'Відкрити і приховати', - locations: 'Розташування', + draw: 'Малювання', + reveal: 'Розкриття і приховування', + locations: 'Локації', tools: 'Інструменти', - layerInUse: 'Нові гекси малюються на {layer}.', + layerInUse: 'Нові гекси малюються на цьому шарі: {layer}.', pageSettingsHelp: 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', }, @@ -9764,22 +9779,22 @@ const HexplorationMod = (() => { undo: 'Скасувати заповнення', reveal: 'Розкрити', conceal: 'Приховати', - explore: 'Досліджуйте', - revealPage: 'Відкрити сторінку', + explore: 'Дослідити', + revealPage: 'Розкрити сторінку', resetPage: 'Скинути сторінку', - mark: 'Позначте розташування', + mark: 'Позначити локацію', unmark: 'Зняти позначку', - name: "Ім'я Hex", + name: 'Назвати гекс', settings: 'Налаштування', - pageSettings: 'Параметри сторінки', + pageSettings: 'Налаштування сторінки', status: 'Статус', - rescan: 'Повторне сканування', + rescan: 'Пересканувати', calibrate: 'Відкалібрувати', calibrateReset: 'Скинути калібрування', help: 'Довідка', - change: 'Зміна', + change: 'Змінити', menu: 'Меню', - clearOverrides: 'Очистити перевизначення', + clearOverrides: 'Скинути перевизначення', confirmReset: 'Так, видалити всі гекси', }, prompts: { @@ -9788,24 +9803,24 @@ const HexplorationMod = (() => { values: { on: 'Увімкнено', off: 'Вимкнено', - none: 'Жодного', + none: 'Немає', hexLayer: { - auto: 'Автоматично (на передньому плані, якщо доступно)', + auto: 'Авто (передній план, якщо доступний)', foreground: 'шар переднього плану', - objects: 'маркерний шар', + objects: 'шар маркерів', }, revealBy: { - players: 'Жетони гравців', - characters: 'Символьні маркери', - all: 'Усі жетони', + players: 'Маркери гравців', + characters: 'Маркери персонажів', + all: 'Усі маркери', }, revealMode: { - clear: 'ясно', - glimpse: 'Поблиск', + clear: 'Очищення', + glimpse: 'Проблиск', }, announce: { all: 'Всі', - gm: 'Тільки GM', + gm: 'Лише GM', off: 'Вимкнено', }, orientation: { @@ -9813,9 +9828,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Заповнити', + fill: 'Заповнення', fillInverse: 'Зворотне заповнення', - conceal: 'Приховати', + conceal: 'Приховування', }, }, settings: { @@ -9824,77 +9839,77 @@ const HexplorationMod = (() => { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шістнадцятковий шар', - desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + label: 'Шар шестикутників', + desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Колір рамки', + label: 'Колір контуру', desc: 'Колір контуру нових гексів.', }, labelColor: { - label: 'Колір етикетки', + label: 'Колір міток', desc: 'Колір написів імен лише для GM на іменованих гексах.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + label: 'Колір проблиску', + desc: 'Колір, якого набувають гекси в режимі «Проблиск». Використовуйте напівпрозорий колір rgba().', }, strokeWidth: { - label: 'Ширина кордону', + label: 'Товщина контуру', desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Шестигранна відстань розкриття', + label: 'Відстань розкриття шестикутників', desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { - label: 'Дистанція огляду', + label: 'Дальність огляду', desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', }, lineOfSight: { - label: 'Пряма видимість', + label: 'Лінія видимості', desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', }, revealPath: { - label: 'Показати уздовж шляху', + label: 'Розкривати вздовж шляху', desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', }, revealBy: { - label: 'Жетони, які розкривають', + label: 'Маркери, що розкривають', desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', }, revealMode: { - label: 'Режим виявлення', - desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + label: 'Режим розкриття', + desc: '«Очищення» видаляє гекси в межах видимості. «Проблиск» натомість робить їх напівпрозорими; вони видаляються, коли на них заходить маркер.', }, announce: { - label: 'Оголосити відкриття', + label: 'Оголошувати відкриття', desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', }, pingDiscoveries: { - label: 'Ping відкриття', + label: 'Пінгувати знахідки', desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', }, hideCoveredTokens: { - label: 'Приховати закриті токени', + label: 'Ховати маркери під гексами', desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', }, }, status: { - engine: 'Ігровий двигун', + engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шестигранний шар', + layer: 'Шар шестикутників', hexes: 'Гекси', named: 'Іменовані гекси', - icons: 'Жетони розташування', - glimpsed: 'Помітені прокляття', - pending: 'Локації очікують на заповнення', - calibrated: 'Відкалібрований', - overrides: 'Перевизначення сторінок', + icons: 'Маркери локацій', + glimpsed: 'Гекси в проблиску', + pending: 'Локації, що чекають на заповнення', + calibrated: 'Відкалібровано', + overrides: 'Перевизначення сторінки', undo: 'Доступне скасування', }, messages: { @@ -9903,7 +9918,7 @@ const HexplorationMod = (() => { revealed: 'Розкрито гекси: {count}.', revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: - 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', resetPage: 'Зі сторінки видалено шестигранники: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', @@ -9921,11 +9936,11 @@ const HexplorationMod = (() => { 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: - 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', pruned: - 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + 'Забуто збережені гекси, яких більше не існує: {dropped}. Якщо цю гру чи сторінку було скопійовано, виконайте «Пересканувати» на сторінці, щоб знову знайти її гекси.', readyHint: - 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + 'Введіть !hexploration, щоб відкрити меню, або відкрийте роздатковий матеріал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -9935,7 +9950,7 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Не вдалося знайти сторінку для роботи.', - notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', emptyArea: 'Вибрана область не містить шестигранних центрів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', @@ -9954,8 +9969,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', - notHex: - 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + notHex: 'Установіть для сітки сторінки Hex (V) або Hex (H) у налаштуваннях сторінки.', noPolygons: 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', @@ -9986,22 +10000,20 @@ const HexplorationMod = (() => { set: 'Змінити налаштування або показати всі налаштування.', pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', - rescan: - 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: - 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + 'Вирівняйте гексову сітку за одним або двома вибраними маркерами, прив’язаними до центрів гексів.', calibrateReset: 'Видалити калібрування поточної сторінки.', status: 'Покажіть, що Hexploration знає про поточну сторінку.', - journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + journal: 'Перебудуйте роздаткові матеріали «Довідка» та «Command Deck».', help: 'Покажіть цей список.', handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', }, deck: { - subtitle: 'Командна колода', drawDesc: - 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + 'Обведіть область фігурами, виділіть їх і натисніть «Заповнити». «Скасувати заповнення» скасовує останнє заповнення.', revealDesc: - 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + 'Виділіть гекси, фігури або маркери, щоб розкрити їх або знову приховати. «Дослідити» розкриває гекси навколо вибраних маркерів, ніби вони туди перемістилися.', locationsDesc: 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', toolsDesc: @@ -10010,7 +10022,7 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Версія', - subtitle: 'Шістнадцяткове дослідження для Roll20', + subtitle: 'Дослідження гекс за гексом для Roll20', footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', @@ -10022,9 +10034,9 @@ const HexplorationMod = (() => { steps: [ 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', - 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', - 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', - 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + 'Виберіть фігури та натисніть «Заповнити» в Command Deck (або введіть !hexploration fill). Фігури буде замінено гексами.', + 'Додатково: перед заповненням виділіть маркери важливих місць і натисніть «Позначити локацію». Вони сховаються під гексами, а коли їх виявлять, про це буде оголошено.', + 'Перемістіть маркер гравця. Кожен гекс, через який він проходить, і гекси в межах його «Дальності огляду» розкриваються.', ], }, commands: { @@ -10037,29 +10049,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Як працює розкриття', points: [ - 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', - 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', - 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', - 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', - 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', + 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів. З увімкненою «Лінією видимості» гекс розкривається, лише якщо між ним і маркером немає закритого гекса.', + '«Відстань розкриття шестикутників» зберігається в гексах під час їх малювання. Такі гекси розкриваються лише з відстані, не більшої за цю кількість гексів, хоч би як далеко бачив маркер. Використовуйте її для гір або лісів, що приховують те, що за ними.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер.', + "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", + 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', ], }, locations: { heading: 'Іменовані гекси та локації', points: [ - 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', - 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', colKey: 'ключ', colName: 'Налаштування', colDesc: 'опис', @@ -10069,18 +10081,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate і Legacy', points: [ 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', - 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', - 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', + 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], }, upgrading: { heading: 'Оновлення з версії 1', points: [ 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', - 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Наявні гексові карти, назви, маркери локацій і налаштування оновлюються автоматично під час першого запуску.', 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', - 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + 'У версії 1 гекси міг розкривати будь-який маркер, що представляв персонажа. Щоб зберегти таку поведінку, встановіть для «Маркери, що розкривають» значення «Маркери персонажів».', ], colV1: 'Команда версії 1', colV2: 'Команда версії 2', @@ -10088,18 +10100,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Усунення несправностей', points: [ - 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', - 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', - 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', - 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Коли маркер рухається, нічого не відбувається: перевірте, чи маркер на шарі маркерів і відповідає параметру «Маркери, що розкривають», а на сторінці є гекси (!hexploration status).', + 'Гекси зміщені відносно сітки: натисніть «Відкалібрувати», а потім перевірте маркером кілька гексів у різних частинах карти.', + 'Гекси перестали розкриватися після копіювання сторінки або гри: виконайте «Пересканувати» на сторінці.', + '«Заповнити» повідомляє, що в області немає центрів гексів: фігура має містити центр принаймні одного гекса.', 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', ], }, languages: { heading: 'Мови', - body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + body: 'Виберіть мову командою !hexploration set language. Доступні мови:', colLanguage: 'Мова', - colNative: 'Рідна назва', + colNative: 'Самоназва', colCode: 'Код', }, credits: { @@ -12648,10 +12660,10 @@ const HexplorationMod = (() => { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ - escapeHtml(flag ? `${flag} ${name}` : name), - escapeHtml(nativeName || name), - code(localeCode), + const locales = LOCALE_DEFINITIONS.map((locale) => [ + escapeHtml(locale.name), + escapeHtml(locale.nativeName || locale.name), + `${buildLocaleFlag(locale)}${code(locale.code)}`, ]); const { original, maintainer } = AUTHOR_LINKS; @@ -12697,7 +12709,7 @@ const HexplorationMod = (() => { return `

    ⬢ ${SCRIPT_NAME} ⬢

    -

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +

    ${DECK_TITLE} • v${SCRIPT_VERSION}

    ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} @@ -13681,7 +13693,11 @@ const HexplorationMod = (() => { const config = getConfig(); const rows = SETTING_ROWS.map((row) => { const value = config[row.key]; - const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const flag = + row.key === 'language' + ? buildLocaleFlag(LOCALE_DEFINITIONS.find(({ code }) => code === value)) + : ''; + const shown = row.color ? buildSwatch(value) : flag + escapeHtml(formatValue(row.key, value)); const button = buildSecondaryButton( tr('buttons.change'), `${COMMAND} set ${row.key} ${settingQuery(row, value)}` @@ -13703,8 +13719,12 @@ const HexplorationMod = (() => { * @returns {void} */ function showLanguages(playerId) { - const buttons = SUPPORTED_LOCALES.map((code) => - buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + const buttons = LOCALE_DEFINITIONS.map((locale) => + buildSecondaryButton( + LOCALE_LABELS[locale.code], + `${COMMAND} set language ${locale.code}`, + buildLocaleFlag(locale) + ) ); whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); } diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index d8d4f47859..062b681f65 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T14:33:58.218Z + * Built: 2026-10-29T15:52:46.956Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T14:33:58.218Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T15:52:46.956Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -34,7 +34,9 @@ const HexplorationMod = (() => { const LEGACY_ARG_SEPARATOR = '&&'; const HANDOUT_HELP_NAME = 'Hexploration - Help'; - const HANDOUT_DECK_NAME = 'Hexploration - Command Deck'; + // The deck's name is not translated, so it always matches the handout's name. + const DECK_TITLE = 'Command Deck'; + const HANDOUT_DECK_NAME = `Hexploration - ${DECK_TITLE}`; const AUTHOR_LINKS = { original: { @@ -529,10 +531,42 @@ const HexplorationMod = (() => { * * @param {string} label Button label. * @param {string} command Chat command the button runs. + * @param {string} [prefixHtml=''] Trusted HTML shown before the label, such as a flag. * @returns {string} HTML anchor. */ - function buildSecondaryButton(label, command) { - return `${escapeHtml(label)}`; + function buildSecondaryButton(label, command, prefixHtml = '') { + return `${prefixHtml}${escapeHtml(label)}`; + } + + /** + * Builds a Twemoji asset URL for a locale flag. + * + * @param {string} flag Unicode regional-indicator flag. + * @returns {string} SVG asset URL or an empty string. + */ + function flagAssetUrl(flag) { + const codepoints = Array.from(String(flag || '').trim()) + .map((character) => character.codePointAt(0).toString(16)) + .join('-'); + return codepoints + ? `https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/${codepoints}.svg` + : ''; + } + + /** + * Builds a locale's flag as a Twemoji image. Roll20 on Windows shows emoji + * flags as letter pairs, so the flag is drawn from an SVG instead. + * + * @param {object} locale Locale metadata. + * @returns {string} Trusted flag HTML, or an empty string when there is no flag. + */ + function buildLocaleFlag(locale) { + const label = escapeHtml(locale?.flagLabel || locale?.name || ''); + const url = flagAssetUrl(locale?.flag); + if (!url) { + return ''; + } + return `${label}`; } /** @@ -1104,12 +1138,12 @@ const HexplorationMod = (() => { const TRANSLATION$m = { titles: { - ready: 'Heeksplorasie is gereed.', - settings: 'Heksplorasie-instellings', + ready: 'Hexploration is gereed.', + settings: 'Hexploration-instellings', languages: "Kies 'n taal", pageSettings: 'Bladsyinstellings: {page}', - status: 'Heksplorasiestatus: {page}', - help: 'Heksplorasie-opdragte', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdragte', confirm: 'Bevestig asseblief', }, discovery: { @@ -1120,14 +1154,14 @@ const HexplorationMod = (() => { reveal: 'Openbaar en versteek', locations: 'Liggings', tools: 'Gereedskap', - layerInUse: 'Nuwe hekse word op die {layer} geteken.', + layerInUse: 'Nuwe seshoeke word op die {layer} geteken.', pageSettingsHelp: - 'Hierdie instellings is slegs van toepassing op hierdie bladsy. Instellings gemerk ★ ignoreer die globale instellings.', + 'Hierdie instellings geld slegs vir hierdie bladsy. Instellings gemerk met ★ oorskryf die globale instellings.', }, buttons: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', - undo: 'Ontdoen vul', + fillInverse: 'Omgekeerde vulling', + undo: 'Ontdoen vulling', reveal: 'Onthul', conceal: 'Versteek', explore: 'Verken', @@ -1135,18 +1169,18 @@ const HexplorationMod = (() => { resetPage: 'Stel bladsy terug', mark: 'Merk ligging', unmark: 'Ontmerk', - name: 'Noem Hex', + name: 'Benoem seshoek', settings: 'Instellings', pageSettings: 'Bladsy-instellings', status: 'Status', rescan: 'Skandeer weer', calibrate: 'Kalibreer', - calibrateReset: 'Stel Kalibrasie terug', - help: 'Help', + calibrateReset: 'Stel kalibrasie terug', + help: 'Hulp', change: 'Verander', - menu: 'Spyskaart', + menu: 'Kieslys', clearOverrides: 'Vee oorskrywings uit', - confirmReset: 'Ja, verwyder alle hekse', + confirmReset: 'Ja, verwyder alle seshoeke', }, prompts: { name: 'Liggingnaam (laat leeg om skoon te maak)', @@ -1157,17 +1191,17 @@ const HexplorationMod = (() => { none: 'Geen', hexLayer: { auto: 'Outo (voorgrond indien beskikbaar)', - foreground: 'voorgrond laag', - objects: 'tekenlaag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Speler tokens', - characters: 'Karaktertekens', - all: 'Alle tekens', + players: 'Speler-tokens', + characters: 'Karaktertokens', + all: 'Alle tokens', }, revealMode: { - clear: 'Duidelik', - glimpse: 'Glimpie', + clear: 'Verwyder', + glimpse: 'Glimp', }, announce: { all: 'Almal', @@ -1175,109 +1209,109 @@ const HexplorationMod = (() => { off: 'Af', }, orientation: { - vertical: 'Heks (V)', - horizontal: 'Heks (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vul', - fillInverse: 'Omgekeerde vul', + fillInverse: 'Omgekeerde vulling', conceal: 'Versteek', }, }, settings: { language: { label: 'Taal', - desc: 'Taal vir spyskaarte, boodskappe en uitdeelstukke.', + desc: 'Taal vir kieslyste, boodskappe en uitdeelstukke.', }, hexLayer: { - label: 'Hex laag', - desc: 'Waar nuwe hekkies geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die token laag as die speletjie dit nie ondersteun nie.', + label: 'Seshoeklaag', + desc: 'Waar nuwe seshoeke geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die tokenlaag as die speletjie dit nie ondersteun nie.', }, fillColor: { - label: 'Vul kleur', - desc: 'Kleur van nuwe hekkies. Gebruik rgba() vir deursigtige hekse, byvoorbeeld rgba(0,0,0,0.8).', + label: 'Vulkleur', + desc: 'Kleur van nuwe seshoeke. Gebruik rgba() vir deursigtige seshoeke, byvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Rand Kleur', - desc: 'Kleur van die buitelyn van nuwe hekse.', + label: 'Randkleur', + desc: 'Kleur van die buitelyn van nuwe seshoeke.', }, labelColor: { - label: 'Etiket Kleur', - desc: 'Kleur van die GM-net naametikette op benoemde hekse.', + label: 'Etiketkleur', + desc: 'Kleur van die naametikette wat net die GM sien, op benoemde seshoeke.', }, glimpseColor: { - label: 'Glimp kleur', - desc: "Kleur hekkies verander na wanneer gekyk word (Glimpse onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + label: 'Glimpkleur', + desc: "Kleur waarna seshoeke verander wanneer hulle deurskynend word (Glimp-onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", }, strokeWidth: { - label: 'Grens breedte', - desc: 'Breedte van die buitelyn van nuwe hekse, in pixels (0 tot 20).', + label: 'Randdikte', + desc: 'Dikte van die buitelyn van nuwe seshoeke, in pieksels (0 tot 20).', }, maxDistance: { - label: 'Hex Reveal Distance', - desc: "Toegepas op hekse soos hulle geteken word: 'n teken moet binne hierdie baie hekse wees om hulle te openbaar, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + label: 'Seshoek-onthullingsafstand', + desc: "Word op seshoeke toegepas wanneer hulle geteken word: 'n token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", }, revealDistance: { label: 'Sigafstand', - desc: "Hoeveel hekkies rondom 'n bewegende teken word geopenbaar (0 tot 20). 0 openbaar slegs die hekkies waardeur die teken gaan.", + desc: "Hoeveel seshoeke rondom 'n bewegende token onthul word (0 tot 20). 0 onthul slegs die seshoeke waardeur die token beweeg.", }, lineOfSight: { label: 'Siglyn', - desc: "Wanneer dit aan is, word 'n hex slegs geopenbaar as geen bedekte hex tussen dit en die teken lê nie.", + desc: "Wanneer dit aan is, word 'n seshoek slegs onthul as geen bedekte seshoek tussen dit en die token lê nie.", }, revealPath: { - label: 'Openbaar Langs Pad', - desc: "Wanneer dit aan is, word elke heks wat 'n teken deurgaan terwyl dit gesleep word (insluitend waypoints) geopenbaar, nie net waar dit stop nie.", + label: 'Onthul langs pad', + desc: "Wanneer dit aan is, word elke seshoek waardeur 'n token beweeg terwyl dit gesleep word (insluitend tussenpunte), onthul, nie net waar dit stop nie.", }, revealBy: { - label: 'Tekens wat openbaar', - desc: "Watter tekens op die tekenlaag openbaar hekse: tekens wat deur 'n speler beheer word, tekens wat enige karakter verteenwoordig, of elke teken.", + label: 'Tokens wat onthul', + desc: "Watter tokens op die tokenlaag seshoeke onthul: tokens wat deur 'n speler beheer word, tokens wat enige karakter verteenwoordig, of elke token.", }, revealMode: { label: 'Onthullingsmodus', - desc: "Clear verwyder hekkies binne sig. Glimpse maak hulle eerder deurskynend; hulle word verwyder wanneer 'n teken hulle binnekom.", + desc: "Met Verwyder word seshoeke binne sig verwyder. Met Glimp word hulle eerder deurskynend; hulle word verwyder wanneer 'n token hulle binnegaan.", }, announce: { label: 'Kondig ontdekkings aan', desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", }, pingDiscoveries: { - label: 'Ping Ontdekkings', + label: 'Ping ontdekkings', desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", }, hideCoveredTokens: { - label: 'Versteek bedekte tekens', - desc: "Roll20 teken name, stawe en aura's bo hekkies. Wanneer dit aan is, word hul speler-sigbare naam, balke en aura's onder 'n bedekte hekshoek afgeskakel en weer aangeskakel wanneer hulle ontbloot word.", + label: 'Versteek bedekte tokens', + desc: "Roll20 teken name, balke en auras bo seshoeke. Wanneer dit aan is, word die naam, balke en auras wat spelers kan sien, afgeskakel vir tokens onder 'n bedekte seshoek, en weer aangeskakel wanneer hulle ontbloot word.", }, }, status: { - engine: 'Spel enjin', + engine: 'Spelenjin', grid: 'Rooster', - layer: 'Hex laag', - hexes: 'Hekse', - named: 'Benoemde hekse', - icons: 'Liggingtekens', - glimpsed: 'Geskimpte hekkies', - pending: "Liggings wat wag vir 'n vulling", + layer: 'Seshoeklaag', + hexes: 'Seshoeke', + named: 'Benoemde seshoeke', + icons: 'Liggingtokens', + glimpsed: 'Deurskynende seshoeke', + pending: "Liggings wat op 'n vulling wag", calibrated: 'Gekalibreer', - overrides: 'Bladsy ignoreer', + overrides: 'Bladsy-oorskrywings', undo: 'Ontdoen beskikbaar', }, messages: { filled: - 'Vul voltooi. Hekse getrek: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', - revealed: 'Hekse geopenbaar: {count}.', - revealedPage: 'Elke heksie op die bladsy is geopenbaar ({count}).', + 'Vulling voltooi. Seshoeke geteken: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Seshoeke onthul: {count}.', + revealedPage: 'Elke seshoek op die bladsy is onthul ({count}).', confirmReset: - 'Verwyder elke heks van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', - resetPage: 'Hekse verwyder van die bladsy: {count}.', + 'Verwyder elke seshoek van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Seshoeke van die bladsy verwyder: {count}.', undone: - 'Laaste vulling ontdoen. Hekse verwyder: {removed}. Herstileerde hekkies is herstel: {restored}.', - named: 'Hekse genaamd "{name}": {count}.', + 'Laaste vulling ontdoen. Seshoeke verwyder: {removed}. Herstileerde seshoeke herstel: {restored}.', + named: 'Seshoeke benoem as "{name}": {count}.', unnamed: 'Name skoongemaak: {count}.', marked: - 'Liggings versteek in bestaande hekkies: {attached}. Wag vir die volgende vul wat hulle dek: {pending}.', - unmarked: 'Tekens wat nie meer liggings is nie: {count}.', + 'Liggings versteek in bestaande seshoeke: {attached}. Wag vir die volgende vulling wat hulle bedek: {pending}.', + unmarked: 'Tokens wat nie meer liggings is nie: {count}.', settingChanged: '{setting} gestel na {value}.', rescanned: 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', @@ -1287,35 +1321,35 @@ const HexplorationMod = (() => { 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', migrated: - "Jou Hexploration 1.x-hex-kaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, voer Rescan op elke hekskaartbladsy uit.", + "Jou Hexploration 1.x-seshoekkaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, gebruik Skandeer weer op elke seshoekkaartbladsy.", pruned: - 'Gestoorde hekkies wat nie meer bestaan ​​nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, hardloop Rescan op die bladsy om sy hekkies weer op te tel.', + 'Gestoorde seshoeke wat nie meer bestaan nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, gebruik Skandeer weer op die bladsy om sy seshoeke weer op te tel.', readyHint: - 'Tik !hexploration vir die spyskaart, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + 'Tik !hexploration vir die kieslys, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', }, warnings: { foregroundUnavailable: - 'Hierdie speletjie ondersteun nie tekening op die voorgrondlaag nie, dus is hekse op die tekenlaag geteken.', + 'Hierdie speletjie ondersteun nie teken op die voorgrondlaag nie, dus is die seshoeke op die tokenlaag geteken.', someFailed: - 'Hekse wat nie geteken kon word nie: {count}. Gaan die API-konsole na vir besonderhede.', + 'Seshoeke wat nie geteken kon word nie: {count}. Kyk in die API-konsole vir besonderhede.', }, errors: { noPage: 'Kon nie die bladsy vind om aan te werk nie.', - notHex: "Hierdie bladsy gebruik nie 'n hex-rooster nie.", + notHex: "Hierdie bladsy gebruik nie 'n seshoekrooster nie.", noPolygons: 'Kies een of meer getekende vorms om te vul.', - emptyArea: 'Die geselekteerde area bevat geen heksasiemiddels nie.', - tooMany: 'Dit sal te veel hekkies in een slag skep ({count}).', - nothingToConceal: 'Kies getekende vorms of tekens om te versteek.', - nothingToReveal: 'Kies hekkies, getekende vorms of tekens om te openbaar.', - noTokens: 'Kies eers een of meer tekens.', - noHexes: 'Kies eers een of meer hekse (of tekens wat op hekse staan).', + emptyArea: 'Die geselekteerde gebied bevat geen seshoekmiddelpunte nie.', + tooMany: 'Dit sal te veel seshoeke op een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tokens om te versteek.', + nothingToReveal: 'Kies seshoeke, getekende vorms of tokens om te onthul.', + noTokens: 'Kies eers een of meer tokens.', + noHexes: 'Kies eers een of meer seshoeke (of tokens wat op seshoeke staan).', nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', unknownCommand: 'Onbekende opdrag: {command}', unknownSetting: 'Onbekende instelling: {key}', unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', - calibrateNeedsTokens: 'Kies een of twee tokens wat aan heksende middelpunte geknip is.', - calibrateFailed: 'Daardie tekens kan nie gebruik word om te kalibreer nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateFailed: 'Daardie tokens kan nie gebruik word om te kalibreer nie.', unexpected: 'Iets het verkeerd geloop: {message}', }, hints: { @@ -1324,63 +1358,62 @@ const HexplorationMod = (() => { noPolygons: "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", - tooMany: 'Vul `n kleiner area, of verdeel die area in verskeie vorms.', + tooMany: "Vul 'n kleiner gebied, of verdeel die gebied in verskeie vorms.", noHexes: - 'Hekse is op die voorgrond of tekenlaag; skakel oor na daardie laag om hulle te kies.', + 'Seshoeke is op die voorgrond- of tokenlaag; skakel oor na daardie laag om hulle te kies.', unknownCommand: 'Tik !hexploration help om die opdragte te lys.', unknownSetting: 'Tik !hexploration set om elke instelling te sien.', calibrateNeedsTokens: - "Knip 'n teken in die middel van 'n hekshoek en kies dit. Kies 'n tweede teken wat aan 'n naburige heks in dieselfde ry (Hex V) of kolom (Hex H) geknip is om ook die heksgrootte reg te stel.", + "Klik 'n token vas in die middel van 'n seshoek en kies dit. Kies 'n tweede token wat op 'n naburige seshoek in dieselfde ry (Hex V) of kolom (Hex H) vasgeklik is om ook die seshoekgrootte reg te stel.", calibrateFailed: - 'Twee tekens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, ten minste een heks van mekaar.', + 'Die twee tokens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, minstens een seshoek uitmekaar.', unexpected: 'Besonderhede is in die API-konsole-logboek.', }, help: { - menu: 'Wys die spyskaart.', - fill: 'Bedek die geselekteerde getekende vorms met hekse.', + menu: 'Wys die kieslys.', + fill: 'Bedek die geselekteerde getekende vorms met seshoeke.', fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', reveal: - 'Onthul die geselekteerde hekse, en die hekse onder die geselekteerde vorms en tekens.', - revealPage: 'Onthul elke heksie op die bladsy sonder aankondigings.', - conceal: 'Bedek die area onder die geselekteerde vorms en tekens weer met hekkies.', - explore: 'Onthul rondom die geselekteerde tekens asof hulle net daarheen verhuis het.', - resetPage: 'Verwyder elke heks op die bladsy (vra eers).', - name: 'Noem die geselekteerde hekse, of die hekse onder die geselekteerde tokens. Laat die naam leeg om dit skoon te maak.', - mark: 'Verander die geselekteerde tekens in versteekte liggings.', + 'Onthul die geselekteerde seshoeke, en die seshoeke onder die geselekteerde vorms en tokens.', + revealPage: 'Onthul elke seshoek op die bladsy sonder aankondigings.', + conceal: 'Bedek die gebied onder die geselekteerde vorms en tokens weer met seshoeke.', + explore: 'Onthul rondom die geselekteerde tokens asof hulle pas daarheen beweeg het.', + resetPage: 'Verwyder elke seshoek op die bladsy (vra eers).', + name: 'Benoem die geselekteerde seshoeke, of die seshoeke onder die geselekteerde tokens. Laat die naam leeg om dit uit te vee.', + mark: 'Verander die geselekteerde tokens in versteekte liggings.', unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', set: "Verander 'n instelling, of wys alle instellings.", - pageSet: "Ignoreer slegs 'n onthulling-instelling op die huidige bladsy.", - pageClear: 'Verwyder die huidige bladsy se ignorering.', + pageSet: "Oorskryf 'n onthullingsinstelling slegs op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se oorskrywings.', rescan: - "Herbou die bladsy se hex lys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + "Herbou die bladsy se seshoeklys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", calibrate: - 'Voer die hekselrooster uit met een of twee geselekteerde tokens wat aan heksmiddelmiddels vasgemaak is.', + 'Belyn die seshoekrooster met een of twee geselekteerde tokens wat op seshoekmiddelpunte vasgeklik is.', calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', status: 'Wys wat Hexploration van die huidige bladsy weet.', - journal: 'Herbou die hulp- en beveldek-uitdeelstukke.', + journal: 'Herbou die Help- en Command Deck-uitdeelstukke.', help: 'Wys hierdie lys.', handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', }, deck: { - subtitle: 'Beveldek', drawDesc: "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", revealDesc: - 'Kies hekkies, vorms of tekens om dit weer te openbaar of te bedek. Verken onthullings rondom geselekteerde tekens asof hulle beweeg het.', + 'Kies seshoeke, vorms of tokens om hulle te onthul of weer te bedek. Verken onthul rondom geselekteerde tokens asof hulle beweeg het.', locationsDesc: - "Kies tekens om hulle as liggings onder hekkies te versteek. Kies hekkies of tekens om 'n heks te noem.", + "Kies tokens om hulle as liggings onder seshoeke te versteek. Kies seshoeke of tokens om 'n seshoek te benoem.", toolsDesc: - 'Instellings, bladsy ignoreer, status, herskandeer van gekopieerde bladsye en kalibrering van die rooster.', + 'Instellings, bladsy-oorskrywings, status, herskandering van gekopieerde bladsye en kalibrering van die rooster.', footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', }, handout: { versionLabel: 'Weergawe', - subtitle: 'Heks-vir-heks verkenning vir Roll20', + subtitle: 'Seshoek-vir-seshoek-verkenning vir Roll20', footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', overview: { heading: 'Oorsig', - body: "Heksplorasie dek 'n hekskaart met ondeursigtige hekse. Soos die party beweeg, word die hekkies waardeur hulle gaan (en, as jy wil, die hekse rondom hulle) verwyder, sodat die kaart een hek op 'n slag ontbloot word. Versteekte liggings kan onder hekkies geplaas word en word aangekondig wanneer dit gevind word. Dit werk in Jumpgate en Legacy-speletjies, op Hex (V) en Hex (H) roosters van enige grootte.", + body: "Hexploration bedek 'n seshoekkaart met ondeursigtige seshoeke. Soos die groep beweeg, word die seshoeke waardeur hulle gaan (en, as jy wil, die seshoeke rondom hulle) verwyder, sodat die kaart een seshoek op 'n slag ontbloot word. Versteekte liggings kan onder seshoeke geplaas word en word aangekondig wanneer hulle gevind word. Dit werk in Jumpgate- en Legacy-speletjies, op Hex (V)- en Hex (H)-roosters van enige grootte.", demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", }, quickStart: { @@ -1388,9 +1421,9 @@ const HexplorationMod = (() => { steps: [ "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', - 'Kies die vorms en klik Vul die Command Deck in (of tik !hexploration fill). Die vorms word deur hekse vervang.', - 'Opsioneel: voor invul, kies tekens vir belangrike plekke en klik Merk ligging. Hulle word onder die hekse versteek en aangekondig wanneer hulle ontdek word.', - "Beweeg 'n spelertoken. Elke heks wat dit deurgaan, en die hekse binne sy sigafstand, word geopenbaar.", + 'Kies die vorms en klik op Vul in die Command Deck (of tik !hexploration fill). Die vorms word deur seshoeke vervang.', + 'Opsioneel: kies voor die vulling tokens vir belangrike plekke en klik Merk ligging. Hulle word onder die seshoeke versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n speler-token. Elke seshoek waardeur dit beweeg, en die seshoeke binne sy Sigafstand, word onthul.", ], }, commands: { @@ -1403,29 +1436,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hoe onthulling werk', points: [ - 'Slegs tekens op die tekenlaag openbaar hekse. Watter tokens telling word bepaal deur Tokens That Reveal: speler tokens by verstek, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', - "'n Teken onthul elke hek wat dit dek (groot tokens dek verskeie) en, met Reveal Along Path op, elke hek op die roete wat dit meegesleep is, insluitend waypoints.", - "Sigafstand openbaar die hekse rondom elkeen van daardie hekse. Met siglyn aan, word 'n hekshoek slegs geopenbaar as geen bedekte heks tussenin lê nie.", - "Hex Reveal Distance word op hekse gestoor soos hulle geteken word. Daardie hekse word net van binne geopenbaar soveel hekse, hoe ver 'n teken ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle is.", - "In Glimpse-modus word hekkies binne sig deurskynend in plaas daarvan om te verdwyn, en word verwyder wanneer 'n teken hulle binnekom.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke. Met Siglyn aan, word 'n seshoek slegs onthul as geen bedekte seshoek tussenin lê nie.", + "Seshoek-onthullingsafstand word op seshoeke gestoor wanneer hulle geteken word. Daardie seshoeke word slegs van binne soveel seshoeke onthul, hoe ver 'n token ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle lê.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan.", + "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], }, locations: { - heading: 'Genoemde hekse en liggings', + heading: 'Benoemde seshoeke en liggings', points: [ - "Merk ligging verander die geselekteerde tekens in versteekte liggings. 'n Teken wat reeds onder 'n heksel is, word dadelik weggesteek; anders word dit weggesteek deur die volgende vul wat dit bedek.", - 'Tekens met die wittoringstatusmerker word ook as liggings hanteer wanneer jy invul, soos in weergawe 1.', - 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul heks onthul word, keer hulle terug na die tekenlaag met hul naam gewys, en hul ontdekking word aangekondig.', - "Name Hex gee 'n hex 'n naam sonder 'n teken. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die heksel bekend gemaak word.", + "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", + 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, settings: { heading: 'Instellings', intro: - 'Verander instellings met !hexploration set (of die Instellings-knoppie). Hex Layer, Tokens That Reveal en Language kan ook op die Mod se instellingsbladsy ingestel word.', + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Seshoeklaag, Tokens wat onthul en Taal kan ook op die Mod se instellingsbladsy gestel word.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beskrywing', @@ -1434,19 +1467,19 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate en Legacy', points: [ - 'Heeksplorasie werk uit watter enjin die speletjie gebruik en teken die bypassende soort vorm. Vorms wat in enige redigeerder geteken is, kan gevul word.', - 'Met Hex Layer op Outo gestel, word hekse op die voorgrondlaag bo tekens geteken, sodat spelers nie kan sien wat onder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tekenlaag eerder gebruik.', - "Jumpgate teken wiskundig gereelde hekse, wat 'n effens ander vorm as Legacy hekse is. As die hekkies nie in lyn is met 'n bladsy se rooster nie, plak 'n teken na 'n heksasiemiddel, kies dit en klik Kalibreer. Kies twee tekens in naburige heks van dieselfde ry (Hex V) of kolom (Hex H) om die heksgrootte ook reg te stel.", - "Wanneer 'n bladsy of speletjie gekopieer word, kry sy hekkies nuwe ID's. Begin Rescan op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + 'Hexploration bepaal watter enjin die speletjie gebruik en teken die ooreenstemmende soort vorm. Vorms wat in enige van die twee redigeerders geteken is, kan gevul word.', + 'Met Seshoeklaag op Outo gestel, word seshoeke op die voorgrondlaag bo tokens geteken, sodat spelers nie kan sien wat daaronder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tokenlaag eerder gebruik.', + "Jumpgate teken wiskundig reëlmatige seshoeke, wat 'n effens ander vorm as Legacy-seshoeke het. As die seshoeke nie met 'n bladsy se rooster belyn nie, klik 'n token vas op 'n seshoekmiddelpunt, kies dit en klik Kalibreer. Kies twee tokens in naburige seshoeke van dieselfde ry (Hex V) of kolom (Hex H) om ook die seshoekgrootte reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy seshoeke nuwe ID's. Gebruik Skandeer weer op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", ], }, upgrading: { heading: 'Opgradering vanaf weergawe 1', points: [ "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", - 'Bestaande hekskaarte, name, liggingtekens en instellings word outomaties opgegradeer met die eerste aanvang.', + 'Bestaande seshoekkaarte, name, liggingtokens en instellings word met die eerste begin outomaties opgegradeer.', 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', - "Weergawe 1 laat enige teken wat 'n karakter verteenwoordig, hekse openbaar. Stel tekens wat openbaar op karaktertekens om daardie gedrag te behou.", + "Weergawe 1 het enige token wat 'n karakter verteenwoordig, seshoeke laat onthul. Stel Tokens wat onthul op Karaktertokens om daardie gedrag te behou.", ], colV1: 'Weergawe 1 opdrag', colV2: 'Weergawe 2 opdrag', @@ -1454,10 +1487,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Probleemoplossing', points: [ - "Niks gebeur wanneer 'n teken beweeg nie: maak seker dat die teken op die tekenlaag is en ooreenstem met Tokens That Reveal, en dat die bladsy hekse het (!hexploration-status).", - "Hekse is verreken van die rooster: gebruik Kalibreer, kyk dan met 'n teken op 'n paar hekse oor die kaart.", - "Hexes het opgehou om te openbaar nadat 'n bladsy of speletjie gekopieer is: hardloop Rescan op die bladsy.", - 'Fill sê die area het geen hekselmiddels nie: die vorm moet die middelpunt van ten minste een hekshoek bevat.', + "Niks gebeur wanneer 'n token beweeg nie: maak seker dat die token op die tokenlaag is en by Tokens wat onthul pas, en dat die bladsy seshoeke het (!hexploration status).", + "Seshoeke is van die rooster af verskuif: gebruik Kalibreer en kyk dan met 'n token op 'n paar seshoeke oor die kaart heen.", + "Seshoeke word nie meer onthul nadat 'n bladsy of speletjie gekopieer is nie: gebruik Skandeer weer op die bladsy.", + 'Vul sê die gebied het geen seshoekmiddelpunte nie: die vorm moet die middelpunt van ten minste een seshoek bevat.', 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', ], }, @@ -1465,7 +1498,7 @@ const HexplorationMod = (() => { heading: 'Tale', body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { @@ -1481,61 +1514,61 @@ const HexplorationMod = (() => { const TRANSLATION$l = { titles: { - ready: "L'exploració està a punt.", - settings: "Configuració d'exploració", + ready: 'Hexploration està a punt.', + settings: "Configuració d'Hexploration", languages: 'Trieu un idioma', pageSettings: 'Configuració de la pàgina: {page}', - status: "Estat de l'exploració: {page}", - help: "Comandes d'exploració", + status: "Estat d'Hexploration: {page}", + help: "Comandes d'Hexploration", confirm: 'Si us plau, confirmeu', }, discovery: { - title: 'Localització descoberta', + title: 'Ubicació descoberta', }, menu: { draw: 'Dibuixa', reveal: 'Revela i amaga', locations: 'Ubicacions', tools: 'Eines', - layerInUse: "S'estan dibuixant nous hexagones al {layer}.", + layerInUse: "S'estan dibuixant hexàgons nous a la {layer}.", pageSettingsHelp: "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", }, buttons: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - undo: 'Desfer el farciment', - reveal: 'Revelar', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + undo: "Desfés l'emplenament", + reveal: 'Revela', + conceal: 'Amaga', explore: 'Explora', revealPage: 'Revela la pàgina', resetPage: 'Restableix la pàgina', mark: 'Marca la ubicació', unmark: 'Desmarca', - name: 'Nom Hex', + name: "Anomena l'hexàgon", settings: 'Configuració', pageSettings: 'Configuració de la pàgina', status: 'Estat', rescan: 'Torna a escanejar', - calibrate: 'Calibrar', + calibrate: 'Calibra', calibrateReset: 'Restableix la calibració', help: 'Ajuda', - change: 'Canviar', + change: 'Canvia', menu: 'Menú', clearOverrides: 'Esborra les substitucions', - confirmReset: 'Sí, traieu tots els hexagones', + confirmReset: 'Sí, elimina tots els hexàgons', }, prompts: { name: 'Nom de la ubicació (deixeu en blanc per esborrar)', }, values: { - on: 'Encès', - off: 'Apagat', + on: 'Activat', + off: 'Desactivat', none: 'Cap', hexLayer: { - auto: 'Automàtic (en primer pla si està disponible)', + auto: 'Automàtic (primer pla si està disponible)', foreground: 'capa de primer pla', - objects: 'capa de testimoni', + objects: 'capa de fitxes', }, revealBy: { players: 'Fitxes de jugador', @@ -1543,22 +1576,22 @@ const HexplorationMod = (() => { all: 'Totes les fitxes', }, revealMode: { - clear: 'Clar', - glimpse: "Un cop d'ull", + clear: 'Neteja', + glimpse: "Cop d'ull", }, announce: { all: 'Tothom', - gm: 'Només GM', - off: 'Apagat', + gm: 'Només el GM', + off: 'Desactivat', }, orientation: { - vertical: 'Hexadecimal (V)', + vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Omplir', - fillInverse: 'Farciment invers', - conceal: 'Ocultar', + fill: 'Omple', + fillInverse: 'Emplenament invers', + conceal: 'Amaga', }, }, settings: { @@ -1567,12 +1600,12 @@ const HexplorationMod = (() => { desc: 'Idioma per a menús, missatges i fullets.', }, hexLayer: { - label: 'Capa hexagonal', - desc: "On es dibuixen nous hexagones. Auto prova la capa de primer pla (a sobre de fitxes) i torna a caure a la capa de fitxes si el joc no l'admet.", + label: 'Capa dels hexàgons', + desc: "On es dibuixen els hexàgons nous. Automàtic prova la capa de primer pla (per sobre de les fitxes) i recorre a la capa de fitxes si el joc no l'admet.", }, fillColor: { label: 'Color de farciment', - desc: 'Color dels nous hexagonals. Utilitzeu rgba() per a hexadecimals transparents, per exemple rgba(0,0,0,0.8).', + desc: 'Color dels hexàgons nous. Utilitzeu rgba() per a hexàgons transparents, per exemple rgba(0,0,0,0.8).', }, strokeColor: { label: 'Color de la vora', @@ -1580,18 +1613,18 @@ const HexplorationMod = (() => { }, labelColor: { label: "Color de l'etiqueta", - desc: 'Color de les etiquetes de nom només de GM en hexadecims amb nom.', + desc: 'Color de les etiquetes de nom, visibles només per al GM, dels hexàgons amb nom.', }, glimpseColor: { - label: "Color d'ull", - desc: 'Els hexagonals de color canvien a quan es veuen (mode de revelació de vista). Utilitzeu un color rgba() transparent.', + label: "Color de cop d'ull", + desc: "Color que prenen els hexàgons quan es veuen de cop d'ull (mode de revelació Cop d'ull). Utilitzeu un color rgba() transparent.", }, strokeWidth: { label: 'Amplada de la vora', - desc: 'Amplada del contorn dels nous hexadecimals, en píxels (0 a 20).', + desc: 'Amplada del contorn dels hexàgons nous, en píxels (de 0 a 20).', }, maxDistance: { - label: 'Distància de revelació hexagonal', + label: 'Distància de revelació dels hexàgons', desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", }, revealDistance: { @@ -1612,14 +1645,14 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Mode de revelació', - desc: "Clear elimina els hexàgons a la vista. En canvi, la vista els fa veure a través; s'eliminen quan hi entra una fitxa.", + desc: "Neteja elimina els hexàgons a la vista. Cop d'ull, en canvi, els fa transparents; s'eliminen quan hi entra una fitxa.", }, announce: { label: 'Anunciar descobriments', desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', }, pingDiscoveries: { - label: 'Ping Descobriments', + label: 'Fer ping als descobriments', desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', }, hideCoveredTokens: { @@ -1630,30 +1663,30 @@ const HexplorationMod = (() => { status: { engine: 'Motor de joc', grid: 'Quadrícula', - layer: 'Capa hexagonal', - hexes: 'Hexes', - named: 'Hexagones anomenats', + layer: 'Capa dels hexàgons', + hexes: 'Hexàgons', + named: 'Hexàgons amb nom', icons: "Fitxes d'ubicació", - glimpsed: 'Hexagones albirats', - pending: "Ubicacions a l'espera d'omplir-se", + glimpsed: 'Hexàgons albirats', + pending: "Ubicacions pendents d'emplenament", calibrated: 'Calibrat', - overrides: 'Anul·lació de la pàgina', - undo: 'Desfer disponible', + overrides: 'Substitucions de la pàgina', + undo: 'Es pot desfer', }, messages: { filled: - 'Omplir complet. Hexagones dibuixats: {created}. Redisseny: {restyled}. Ubicacions amagades: {icons}.', + 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', revealed: 'Hexagones revelats: {count}.', - revealedPage: "S'han revelat tots els hexadecimals de la pàgina ({count}).", + revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: - 'Eliminar tots els hexadecimals de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Desfer no pot revertir això.', - resetPage: 'Hexadecimals eliminats de la pàgina: {count}.', + 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', + resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', - named: 'Hexadecimals anomenats "{name}": {count}.', + named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: - 'Ubicacions amagades en hexadecimals existents: {attached}. Esperant el següent farcit que els cobreixi: {pending}.', + 'Ubicacions amagades en hexàgons existents: {attached}. Pendents del següent farciment que les cobreixi: {pending}.', unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: @@ -1664,11 +1697,11 @@ const HexplorationMod = (() => { "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: - "Els vostres mapes hexadecimals d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Reexplora a cada pàgina de mapa hexadecimal.", + "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", pruned: - "Hexagones desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Tornar a escanejar a la pàgina per recollir-ne els hexàgons.", + "Hexàgons desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Torna a escanejar a la pàgina per recuperar-ne els hexàgons.", readyHint: - 'Escriviu !hexploration per al menú o obriu el fullet "Hexploration - Conjunt d\'ordres".', + 'Escriviu !hexploration per obrir el menú o obriu el fullet "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -1678,7 +1711,7 @@ const HexplorationMod = (() => { }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", - notHex: 'Aquesta pàgina no utilitza una graella hexadecimal.', + notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", tooMany: "Això crearia massa hexagones d'una vegada ({count}).", @@ -1705,13 +1738,13 @@ const HexplorationMod = (() => { 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", noHexes: - 'Els hexagonals es troben en primer pla o capa de fitxes; canvieu a aquesta capa per seleccionar-los.', + 'Els hexàgons són a la capa de primer pla o a la de fitxes; canvieu a aquesta capa per seleccionar-los.', unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', calibrateNeedsTokens: - "Col·loca una fitxa al centre d'un hexagonal i selecciona-la. Seleccioneu una segona fitxa enganxada a un hexadecimal veí a la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", + "Col·loqueu una fitxa al centre d'un hexàgon i seleccioneu-la. Seleccioneu una segona fitxa ajustada a un hexàgon veí de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", calibrateFailed: - "Dues fitxes han d'estar a la mateixa fila (hexadecimal V) o a la mateixa columna (hexadecimal H), almenys un hexadecimal de distància.", + "Les dues fitxes han d'estar a la mateixa fila (Hex V) o a la mateixa columna (Hex H), separades almenys per un hexàgon.", unexpected: "Els detalls es troben al registre de la consola de l'API.", }, help: { @@ -1721,10 +1754,10 @@ const HexplorationMod = (() => { undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", reveal: 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', - revealPage: 'Revela cada hexadecimal de la pàgina sense anuncis.', + revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", - resetPage: 'Traieu tots els hexadecimals de la pàgina (demana primer).', + resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', @@ -1732,30 +1765,29 @@ const HexplorationMod = (() => { pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: - 'Reconstrueix la llista hexadecimal de la pàgina, per exemple després de copiar una pàgina o un joc.', + "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', - journal: "Reconstruïu els fulls d'ajuda i de comandaments.", + journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", help: 'Mostra aquesta llista.', handout: 'Les instruccions completes es troben al fullet "{name}".', }, deck: { - subtitle: 'Comandament de la plataforma', drawDesc: - "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfer inverteix l'últim farcit.", + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfés l'emplenament reverteix l'últim emplenament.", revealDesc: - "Seleccioneu hexagonals, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revelacions al voltant de fitxes seleccionades com si s'haguessin mogut.", + "Selecciona hexàgons, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revela el voltant de les fitxes seleccionades com si s'haguessin mogut.", locationsDesc: - 'Seleccioneu fitxes per amagar-les com a ubicacions sota hexagones. Seleccioneu hexadecimals o fitxes per anomenar un hexadecimal.', + 'Seleccioneu fitxes per amagar-les com a ubicacions sota els hexàgons. Seleccioneu hexàgons o fitxes per posar nom a un hexàgon.', toolsDesc: 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', }, handout: { versionLabel: 'Versió', - subtitle: 'Exploració hexadecimal per hexadecimal per a Roll20', + subtitle: 'Exploració hexàgon a hexàgon per a Roll20', footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', @@ -1767,7 +1799,7 @@ const HexplorationMod = (() => { steps: [ 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", - "Seleccioneu les formes i feu clic a Emplenar el conjunt d'ordres (o escriviu !hexploration fill). Les formes es substitueixen per hexagonals.", + 'Seleccioneu les formes i feu clic a Omple al Command Deck (o escriviu !hexploration fill). Les formes se substitueixen per hexàgons.', "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', ], @@ -1782,12 +1814,12 @@ const HexplorationMod = (() => { revealing: { heading: 'Com funciona la revelació', points: [ - 'Només les fitxes de la capa de fitxes revelen hexagones. El nombre de fitxes està establert per Fitxes que revelen: fitxes de jugador per defecte, de manera que el GM pot moure monstres sense descobrir el mapa.', - "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Reveal Along Path activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els waypoints.", - "La distància de visió revela els hexagones al voltant de cadascun d'aquests hexagones. Amb la línia de visió activada, un hexàgon només es revela si no hi ha cap hexagonal cobert entremig.", - "Hex Reveal La distància s'emmagatzema en hexagonals a mesura que es dibuixen. Aquests hexagones només es revelen des de dins tants hexagones, per molt lluny que pugui veure una fitxa. Utilitzeu-lo per muntanyes o boscos que amaguen el que hi ha darrere.", - "En el mode Visió visual, els hexàgons a la vista esdevenen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", + "La distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons. Amb Línia de visió activada, un hexàgon només es revela si no hi ha cap hexàgon cobert entremig.", + "La distància de revelació dels hexàgons s'emmagatzema als hexàgons quan es dibuixen. Aquests hexàgons només es revelen des d'un màxim d'aquest nombre d'hexàgons, per lluny que pugui veure una fitxa. Utilitzeu-la per a muntanyes o boscos que amaguen el que hi ha darrere.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], }, @@ -1797,14 +1829,14 @@ const HexplorationMod = (() => { "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", - "Name Hex dóna un nom a un hexadecimal sense cap testimoni. El nom es mostra al GM com una etiqueta a la capa de GM i s'anuncia quan es revela l'hex.", - "Announce Discoveries tria si tothom, només el GM, o ningú veu l'anunci. Ping Discoveries també mou la vista dels jugadors a la ubicació.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], }, settings: { heading: 'Configuració', intro: - "Canvieu la configuració amb !hexploration set (o el botó Configuració). La capa hexadecimal, els fitxes que revelen i l'idioma també es poden configurar a la pàgina de configuració del mod.", + 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', colKey: 'clau', colName: 'Configuració', colDesc: 'Descripció', @@ -1814,18 +1846,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate i Legacy', points: [ 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', - "Amb la capa hexadecimal establerta a Automàtic, els hexadecimals es dibuixen a la capa de primer pla, per sobre de les fitxes, de manera que els jugadors no poden veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de testimoni.", - "Jumpgate dibuixa hexagones matemàticament regulars, que tenen una forma lleugerament diferent dels hexagones heretats. Si els hexadecimals no s'alineen amb la quadrícula d'una pàgina, col·loqueu un testimoni a un centre hexadecimal, seleccioneu-lo i feu clic a Calibrar. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (hexadecimal V) o columna (hexadecimal H) per corregir també la mida de l'hexadecimal.", - "Quan es copia una pàgina o un joc, els seus hexadecimals obtenen nous identificadors. Executeu Torna a escanejar a la pàgina per tornar-los a recollir, juntament amb les etiquetes de noms i fitxes d'ubicació.", + "Amb Capa dels hexàgons establerta a Automàtic, els hexàgons es dibuixen a la capa de primer pla, per sobre de les fitxes, perquè els jugadors no puguin veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de fitxes.", + "Jumpgate dibuixa hexàgons matemàticament regulars, que tenen una forma lleugerament diferent dels hexàgons de Legacy. Si els hexàgons no s'alineen amb la graella d'una pàgina, ajusteu una fitxa al centre d'un hexàgon, seleccioneu-la i feu clic a Calibra. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + "Quan es copia una pàgina o un joc, els seus hexàgons reben identificadors nous. Executeu Torna a escanejar a la pàgina per tornar-los a recuperar, juntament amb les etiquetes de nom i les fitxes d'ubicació.", ], }, upgrading: { heading: 'Actualització de la versió 1', points: [ 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', - "Els mapes hexadecimals, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament al primer inici.", + "Els mapes d'hexàgons, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament la primera vegada que s'inicia.", 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', - 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexagones. Estableix fitxes que revelen en fitxes de personatge per mantenir aquest comportament.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], colV1: 'Comandament de la versió 1', colV2: 'Comandament de la versió 2', @@ -1833,10 +1865,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Resolució de problemes', points: [ - 'No passa res quan un testimoni es mou: comproveu que el testimoni estigui a la capa de fitxes i coincideixi amb els fitxes que es revelen i que la pàgina tingui hexadecimals (estat! hexploration).', - 'Els hexagones es desplacen de la quadrícula: utilitzeu Calibrar i, a continuació, comproveu amb una fitxa en uns quants hexagones del mapa.', - 'Hexes va deixar de revelar-se després de copiar una pàgina o un joc: executeu Tornar a explorar la pàgina.', - "El farciment diu que l'àrea no té centres hexagonals: la forma ha de contenir el centre d'almenys un hexagonal.", + 'No passa res quan es mou una fitxa: comproveu que la fitxa és a la capa de fitxes i que coincideix amb Fitxes que revelen, i que la pàgina té hexàgons (!hexploration status).', + 'Els hexàgons estan desplaçats respecte de la quadrícula: utilitzeu Calibra i, a continuació, comproveu-ho amb una fitxa en uns quants hexàgons del mapa.', + 'Els hexàgons han deixat de revelar-se després de copiar una pàgina o un joc: executeu Torna a escanejar a la pàgina.', + "Omple diu que l'àrea no té centres d'hexàgon: la forma ha de contenir el centre d'almenys un hexàgon.", "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", ], }, @@ -1844,7 +1876,7 @@ const HexplorationMod = (() => { heading: 'Idiomes', body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", colLanguage: 'Llengua', - colNative: 'Nom nadiu', + colNative: 'Nom original', colCode: 'Codi', }, credits: { @@ -1860,81 +1892,81 @@ const HexplorationMod = (() => { const TRANSLATION$k = { titles: { - ready: 'H探索已準備就緒。', - settings: 'H探索設置', + ready: 'Hexploration 已就緒。', + settings: 'Hexploration 設定', languages: '選擇語言', pageSettings: '頁面設定：{page}', - status: 'H探索狀態：{page}', - help: '探索命令', + status: 'Hexploration 狀態：{page}', + help: 'Hexploration 指令', confirm: '請確認', }, discovery: { title: '發現地點', }, menu: { - draw: '畫', - reveal: '顯示和隱藏', + draw: '繪製', + reveal: '揭示與隱藏', locations: '地點', tools: '工具', layerInUse: '正在 {layer} 上繪製新的六角形。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', undo: '撤銷填充', reveal: '揭示', conceal: '隱藏', explore: '探索', - revealPage: '顯示頁面', + revealPage: '揭示整頁', resetPage: '重置頁面', - mark: '標記位置', + mark: '標記地點', unmark: '取消標記', - name: '名稱十六進位', + name: '命名六角格', settings: '設定', pageSettings: '頁面設定', - status: '地位', + status: '狀態', rescan: '重新掃描', calibrate: '校準', calibrateReset: '重置校準', - help: '幫助', - change: '改變', + help: '說明', + change: '變更', menu: '選單', - clearOverrides: '清除覆蓋', - confirmReset: '是的，刪除所有六角形', + clearOverrides: '清除覆寫', + confirmReset: '是，移除所有六角格', }, prompts: { name: '地點名稱（留空以清除）', }, values: { - on: '在', - off: '離開', - none: '沒有任何', + on: '開', + off: '關', + none: '無', hexLayer: { - auto: '自動（前景，如果可用）', + auto: '自動（可用時使用前景層）', foreground: '前景層', objects: '令牌層', }, revealBy: { - players: '玩家代幣', - characters: '字元標記', - all: '所有代幣', + players: '玩家令牌', + characters: '角色令牌', + all: '所有令牌', }, revealMode: { clear: '清除', - glimpse: '一瞥', + glimpse: '瞥見', }, announce: { - all: '每個人', - gm: '限通用汽車', - off: '離開', + all: '所有人', + gm: '僅限 GM', + off: '關', }, orientation: { - vertical: '六角 (V)', - horizontal: '六角 (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '充滿', + fill: '填充', fillInverse: '反向填充', conceal: '隱藏', }, @@ -1945,12 +1977,12 @@ const HexplorationMod = (() => { desc: '選單、訊息和講義的語言。', }, hexLayer: { - label: '六角層', + label: '六角格圖層', desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', }, fillColor: { label: '填充顏色', - desc: '新六角形的顏色。使用 rgba() 來透視十六進位，例如 rgba(0,0,0,0.8)。', + desc: '新六角格的顏色。若要讓六角格半透明，請使用 rgba()，例如 rgba(0,0,0,0.8)。', }, strokeColor: { label: '邊框顏色', @@ -1962,14 +1994,14 @@ const HexplorationMod = (() => { }, glimpseColor: { label: '瞥見顏色', - desc: '瞥見時，顏色六角形會變更為（瞥見顯示模式）。使用透明的 rgba() 顏色。', + desc: '六角格被瞥見時變成的顏色（「瞥見」揭示模式）。請使用半透明的 rgba() 顏色。', }, strokeWidth: { label: '邊框寬度', desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { - label: '十六進位顯示距離', + label: '六角格揭示距離', desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', }, revealDistance: { @@ -1985,46 +2017,46 @@ const HexplorationMod = (() => { desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', }, revealBy: { - label: '揭示的代幣', - desc: '令牌層上的哪些令牌顯示六角形：由玩家控制的令牌、代表任何角色的令牌或每個令牌。', + label: '可揭示的令牌', + desc: '令牌層上哪些令牌會揭示六角格：由玩家控制的令牌、代表任何角色的令牌，或所有令牌。', }, revealMode: { label: '揭示模式', - desc: '清除可移除視線範圍內的六角形。瞥見反而讓他們看穿；當令牌進入它們時，它們就會被刪除。', + desc: '清除會移除視線範圍內的六角格。瞥見則改為讓六角格變得半透明；令牌進入時才將其移除。', }, announce: { - label: '宣布發現', + label: '公告發現', desc: '當發現指定位置時誰會看到聊天訊息。', }, pingDiscoveries: { - label: '平發現', + label: '標示發現位置', desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', }, hideCoveredTokens: { - label: '隱藏覆蓋的令牌', + label: '隱藏被覆蓋的令牌', desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', }, }, status: { engine: '遊戲引擎', grid: '網格', - layer: '六角層', - hexes: '六角形', - named: '命名六角形', - icons: '位置標記', - glimpsed: '瞥見的六角形', - pending: '等待填補的地點', + layer: '六角格圖層', + hexes: '六角格', + named: '已命名的六角格', + icons: '地點令牌', + glimpsed: '被瞥見的六角格', + pending: '等待填充的地點', calibrated: '已校準', - overrides: '頁面覆蓋', - undo: '可以撤銷', + overrides: '頁面覆寫', + undo: '可撤銷', }, messages: { filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', revealed: '六角形顯示：{count}。', - revealedPage: '顯示頁面上的每個十六進位 ({count})。', + revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: - '刪除「{page}」（{count}）中的每個十六進位？位置令牌返回令牌層。撤銷無法逆轉此情況。', - resetPage: '從頁面中刪除的十六進位：{count}。', + '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', + resetPage: '已從頁面移除的六角格：{count}。', undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', named: '名為「{name}」的六角形：{count}。', unnamed: '已清除的名稱：{count}。', @@ -2038,10 +2070,10 @@ const HexplorationMod = (() => { calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Heexploration 1.x 十六進位地圖已升級。如果此遊戲是從舊版遊戲複製的，請在每個十六進位地圖頁面上執行重新掃描。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: - '已保存的不再存在並被遺忘的十六進位：{dropped}。如果該遊戲或頁面被複製，請在該頁面上執行重新掃描以再次擷取其六角形。', - readyHint: '在選單中輸入 !hexploration，或開啟「Hexploration - Command Deck」講義。', + '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', + readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', @@ -2068,7 +2100,7 @@ const HexplorationMod = (() => { }, hints: { noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', - notHex: '在頁面設定中將頁面網格設定為十六進位 (V) 或十六進位 (H)。', + notHex: '請在頁面設定中將頁面網格設為 Hex (V) 或 Hex (H)。', noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', @@ -2077,7 +2109,7 @@ const HexplorationMod = (() => { unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', - calibrateFailed: '兩個標記必須位於同一行 (Hex V) 或同一列 (Hex H)，相距至少 1 個十六進位。', + calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { @@ -2086,49 +2118,48 @@ const HexplorationMod = (() => { fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', - revealPage: '顯示頁面上的每個十六進制，無需公告。', + revealPage: '揭示頁面上的所有六角格，不發布公告。', conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', - resetPage: '刪除頁面上的每個十六進制（首先詢問）。', + resetPage: '移除頁面上的所有六角格（會先確認）。', name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', mark: '將選取的標記變成隱藏位置。', unmark: '停止將選定的標記隱藏在位置。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', - rescan: '重建頁面的十六進位列表，例如複製頁面或遊戲後。', + rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', - journal: '重建幫助和命令平台講義。', + journal: '重建說明與 Command Deck 講義。', help: '顯示此清單。', handout: '完整說明位於「{name}」講義。', }, deck: { - subtitle: '指揮台', - drawDesc: '在某個區域周圍繪製形狀，選擇它們，然後填充。撤消會反轉最後一次填充。', + drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', - locationsDesc: '選擇標記以將其隱藏為六角形下的位置。選擇十六進位或標記來命名十六進位。', + locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', }, handout: { versionLabel: '版本', - subtitle: 'Roll20 的逐十六進位探索', + subtitle: 'Roll20 的逐格六角格探索', footer: '使用“{deck}”講義進行一鍵式控制項。', overview: { heading: '概述', - body: 'Heexploration 覆蓋了帶有不透明六角形的六角形地圖。當隊伍移動時，他們穿過的六角形（如果你願意的話，他們周圍的六角形）也會被移除，因此地圖一次會露出一個六角形。隱藏位置可以放置在六角形下，並在發現時宣布。它適用於 Jumpgate 和 Legacy 遊戲，適用於任何大小的 Hex (V) 和 Hex (H) 網格。', + body: 'Hexploration 以不透明的六角格覆蓋六角格地圖。隊伍移動時，他們經過的六角格（以及你願意的話，周圍的六角格）會被移除，讓地圖一格一格地揭開。隱藏地點可以放在六角格下方，被找到時會公告。它適用於 Jumpgate 和 Legacy 遊戲，以及任何大小的 Hex (V) 和 Hex (H) 網格。', demo: '觀看簡短的演示（來自版本 1）', }, quickStart: { heading: '快速入門', steps: [ - '開啟網格設定為十六進位 (V) 或十六進位 (H) 的頁面。', + '開啟網格設為 Hex (V) 或 Hex (H) 的頁面。', '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', - '選擇形狀並點選指令面板中的「填滿」（或鍵入 !hexploration fill）。形狀被六角形取代。', - '可選：填寫前，選擇重要地點的標記，然後按一下「標記位置」。它們隱藏在六角形下並在被發現時宣布。', + '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', + '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', ], }, @@ -2142,40 +2173,40 @@ const HexplorationMod = (() => { revealing: { heading: '揭示如何運作', points: [ - '只有令牌層上的令牌才會顯示六角形。預設情況下，哪些令牌計數由「顯示的令牌：玩家令牌」設置，因此 GM 可以在不揭開地圖的情況下移動怪物。', + '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', - '六角形顯示距離在繪製時儲存在六角形上。無論令牌能看到多遠，這些六角形都只能從那麼多六角形內顯露出來。將其用於隱藏其後面的山脈或森林。', - '在「一瞥」模式中，視線內的六角形會變得透明而不是消失，當令牌進入其中時會被移除。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', - 'API 不會報告其他模組所做的動作。 TokenMod 動作會自動拾取；對於其他 mod，請選擇令牌並點擊“探索”，或從您自己的 mod 中呼叫 Heexploration.revealAround(token)。', + '「六角格揭示距離」會在六角格繪製時儲存在六角格上。無論令牌能看多遠，這些六角格都只會在該格數範圍內被揭示。可用於遮擋後方景物的山脈或森林。', + '在「瞥見」模式中，視線內的六角格會變為半透明而非消失，並在令牌進入時被移除。', + 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', + 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', ], }, locations: { heading: '命名六角形和位置', points: [ - '標記位置將選定的標記轉變為隱藏位置。已經在六角形下的標記會立即隱藏；否則它會被覆蓋它的下一個填充隱藏。', + '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', - '隱藏位置標記被移至 GM 層。當他們的十六進制被揭露時，他們返回到令牌層並顯示他們的名字，並宣布他們的發現。', - 'Name Hex 為十六進位提供一個沒有標記的名稱。該名稱作為 GM 層上的標籤顯示給 GM，並在十六進位顯示時宣布。', - '宣布發現選擇是所有人、僅總經理還是無人看到該公告。 Ping Discoveries 也將玩家的視野移動到該位置。', + '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', ], }, settings: { heading: '設定', intro: - '使用 !hexploration set（或「設定」按鈕）變更設定。十六進位圖層、顯示的令牌和語言也可以在 Mod 的設定頁面上設定。', + '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', colKey: '鑰匙', colName: '環境', colDesc: '描述', perPage: '（可按頁設定。）', }, jumpgate: { - heading: '跳躍門和遺產', + heading: 'Jumpgate 與 Legacy', points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', - '將「六角形圖層」設定為「自動」時，六角形會繪製在令牌上方的前景圖層上，因此玩家無法看到下面的內容。如果前景層不可用，則使用令牌層。', - 'Jumpgate 繪製數學上規則的六角形，其形狀與舊版六角形略有不同。如果六角形未與頁面網格對齊，請將標記捕捉到六角形中心，選擇它並按一下校準。選擇同一行（十六進位 V）或同一列（十六進位 H）的相鄰六角形中的兩個標記也可以更正六角形大小。', + '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', ], }, @@ -2183,9 +2214,9 @@ const HexplorationMod = (() => { heading: '從版本 1 升級', points: [ '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', - '現有的十六進位地圖、名稱、位置標記和設定會在首次啟動時自動升級。', - '版本 1 指令（包括 Heexploration_menu 巨集）仍然有效。', - '版本 1 讓任何代表字元的標記都顯示十六進位。將「顯示的令牌」設為「角色令牌」以保留該行為。', + '現有的六角格地圖、名稱、地點令牌與設定會在首次啟動時自動升級。', + '版本 1 的指令（包括 Hexploration_menu 巨集）仍然有效。', + '版本 1 允許任何代表角色的令牌揭示六角格。若要保留此行為，請將「可揭示的令牌」設為「角色令牌」。', ], colV1: '版本 1 指令', colV2: '版本 2 指令', @@ -2193,18 +2224,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: '故障排除', points: [ - '令牌移動時不會發生任何事情：檢查令牌是否位於令牌層上並與「顯示的令牌」匹配，頁面是否有六角形（！h探索狀態）。', + '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', - '複製頁面或遊戲後，十六進位停止顯示：在頁面上執行重新掃描。', - 'Fill 表示該區域沒有六角形中心：該形狀必須包含至少一個六角形的中心。', + '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', + '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', ], }, languages: { heading: '語言', - body: '透過 !hexploration 設定語言來選擇語言。可用語言：', + body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', - colNative: '原生名', + colNative: '原文名稱', colCode: '程式碼', }, credits: { @@ -2220,84 +2251,84 @@ const HexplorationMod = (() => { const TRANSLATION$j = { titles: { - ready: 'Heexploration je připraven.', - settings: 'Nastavení Heexploration', + ready: 'Hexploration je připraven.', + settings: 'Nastavení Hexploration', languages: 'Vyberte jazyk', pageSettings: 'Nastavení stránky: {page}', - status: 'Stav průzkumu: {page}', - help: 'Příkazy pro průzkum', - confirm: 'Prosím potvrďte', + status: 'Stav Hexploration: {page}', + help: 'Příkazy Hexploration', + confirm: 'Potvrďte prosím', }, discovery: { title: 'Místo objeveno', }, menu: { - draw: 'Remíza', - reveal: 'Odhalit a skrýt', + draw: 'Kreslení', + reveal: 'Odhalení a skrytí', locations: 'Místa', tools: 'Nástroje', - layerInUse: 'Na {layer} se kreslí nové hexy.', + layerInUse: 'Vrstva, do které se kreslí nové hexy: {layer}.', pageSettingsHelp: 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', }, buttons: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - undo: 'Vrátit zpět výplň', + undo: 'Vrátit výplň', reveal: 'Odhalit', - conceal: 'Skrývat', + conceal: 'Zakrýt', explore: 'Prozkoumat', revealPage: 'Odhalit stránku', - resetPage: 'Obnovit stránku', - mark: 'Označte umístění', + resetPage: 'Resetovat stránku', + mark: 'Označit místo', unmark: 'Zrušit označení', - name: 'Jméno Hex', + name: 'Pojmenovat hex', settings: 'Nastavení', pageSettings: 'Nastavení stránky', - status: 'Postavení', - rescan: 'Znovu naskenujte', + status: 'Stav', + rescan: 'Znovu skenovat', calibrate: 'Kalibrovat', calibrateReset: 'Resetovat kalibraci', help: 'Pomoc', - change: 'Přeměna', + change: 'Změnit', menu: 'Menu', - clearOverrides: 'Vymazat přepisy', - confirmReset: 'Ano, Odebrat všechny hexy', + clearOverrides: 'Zrušit přepsání', + confirmReset: 'Ano, odebrat všechny hexy', }, prompts: { name: 'Název místa (pro vymazání ponechte prázdné)', }, values: { - on: 'Na', + on: 'Zapnuto', off: 'Vypnuto', - none: 'Žádný', + none: 'Žádné', hexLayer: { auto: 'Auto (popředí, pokud je k dispozici)', foreground: 'vrstva popředí', - objects: 'vrstva tokenů', + objects: 'vrstva žetonů', }, revealBy: { - players: 'Hráčské žetony', + players: 'Žetony hráčů', characters: 'Žetony postav', - all: 'Všechny tokeny', + all: 'Všechny žetony', }, revealMode: { - clear: 'Jasný', + clear: 'Odstranění', glimpse: 'Záblesk', }, announce: { - all: 'Každý', + all: 'Všichni', gm: 'Pouze GM', off: 'Vypnuto', }, orientation: { - vertical: 'Hexadecimální (V)', - horizontal: 'Hexadecimální (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vyplnit', fillInverse: 'Inverzní výplň', - conceal: 'Skrývat', + conceal: 'Zakrýt', }, }, settings: { @@ -2306,7 +2337,7 @@ const HexplorationMod = (() => { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Hexadecimální vrstva', + label: 'Vrstva šestiúhelníků', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { @@ -2318,66 +2349,66 @@ const HexplorationMod = (() => { desc: 'Barva obrysu nových hexů.', }, labelColor: { - label: 'Barva štítku', + label: 'Barva popisku', desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', }, glimpseColor: { label: 'Barva záblesku', - desc: 'Barevné hexy se při zahlédnutí změní na (režim Odhalení letmým pohledem). Použijte průhlednou barvu rgba().', + desc: 'Barva, kterou hexy získají při zahlédnutí (režim odhalování Záblesk). Použijte průhlednou barvu rgba().', }, strokeWidth: { - label: 'Šířka okraje', + label: 'Šířka ohraničení', desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Hexadecimální vzdálenost odhalení', + label: 'Vzdálenost odhalení šestiúhelníků', desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', }, revealDistance: { - label: 'Pohledová vzdálenost', + label: 'Vzdálenost dohledu', desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', }, lineOfSight: { - label: 'Zornost', + label: 'Přímá viditelnost', desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', }, revealPath: { - label: 'Odhalení Po cestě', + label: 'Odhalovat po cestě', desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', }, revealBy: { - label: 'Tokeny, které odhalují', + label: 'Žetony, které odhalují', desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', }, revealMode: { - label: 'Režim odhalení', - desc: 'Clear odstraní hexy na dohled. Letmý pohled je místo toho dělá průhlednými; jsou odstraněny, když do nich vstoupí token.', + label: 'Režim odhalování', + desc: 'Odstranění odstraní hexy v dohledu. Záblesk je místo toho zprůhlední; odstraní se, když do nich vstoupí žeton.', }, announce: { - label: 'Oznamte objevy', + label: 'Oznamovat objevy', desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', }, pingDiscoveries: { - label: 'Ping Discovery', + label: 'Pingnout objevy', desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', }, hideCoveredTokens: { - label: 'Skryjte kryté žetony', + label: 'Skrýt zakryté žetony', desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', }, }, status: { engine: 'Herní engine', grid: 'Mřížka', - layer: 'Hexadecimální vrstva', + layer: 'Vrstva hexů', hexes: 'Hexy', named: 'Pojmenované hexy', - icons: 'Tokeny polohy', + icons: 'Žetony míst', glimpsed: 'Zahlédnuté hexy', - pending: 'Místa čekající na zaplnění', + pending: 'Místa čekající na výplň', calibrated: 'Zkalibrováno', - overrides: 'Přepíše stránku', - undo: 'Zpět k dispozici', + overrides: 'Přepsání stránky', + undo: 'Lze vrátit zpět', }, messages: { filled: @@ -2388,7 +2419,7 @@ const HexplorationMod = (() => { 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: - 'Poslední výplň zrušena. Odstraněné hexy: {removed}. Obnovené obnovené hexy: {restored}.', + 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', named: 'Hexusy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: @@ -2403,11 +2434,11 @@ const HexplorationMod = (() => { 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: - 'Vaše hex mapy Heexploration 1.x byly upgradovány. Pokud byla tato hra zkopírována ze starší hry, spusťte znovu skenování na každé stránce hexové mapy.', + 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', pruned: - 'Uložená hexy, která již neexistují a byla zapomenuta: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte Rescan na stránce a znovu seberte její hexy.', + 'Uložené hexy, které již neexistují a byly zapomenuty: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte na stránce Znovu skenovat, aby se její hexy znovu načetly.', readyHint: - 'Zadejte !hexploration pro nabídku nebo otevřete leták „Hexploration – Command Deck“.', + 'Zadejte !hexploration pro otevření nabídky nebo otevřete leták "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -2417,7 +2448,7 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', - notHex: 'Tato stránka nepoužívá hexadecimální mřížku.', + notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', @@ -2470,17 +2501,16 @@ const HexplorationMod = (() => { calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', - status: 'Ukažte, co Heexploration ví o aktuální stránce.', - journal: 'Znovu sestavte podklady pro balíček nápovědy a příkazů.', + status: 'Zobrazit, co Hexploration ví o aktuální stránce.', + journal: 'Znovu vytvořte letáky „Pomoc“ a „Command Deck“.', help: 'Zobrazit tento seznam.', handout: 'Úplné pokyny jsou v letáku „{name}“.', }, deck: { - subtitle: 'Velitelský balíček', drawDesc: 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', revealDesc: - 'Vyberte hexy, tvary nebo žetony, abyste je znovu odhalili nebo zakryli. Prozkoumejte odhalení kolem vybraných žetonů, jako by se pohnuly.', + 'Vyberte hexy, tvary nebo žetony, abyste je odhalili nebo znovu zakryli. Prozkoumat odhalí okolí vybraných žetonů, jako by se pohnuly.', locationsDesc: 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', toolsDesc: @@ -2501,9 +2531,9 @@ const HexplorationMod = (() => { steps: [ 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', - 'Vyberte tvary a klikněte na Vyplnit v balíčku příkazů (nebo zadejte !hexploration fill). Tvary jsou nahrazeny hexy.', + 'Vyberte tvary a v Command Deck klikněte na Vyplnit (nebo zadejte !hexploration fill). Tvary se nahradí hexy.', 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', - 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Viditelné vzdálenosti jsou odhaleny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Vzdálenosti dohledu jsou odhaleny.', ], }, commands: { @@ -2516,13 +2546,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Jak funguje odhalování', points: [ - 'Pouze žetony na vrstvě žetonů odhalují hexy. Počet žetonů je nastaven pomocí žetonů, které se odhalují: žetony hráčů ve výchozím nastavení, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', - 'Žeton odhaluje každý hex, který zakrývá (velké žetony jich pokrývají několik), a se zapnutou funkcí Odhalení podél cesty každý hex na trase, po které byl tažen, včetně navigačních bodů.', - 'Viditelná vzdálenost odhaluje hexy kolem každého z těchto hexů. Se zapnutou linií viditelnosti je hex odhalen pouze v případě, že mezi nimi není žádný krytý hex.', - 'Hexová vzdálenost odhalení je uložena na hexech tak, jak jsou kresleny. Tyto hexy jsou odhaleny pouze z tolika hexů, jakkoli daleko žeton vidí. Použijte jej na hory nebo lesy, které skrývají to, co je za nimi.', - 'V režimu Glimpse se hexy v dohledu stanou průhlednými, místo aby zmizely, a jsou odstraněny, když do nich vstoupí žeton.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', - 'API nehlásí pohyby provedené jinými mody. Pohyby TokenMod se sbírají automaticky; pro další mody vyberte tokeny a klikněte na Prozkoumat, nebo zavolejte Heexploration.revealAround(token) ze svého vlastního modu.', + 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů. Se zapnutou Přímou viditelností je hex odhalen pouze tehdy, když mezi ním a žetonem neleží žádný zakrytý hex.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do hexů při jejich kreslení. Tyto hexy lze odhalit jen ze vzdálenosti nejvýše tolika hexů, ať žeton vidí jakkoli daleko. Použijte ji pro hory nebo lesy, které zakrývají, co je za nimi.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton.', + 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', + 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', ], }, locations: { @@ -2531,14 +2561,14 @@ const HexplorationMod = (() => { 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Name Hex dává hexu jméno bez žetonu. Jméno je ukázáno GM jako štítek na GM vrstvě a oznámeno, když je odhalen hex.', - 'Announce Discoveries volí, zda oznámení uvidí všichni, pouze GM nebo nikdo. Ping Discoveries také přesune pohled hráčů na místo.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Změňte nastavení pomocí sady !hexploration (nebo tlačítka Nastavení). Hexadecimální vrstvu, tokeny, které odhalují a jazyk lze také nastavit na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -2548,18 +2578,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate a Legacy', points: [ 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Při nastavení Hex Layer na Auto se hexy kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva tokenu.', + 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', - 'Když je stránka nebo hra zkopírována, její hexy získají nová ID. Spusťte Rescan na stránce a vyzvedněte je znovu spolu s jejich jmenovkami a žetony umístění.', + 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], }, upgrading: { heading: 'Upgrade z verze 1', points: [ 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', - 'Stávající hexadecimální mapy, názvy, tokeny umístění a nastavení se automaticky upgradují při prvním spuštění.', - 'Příkazy verze 1, včetně makra Heexploration_menu, stále fungují.', - 'Verze 1 umožnila jakémukoli žetonu, který představoval postavu, odhalit hexy. Chcete-li zachovat toto chování, nastavte žetony, které se odhalují, na žetony postav.', + 'Stávající hexové mapy, názvy, tokeny lokací a nastavení se při prvním spuštění automaticky aktualizují.', + 'Příkazy verze 1, včetně makra Hexploration_menu, stále fungují.', + 'Verze 1 umožňovala odhalovat hexy každému žetonu, který představoval postavu. Chcete-li toto chování zachovat, nastavte Žetony, které odhalují, na Žetony postav.', ], colV1: 'Příkaz verze 1', colV2: 'Příkaz verze 2', @@ -2567,18 +2597,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Odstraňování problémů', points: [ - 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá žetonům, které odhalují, a že stránka má hexy (stav !hexploration).', + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá nastavení Žetony, které odhalují, a zda stránka obsahuje hexy (!hexploration status).', 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', - 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte znovu skenování stránky.', - 'Fill říká, že oblast nemá žádné středy hexu: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte na stránce Znovu skenovat.', + 'Vyplnit hlásí, že oblast neobsahuje žádné středy hexů: tvar musí obsahovat střed alespoň jednoho hexu.', 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', ], }, languages: { heading: 'Jazyky', - body: 'Vyberte jazyk pomocí nastavení jazyka !hexploration. Dostupné jazyky:', + body: 'Jazyk vyberte příkazem !hexploration set language. Dostupné jazyky:', colLanguage: 'Jazyk', - colNative: 'Rodné jméno', + colNative: 'Vlastní název', colCode: 'Kód', }, credits: { @@ -2598,34 +2628,34 @@ const HexplorationMod = (() => { settings: 'Indstillinger for Hexploration', languages: 'Vælg et sprog', pageSettings: 'Sideindstillinger: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandoer', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandoer', confirm: 'Bekræft venligst', }, discovery: { title: 'Sted opdaget', }, menu: { - draw: 'Tegne', - reveal: 'Afsløre og skjul', + draw: 'Tegn', + reveal: 'Afslør og skjul', locations: 'Steder', tools: 'Værktøjer', - layerInUse: 'Nye sekskanter bliver tegnet på {layer}.', + layerInUse: 'Nye hexfelter tegnes på {layer}.', pageSettingsHelp: 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', }, buttons: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - undo: 'Fortryd Fyld', - reveal: 'Afsløre', - conceal: 'Skjule', - explore: 'Udforske', - revealPage: 'Afsløre side', + undo: 'Fortryd fyld', + reveal: 'Afslør', + conceal: 'Skjul', + explore: 'Udforsk', + revealPage: 'Afslør side', resetPage: 'Nulstil side', - mark: 'Marker placering', + mark: 'Marker sted', unmark: 'Fjern markering', - name: 'Navn Hex', + name: 'Navngiv hexfelt', settings: 'Indstillinger', pageSettings: 'Sideindstillinger', status: 'Status', @@ -2633,45 +2663,45 @@ const HexplorationMod = (() => { calibrate: 'Kalibrer', calibrateReset: 'Nulstil kalibrering', help: 'Hjælp', - change: 'Forandring', + change: 'Skift', menu: 'Menu', clearOverrides: 'Ryd tilsidesættelser', - confirmReset: 'Ja, Fjern alle Hexes', + confirmReset: 'Ja, fjern alle hexfelter', }, prompts: { - name: 'Placeringsnavn (lad tom for at rydde)', + name: 'Stednavn (lad feltet være tomt for at rydde)', }, values: { - on: 'På', - off: 'Slukket', + on: 'Til', + off: 'Fra', none: 'Ingen', hexLayer: { auto: 'Auto (forgrund, hvis tilgængelig)', foreground: 'forgrundslaget', - objects: 'symbollag', + objects: 'tokenlaget', }, revealBy: { - players: 'Spillerpoletter', - characters: 'Karakter tokens', + players: 'Spillertokens', + characters: 'Karaktertokens', all: 'Alle tokens', }, revealMode: { - clear: 'Klar', + clear: 'Fjern', glimpse: 'Glimt', }, announce: { - all: 'Alle sammen', + all: 'Alle', gm: 'Kun GM', - off: 'Slukket', + off: 'Fra', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylde', + fill: 'Fyld', fillInverse: 'Omvendt fyld', - conceal: 'Skjule', + conceal: 'Skjul', }, }, settings: { @@ -2680,11 +2710,11 @@ const HexplorationMod = (() => { desc: 'Sprog til menuer, beskeder og uddelingskopier.', }, hexLayer: { - label: 'Hex lag', - desc: 'Hvor nye sekskanter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + label: 'Lag for hexfelter', + desc: 'Hvor nye hexfelter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', }, fillColor: { - label: 'Fyld farve', + label: 'Fyldfarve', desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { @@ -2692,19 +2722,19 @@ const HexplorationMod = (() => { desc: 'Farve på omridset af nye sekskanter.', }, labelColor: { - label: 'Etiket farve', + label: 'Etiketfarve', desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', }, glimpseColor: { - label: 'Glimt farve', - desc: 'Farvehexer ændres til, når de skimtes (Glimpse-afsløringstilstand). Brug en gennemsigtig rgba()-farve.', + label: 'Glimtfarve', + desc: 'Den farve, hexfelter skifter til, når de skimtes (afsløringstilstanden Glimt). Brug en gennemsigtig rgba()-farve.', }, strokeWidth: { - label: 'Border Bredde', + label: 'Kantbredde', desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', }, maxDistance: { - label: 'Hex afsløre afstand', + label: 'Afsløringsafstand for hexfelter', desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', }, revealDistance: { @@ -2712,20 +2742,20 @@ const HexplorationMod = (() => { desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', }, lineOfSight: { - label: 'Synslinie', + label: 'Synslinje', desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', }, revealPath: { - label: 'Afsløre langs stien', + label: 'Afslør langs ruten', desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', }, revealBy: { - label: 'Tokens, der afslører', + label: 'Afslørende tokens', desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', }, revealMode: { label: 'Afsløringstilstand', - desc: 'Clear fjerner sekskanter inden for syne. Glimt gør dem gennemsigtige i stedet; de fjernes, når et token kommer ind i dem.', + desc: 'Fjern fjerner hexfelter inden for synsvidde. Glimt gør dem i stedet gennemsigtige; de fjernes, når et token går ind i dem.', }, announce: { label: 'Annoncer opdagelser', @@ -2741,16 +2771,16 @@ const HexplorationMod = (() => { }, }, status: { - engine: 'Spil motor', + engine: 'Spilmotor', grid: 'Gitter', - layer: 'Hex lag', - hexes: 'Hekser', - named: 'Navngivne hexes', - icons: 'Placeringstokens', - glimpsed: 'Glimpede sekskanter', - pending: 'Steder, der venter på udfyldning', + layer: 'Lag for hexfelter', + hexes: 'Hexfelter', + named: 'Navngivne hexfelter', + icons: 'Stedtokens', + glimpsed: 'Gennemsigtige hexfelter', + pending: 'Steder, der venter på fyld', calibrated: 'Kalibreret', - overrides: 'Side tilsidesætter', + overrides: 'Sidetilsidesættelser', undo: 'Fortryd tilgængelig', }, messages: { @@ -2777,11 +2807,11 @@ const HexplorationMod = (() => { 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: - 'Dine Hexploration 1.x hex-kort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Rescan på hver hex-kortside.', + 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', pruned: - 'Gemte hexes, der ikke længere eksisterer og blev glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Rescan på siden for at samle dens hexes op igen.', + 'Gemte hexfelter, der ikke længere findes og er blevet glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Scan igen på siden for at finde dens hexfelter igen.', readyHint: - 'Skriv !hexploration for menuen, eller åbn "Hexploration - Command Deck"-uddelingsark.', + 'Skriv !hexploration for at åbne menuen, eller åbn uddelingsarket "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -2845,16 +2875,15 @@ const HexplorationMod = (() => { 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', - journal: 'Genopbyg hjælpe- og kommandodækket-uddelingsarkene.', + journal: 'Genopbyg uddelingsarkene Help og Command Deck.', help: 'Vis denne liste.', handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', }, deck: { - subtitle: 'Kommandodæk', drawDesc: - 'Tegn figurer rundt om et område, vælg dem, og udfyld derefter. Fortryd vender den sidste udfyldning.', + 'Tegn figurer rundt om et område, vælg dem, og fyld derefter. Fortryd fyld annullerer den sidste fyldning.', revealDesc: - 'Vælg sekskanter, former eller tokens for at afsløre eller dække dem igen. Udforsk afsløringer omkring udvalgte tokens, som om de havde flyttet sig.', + 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', toolsDesc: @@ -2875,9 +2904,9 @@ const HexplorationMod = (() => { steps: [ 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', - 'Vælg figurerne, og klik på Fyld i kommandodækket (eller skriv !hexploration fill). Formerne erstattes af sekskanter.', - 'Valgfrit: Inden du udfylder, skal du vælge tokens for vigtige steder og klikke på Marker placering. De er gemt under hexes og annonceret, når de opdages.', - 'Flyt et spillertoken. Hver hex, den passerer igennem, og hexes inden for dens synsafstand, afsløres.', + 'Vælg figurerne, og klik på Fyld i Command Deck (eller skriv !hexploration fill). Figurerne erstattes af hexfelter.', + 'Valgfrit: Før du fylder, kan du vælge tokens for vigtige steder og klikke på Marker sted. De skjules under hexfelterne og annonceres, når de opdages.', + 'Flyt et spillertoken. Hvert hexfelt, det passerer igennem, og hexfelterne inden for dets Synsafstand afsløres.', ], }, commands: { @@ -2890,29 +2919,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Sådan fungerer afsløring', points: [ - 'Kun tokens på tokenlaget afslører sekskanter. Hvilket antal tokens er angivet af Tokens That Reveal: spillerpoletter som standard, så GM kan flytte monstre uden at afdække kortet.', - 'Et token afslører hver hex, den dækker (store tokens dækker flere), og med Reveal Along Path aktiveret, hver hex på den rute, den blev trukket langs, inklusive waypoints.', - 'Sight Distance afslører sekskanterne omkring hver af disse sekskanter. Med Line of Sight slået til, afsløres en hex kun, hvis der ikke ligger nogen dækket hex imellem.', - 'Hex Reveal Distance gemmes på hexes, efterhånden som de tegnes. Disse hexes afsløres kun indefra så mange hexes, uanset hvor langt et token kan se. Brug den til bjerge eller skove, der skjuler, hvad der er bag dem.', - 'I Glimpse-tilstand bliver sekskanter inden for synsvidde gennemsigtige i stedet for at forsvinde, og fjernes, når et token kommer ind i dem.', - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", - "API'en rapporterer ikke bevægelser foretaget af andre mods. TokenMod-træk opfanges automatisk; for andre mods, vælg tokens og klik på Udforsk, eller ring til Hexploration.revealAround(token) fra din egen mod.", + 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter. Med Synslinje slået til afsløres et hexfelt kun, hvis der ikke ligger noget dækket hexfelt imellem.', + 'Afsløringsafstand for hexfelter gemmes på hexfelterne, når de tegnes. Disse hexfelter afsløres kun inden for så mange hexfelters afstand, uanset hvor langt et token kan se. Brug det til bjerge eller skove, der skjuler, hvad der ligger bag dem.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem.', + 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', + 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', ], }, locations: { heading: 'Navngivne Hekser og Steder', points: [ - 'Mark Location forvandler de valgte tokens til skjulte placeringer. Et token, der allerede er under en hex, gemmes med det samme; ellers er det skjult af det næste fyld, der dækker det.', + 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', - 'Navn Hex giver en hex et navn uden token. Navnet vises til GM som en etiket på GM-laget og annonceres, når hexen afsløres.', - 'Announce Discoveries vælger, om alle, kun GM, eller ingen ser meddelelsen. Ping Discoveries flytter også spillernes udsigt til placeringen.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], }, settings: { heading: 'Indstillinger', intro: - "Skift indstillinger med !hexploration set (eller knappen Indstillinger). Hex Layer, Tokens That Reveal og Language kan også indstilles på Mod'ens indstillingsside.", + 'Skift indstillinger med !hexploration set (eller knappen Indstillinger). Lag for hexfelter, Afslørende tokens og Sprog kan også indstilles på modens indstillingsside.', colKey: 'Nøgle', colName: 'Indstilling', colDesc: 'Beskrivelse', @@ -2922,9 +2951,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate og Legacy', points: [ 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', - 'Med Hex Layer sat til Auto, tegnes hexes på forgrundslaget, over tokens, så spillere ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', - 'Jumpgate tegner matematisk regulære hexes, som er en lidt anderledes form end Legacy hexes. Hvis hexene ikke stemmer overens med en sides gitter, skal du sætte et token til et hex-center, vælge det og klikke på Kalibrer. Vælg to tokens i tilstødende hexes i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', - "Når en side eller et spil kopieres, får dets hexes nye id'er. Kør Rescan på siden for at samle dem op igen, sammen med deres navneetiketter og placeringstokens.", + 'Når Lag for hexfelter er sat til Auto, tegnes hexfelter på forgrundslaget over tokens, så spillerne ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexfelter, som har en lidt anden form end Legacy-hexfelter. Hvis hexfelterne ikke flugter med en sides gitter, så fastgør et token til midten af et hexfelt, vælg det, og klik på Kalibrer. Vælg to tokens i nabohexfelter i samme række (Hex V) eller kolonne (Hex H) for også at rette hexfeltstørrelsen.', + 'Når en side eller et spil kopieres, får hexfelterne nye id’er. Kør Scan igen på siden for at finde dem igen sammen med deres navneetiketter og stedtokens.', ], }, upgrading: { @@ -2933,7 +2962,7 @@ const HexplorationMod = (() => { 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', - 'Version 1 lader enhver token, der repræsenterede en karakter, afsløre hexes. Indstil Tokens That Reveal til Character-tokens for at bevare denne adfærd.', + 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], colV1: 'Version 1 kommando', colV2: 'Version 2 kommando', @@ -2941,10 +2970,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Fejlfinding', points: [ - 'Der sker ikke noget, når et token bevæger sig: Kontroller, at tokenet er på tokenlaget og matcher Tokens That Reveal, og at siden har hexes (!hexploration-status).', - 'Hexes er forskudt fra gitteret: Brug Kalibrer, og tjek derefter med et token på et par hexes på tværs af kortet.', - 'Hexes stoppede med at afsløre efter kopiering af en side eller et spil: kør Rescan på siden.', - 'Fill siger, at området ikke har nogen hex-centre: Formen skal indeholde midten af ​​mindst én hex-centre.', + 'Der sker ikke noget, når et token flytter sig: Kontroller, at tokenet ligger på tokenlaget og matcher Afslørende tokens, og at siden har hexfelter (!hexploration status).', + 'Hexfelterne er forskudt i forhold til gitteret: Brug Kalibrer, og kontroller derefter med et token på nogle få hexfelter rundt om på kortet.', + 'Hexfelterne holdt op med at blive afsløret efter kopiering af en side eller et spil: Kør Scan igen på siden.', + 'Fyld siger, at området ikke har nogen hexfeltcentre: Figuren skal indeholde midten af mindst ét hexfelt.', 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', ], }, @@ -2952,7 +2981,7 @@ const HexplorationMod = (() => { heading: 'Sprog', body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', colLanguage: 'Sprog', - colNative: 'Indfødt navn', + colNative: 'Eget navn', colCode: 'Kode', }, credits: { @@ -2968,12 +2997,12 @@ const HexplorationMod = (() => { const TRANSLATION$h = { titles: { - ready: 'Hexploratie is klaar.', - settings: 'Hexploratie-instellingen', + ready: 'Hexploration is klaar.', + settings: 'Hexploration-instellingen', languages: 'Kies een taal', pageSettings: 'Pagina-instellingen: {page}', - status: 'Hverkenningsstatus: {page}', - help: 'Hexploratie-opdrachten', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdrachten', confirm: 'Bevestig alstublieft', }, discovery: { @@ -2984,7 +3013,7 @@ const HexplorationMod = (() => { reveal: 'Onthullen en verbergen', locations: 'Locaties', tools: 'Hulpmiddelen', - layerInUse: 'Er worden nieuwe velden getekend op de {layer}.', + layerInUse: 'Nieuwe zeshoeken worden getekend op de {layer}.', pageSettingsHelp: 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', }, @@ -2993,44 +3022,44 @@ const HexplorationMod = (() => { fillInverse: 'Omgekeerde vulling', undo: 'Vulling ongedaan maken', reveal: 'Onthullen', - conceal: 'Maskeren', - explore: 'Ontdekken', + conceal: 'Verbergen', + explore: 'Verkennen', revealPage: 'Pagina onthullen', resetPage: 'Pagina opnieuw instellen', - mark: 'Markeer locatie', + mark: 'Locatie markeren', unmark: 'Markering opheffen', - name: 'Naam Hex', + name: 'Zeshoek benoemen', settings: 'Instellingen', pageSettings: 'Pagina-instellingen', status: 'Status', rescan: 'Opnieuw scannen', calibrate: 'Kalibreren', calibrateReset: 'Kalibratie opnieuw instellen', - help: 'Hulp', - change: 'Wijziging', + help: 'Help', + change: 'Wijzigen', menu: 'Menu', - clearOverrides: 'Wis overschrijvingen', - confirmReset: 'Ja, verwijder alle vakjes', + clearOverrides: 'Overschrijvingen wissen', + confirmReset: 'Ja, verwijder alle zeshoeken', }, prompts: { name: 'Locatienaam (leeg laten om te wissen)', }, values: { - on: 'Op', + on: 'Aan', off: 'Uit', none: 'Geen', hexLayer: { auto: 'Automatisch (voorgrond indien beschikbaar)', - foreground: 'voorgrond laag', - objects: 'token laag', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', }, revealBy: { - players: 'Spelerfiches', - characters: 'Karakterfiches', + players: 'Spelertokens', + characters: 'Personagetokens', all: 'Alle tokens', }, revealMode: { - clear: 'Duidelijk', + clear: 'Wissen', glimpse: 'Glimp', }, announce: { @@ -3039,13 +3068,13 @@ const HexplorationMod = (() => { off: 'Uit', }, orientation: { - vertical: 'Zeskant (V)', - horizontal: 'Zeskant (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Vullen', fillInverse: 'Omgekeerde vulling', - conceal: 'Maskeren', + conceal: 'Verbergen', }, }, settings: { @@ -3054,8 +3083,8 @@ const HexplorationMod = (() => { desc: "Taal voor menu's, berichten en hand-outs.", }, hexLayer: { - label: 'Hex-laag', - desc: 'Waar nieuwe vakken worden getrokken. Auto probeert de voorgrondlaag (boven tokens) en valt terug naar de tokenlaag als het spel dit niet ondersteunt.', + label: 'Laag voor zeshoeken', + desc: 'Waar nieuwe zeshoeken worden getekend. Automatisch probeert de voorgrondlaag (boven tokens) en valt terug op de tokenlaag als het spel die niet ondersteunt.', }, fillColor: { label: 'Vulkleur', @@ -3066,23 +3095,23 @@ const HexplorationMod = (() => { desc: 'Kleur van de omtrek van nieuwe vakjes.', }, labelColor: { - label: 'Etiketkleur', + label: 'Labelkleur', desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', }, glimpseColor: { - label: 'Glimp kleur', - desc: 'Kleurvakken veranderen naar wanneer er een glimp van wordt opgevangen (Glimpse-onthullingsmodus). Gebruik een doorzichtige rgba()-kleur.', + label: 'Glimpkleur', + desc: 'Kleur die zeshoeken krijgen wanneer er een glimp van wordt opgevangen (onthullingsmodus Glimp). Gebruik een doorzichtige rgba()-kleur.', }, strokeWidth: { label: 'Randbreedte', desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', }, maxDistance: { - label: 'Hex onthullen afstand', + label: 'Onthullingsafstand van zeshoeken', desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', }, revealDistance: { - label: 'Zicht afstand', + label: 'Zichtafstand', desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', }, lineOfSight: { @@ -3090,7 +3119,7 @@ const HexplorationMod = (() => { desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', }, revealPath: { - label: 'Onthul langs het pad', + label: 'Onthullen langs pad', desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { @@ -3099,30 +3128,30 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Onthullingsmodus', - desc: 'Clear verwijdert vakjes die in zicht zijn. Glimpse maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer er een token in komt.', + desc: 'Wissen verwijdert zeshoeken binnen het zicht. Glimp maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer een token ze betreedt.', }, announce: { label: 'Ontdekkingen aankondigen', desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', }, pingDiscoveries: { - label: 'Ping-ontdekkingen', + label: 'Ontdekkingen pingen', desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { - label: 'Verberg afgedekte tokens', + label: 'Bedekte tokens verbergen', desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { engine: 'Game-engine', grid: 'Rooster', - layer: 'Hex-laag', - hexes: 'Hexen', - named: 'Genoemde hexen', - icons: 'Locatiefiches', - glimpsed: 'Glimp van hexen', - pending: 'Locaties die wachten op vulling', + layer: 'Laag voor zeshoeken', + hexes: 'Zeshoeken', + named: 'Benoemde zeshoeken', + icons: 'Locatietokens', + glimpsed: 'Doorzichtige zeshoeken', + pending: 'Locaties die op een vulling wachten', calibrated: 'Gekalibreerd', overrides: 'Pagina-overschrijvingen', undo: 'Ongedaan maken beschikbaar', @@ -3151,11 +3180,11 @@ const HexplorationMod = (() => { 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: - 'Je Hexploration 1.x hex-kaarten zijn geüpgraded. Als dit spel is gekopieerd van een Legacy-spel, voert u Rescan uit op elke hex-kaartpagina.', + 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', pruned: - 'Opgeslagen vakjes die niet meer bestaan ​​en vergeten zijn: {dropped}. Als dit spel of deze pagina is gekopieerd, voert u Opnieuw scannen uit op de pagina om de vakjes weer op te halen.', + 'Opgeslagen zeshoeken die niet meer bestaan en zijn vergeten: {dropped}. Als dit spel of deze pagina is gekopieerd, voer dan Opnieuw scannen uit op de pagina om de zeshoeken weer op te pikken.', readyHint: - 'Typ !hexploration voor het menu, of open het hand-out "Hexploration - Command Deck".', + 'Typ !hexploration voor het menu, of open de hand-out "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -3218,21 +3247,20 @@ const HexplorationMod = (() => { pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', rescan: - 'Bouw de hexadecimale lijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hex-raster uit met een of twee geselecteerde tokens die op de hexadecimale middelpunten zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', - journal: 'Herbouw de Help- en Command Deck-hand-outs.', + journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', help: 'Laat deze lijst zien.', handout: 'Volledige instructies vindt u in de hand-out "{name}".', }, deck: { - subtitle: 'Commandodek', drawDesc: - 'Teken vormen rond een gebied, selecteer ze en vul ze. Met Ongedaan maken wordt de laatste vulling ongedaan gemaakt.', + 'Teken vormen rond een gebied, selecteer ze en vul ze dan. Vulling ongedaan maken draait de laatste vulling terug.', revealDesc: - 'Selecteer vakjes, vormen of tokens om ze weer te onthullen of te bedekken. Ontdek onthullingen rond geselecteerde tokens alsof ze zijn verplaatst.', + 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', toolsDesc: @@ -3253,9 +3281,9 @@ const HexplorationMod = (() => { steps: [ 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', - 'Selecteer de vormen en klik op Invullen in het Command Deck (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', - 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze zijn verborgen onder de vakken en worden aangekondigd wanneer ze worden ontdekt.', - 'Verplaats een spelersfiche. Elke vakje waar hij doorheen gaat, en de vakjes binnen zijn zichtafstand, worden onthuld.', + 'Selecteer de vormen en klik in het Command Deck op Vullen (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze worden verborgen onder de zeshoeken en aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelertoken. Elke zeshoek waar het doorheen gaat, en de zeshoeken binnen zijn Zichtafstand, worden onthuld.', ], }, commands: { @@ -3268,29 +3296,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hoe onthullen werkt', points: [ - 'Alleen tokens op de tokenlaag onthullen hexen. Welke tokens tellen wordt bepaald door Tokens That Reveal: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', - "Een fiche onthult elk vak dat het bestrijkt (grote fiches bestrijken er meerdere) en, als 'Onthullen langs pad' is ingeschakeld, elk vakje op de route waarlangs het is gesleept, inclusief tussenpunten.", - 'Zichtafstand onthult de velden rond elk van deze velden. Als de zichtlijn is ingeschakeld, wordt een vakje alleen onthuld als er geen bedekt vakje tussen ligt.', - 'Hex Reveal Distance wordt op de velden opgeslagen terwijl ze worden getrokken. Deze vakjes worden alleen onthuld vanuit dat aantal vakjes, hoe ver een token ook kan kijken. Gebruik het voor bergen of bossen die verbergen wat erachter ligt.', - 'In de Glimpse-modus worden vakjes die zichtbaar zijn, doorzichtig in plaats van te verdwijnen, en worden ze verwijderd wanneer er een token in komt.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', - 'De API rapporteert geen bewegingen van andere mods. TokenMod-bewegingen worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Ontdekken, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken. Als Zichtlijn aan staat, wordt een zeshoek alleen onthuld als er geen bedekte zeshoek tussen ligt.', + 'Onthullingsafstand van zeshoeken wordt bij het tekenen in de zeshoeken opgeslagen. Die zeshoeken worden alleen onthuld vanaf hooguit zoveel zeshoeken afstand, hoe ver een token ook kan kijken. Gebruik dit voor bergen of bossen die verbergen wat erachter ligt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt.', + 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', + 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', ], }, locations: { heading: 'Genoemde velden en locaties', points: [ - 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een pion dat zich al onder een vakje bevindt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', - 'Naam Hex geeft een hex een naam zonder token. De naam wordt aan de GM getoond als een label op de GM-laag en aangekondigd wanneer de hex wordt onthuld.', - 'Announce Discoveries kiest of iedereen, alleen de GM, of niemand de aankondiging ziet. Ping Discoveries verplaatst ook het zicht van de speler naar de locatie.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], }, settings: { heading: 'Instellingen', intro: - 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Hex Layer, Tokens That Reveal en Language kunnen ook worden ingesteld op de instellingenpagina van de Mod.', + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Laag voor zeshoeken, Tokens die onthullen en Taal kunnen ook worden ingesteld op de instellingenpagina van de mod.', colKey: 'Sleutel', colName: 'Instelling', colDesc: 'Beschrijving', @@ -3300,18 +3328,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate en erfenis', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', - 'Als Hex Layer is ingesteld op Auto, worden hexen op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder zit. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', - 'Jumpgate tekent wiskundig regelmatige vakken, die een iets andere vorm hebben dan Legacy-vakken. Als de vakjes niet op één lijn liggen met het raster van een pagina, plaats dan een token op het midden van een vakje, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende vakjes van dezelfde rij (Hex V) of kolom (Hex H) om ook de hexadecimale grootte te corrigeren.', - "Wanneer een pagina of spel wordt gekopieerd, krijgen de vakjes nieuwe ID's. Voer Rescan uit op de pagina om ze weer op te halen, samen met hun naamlabels en locatietokens.", + 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige zeshoeken, die een iets andere vorm hebben dan Legacy-zeshoeken. Als de zeshoeken niet samenvallen met het raster van een pagina, zet dan een token vast op het midden van een zeshoek, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende zeshoeken van dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', + 'Wanneer een pagina of spel wordt gekopieerd, krijgen de zeshoeken nieuwe ID’s. Voer Opnieuw scannen uit op de pagina om ze weer op te pikken, samen met hun naamlabels en locatietokens.', ], }, upgrading: { heading: 'Upgraden vanaf versie 1', points: [ 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', - 'Bestaande hexadecimale kaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch geüpgraded.', + 'Bestaande hexkaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch bijgewerkt.', 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', - 'Versie 1 liet elk token dat een personage vertegenwoordigde, vakjes onthullen. Stel tokens die onthullen in op karaktertokens om dat gedrag te behouden.', + 'In versie 1 kon elk token dat een personage voorstelde zeshoeken onthullen. Stel Tokens die onthullen in op Personagetokens om dat gedrag te behouden.', ], colV1: 'Versie 1-opdracht', colV2: 'Versie 2-opdracht', @@ -3319,10 +3347,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Problemen oplossen', points: [ - 'Er gebeurt niets wanneer een token beweegt: controleer of het token zich op de tokenlaag bevindt en overeenkomt met Tokens That Reveal, en of de pagina hexes heeft (!hexploration-status).', - 'Hexes zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer vervolgens met een token op een paar velden op de kaart.', - 'Hexes zijn niet meer zichtbaar na het kopiëren van een pagina of game: voer Rescan uit op de pagina.', - 'Fill geeft aan dat het gebied geen middelpunten van zeshoeken heeft: de vorm moet het midden van ten minste één zeshoek bevatten.', + 'Er gebeurt niets wanneer een token beweegt: controleer of het token op de tokenlaag staat en overeenkomt met Tokens die onthullen, en of de pagina zeshoeken heeft (!hexploration status).', + 'Zeshoeken zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer daarna met een token op een paar zeshoeken verspreid over de kaart.', + 'Zeshoeken worden niet meer onthuld na het kopiëren van een pagina of spel: voer Opnieuw scannen uit op de pagina.', + 'Vullen meldt dat het gebied geen middelpunten van zeshoeken bevat: de vorm moet het middelpunt van ten minste één zeshoek bevatten.', 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', ], }, @@ -3330,7 +3358,7 @@ const HexplorationMod = (() => { heading: 'Talen', body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', colLanguage: 'Taal', - colNative: 'Inheemse naam', + colNative: 'Eigen naam', colCode: 'Code', }, credits: { @@ -3599,7 +3627,6 @@ const HexplorationMod = (() => { handout: 'Full instructions are in the "{name}" handout.', }, deck: { - subtitle: 'Command Deck', drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', revealDesc: 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', @@ -3717,48 +3744,48 @@ const HexplorationMod = (() => { const TRANSLATION$g = { titles: { ready: 'Hexploration on valmis.', - settings: 'Tutkimusasetukset', + settings: 'Hexploration-asetukset', languages: 'Valitse kieli', pageSettings: 'Sivuasetukset: {page}', - status: 'Tutkimuksen tila: {page}', - help: 'Hexploration komennot', - confirm: 'Ole hyvä ja vahvista', + status: 'Hexploration-tila: {page}', + help: 'Hexploration-komennot', + confirm: 'Vahvista', }, discovery: { title: 'Sijainti löydetty', }, menu: { - draw: 'Piirrä', + draw: 'Piirto', reveal: 'Paljasta ja piilota', locations: 'Sijainnit', tools: 'Työkalut', - layerInUse: 'Uusia heksalukuja piirretään paikkaan {layer}.', + layerInUse: 'Uudet heksat piirretään tasolle: {layer}.', pageSettingsHelp: 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', }, buttons: { - fill: 'Täyttää', + fill: 'Täytä', fillInverse: 'Käänteinen täyttö', undo: 'Kumoa täyttö', - reveal: 'Paljastaa', - conceal: 'Salata', - explore: 'Tutkia', + reveal: 'Paljasta', + conceal: 'Peitä', + explore: 'Tutki', revealPage: 'Paljasta sivu', resetPage: 'Nollaa sivu', mark: 'Merkitse sijainti', unmark: 'Poista merkintä', - name: 'Nimi Hex', + name: 'Nimeä heksa', settings: 'Asetukset', - pageSettings: 'Sivun asetukset', - status: 'Status', + pageSettings: 'Sivuasetukset', + status: 'Tila', rescan: 'Skannaa uudelleen', - calibrate: 'Kalibroida', + calibrate: 'Kalibroi', calibrateReset: 'Nollaa kalibrointi', - help: 'Auttaa', - change: 'Muuttaa', + help: 'Ohje', + change: 'Muuta', menu: 'Valikko', clearOverrides: 'Tyhjennä ohitukset', - confirmReset: 'Kyllä, poista kaikki heksit', + confirmReset: 'Kyllä, poista kaikki heksat', }, prompts: { name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', @@ -3768,18 +3795,18 @@ const HexplorationMod = (() => { off: 'Pois', none: 'Ei mitään', hexLayer: { - auto: 'Automaattinen (etualalla, jos saatavilla)', - foreground: 'etualan kerros', - objects: 'merkkikerros', + auto: 'Automaattinen (etuala, jos saatavilla)', + foreground: 'etualan taso', + objects: 'merkkitaso', }, revealBy: { - players: 'Pelaajan merkit', - characters: 'Hahmomerkit', + players: 'Pelaajien merkit', + characters: 'Hahmojen merkit', all: 'Kaikki merkit', }, revealMode: { - clear: 'Selkeä', - glimpse: 'Vilkkaus', + clear: 'Poisto', + glimpse: 'Vilkaisu', }, announce: { all: 'Kaikki', @@ -3791,9 +3818,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Täyttää', + fill: 'Täyttö', fillInverse: 'Käänteinen täyttö', - conceal: 'Salata', + conceal: 'Peitto', }, }, settings: { @@ -3802,31 +3829,31 @@ const HexplorationMod = (() => { desc: 'Valikkojen, viestien ja monisteiden kieli.', }, hexLayer: { - label: 'Hex kerros', - desc: 'Jossa piirretään uudet heksat. Auto yrittää etualan kerrosta (merkkien yläpuolella) ja palaa token-kerrokseen, jos peli ei tue sitä.', + label: 'Heksataso', + desc: 'Mihin uudet heksat piirretään. Automaattinen kokeilee etualan tasoa (merkkien yläpuolella) ja käyttää merkkitasoa, jos peli ei tue sitä.', }, fillColor: { label: 'Täyttöväri', desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Reunuksen väri', + label: 'Reunan väri', desc: 'Uusien kuusioiden ääriviivan väri.', }, labelColor: { - label: 'Etiketin väri', + label: 'Nimilappujen väri', desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Heksojen väri muuttuu välähdessään (Glimpse paljastamistila). Käytä läpinäkyvää rgba()-väriä.', + label: 'Vilkaisun väri', + desc: 'Väri, jonka heksat saavat Vilkaisu-tilassa. Käytä läpikuultavaa rgba()-väriä.', }, strokeWidth: { label: 'Reunan leveys', desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', }, maxDistance: { - label: 'Hex paljastaa etäisyyttä', + label: 'Heksojen paljastusetäisyys', desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', }, revealDistance: { @@ -3834,46 +3861,46 @@ const HexplorationMod = (() => { desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', }, lineOfSight: { - label: 'Näkökenttä', + label: 'Näköyhteys', desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', }, revealPath: { - label: 'Paljasta polun varrella', + label: 'Paljasta reitin varrelta', desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { - label: 'Tokenit jotka paljastavat', + label: 'Paljastavat merkit', desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', }, revealMode: { label: 'Paljastustila', - desc: 'Kirkas poistaa kuusiot näkyviltä. Sen sijaan välähdys tekee niistä läpinäkyviä; ne poistetaan, kun niihin tulee merkki.', + desc: 'Poisto poistaa näköetäisyydellä olevat heksat. Vilkaisu tekee niistä sen sijaan läpikuultavia; ne poistetaan, kun merkki astuu niihin.', }, announce: { - label: 'Ilmoita löydökset', + label: 'Ilmoita löydöt', desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', }, pingDiscoveries: { - label: 'Ping löydöt', + label: 'Pingaa löydöt', desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', }, hideCoveredTokens: { - label: 'Piilota peitetyt rahakkeet', + label: 'Piilota peitetyt merkit', desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', }, }, status: { - engine: 'Pelin moottori', + engine: 'Pelimoottori', grid: 'Ruudukko', - layer: 'Hex kerros', - hexes: 'Hexes', + layer: 'Heksataso', + hexes: 'Heksat', named: 'Nimetyt heksat', - icons: 'Sijaintitunnukset', - glimpsed: 'Näytetyt kuusiot', - pending: 'Täyttöä odottavat paikat', + icons: 'Sijaintimerkit', + glimpsed: 'Vilkaistut heksat', + pending: 'Täyttöä odottavat sijainnit', calibrated: 'Kalibroitu', overrides: 'Sivun ohitukset', - undo: 'Kumoa käytettävissä', + undo: 'Kumoaminen käytettävissä', }, messages: { filled: @@ -3899,10 +3926,11 @@ const HexplorationMod = (() => { 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: - 'Hexploration 1.x -heksaanikarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Rescan jokaisella hex-karttasivulla.', + 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', pruned: - 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla uudelleenskannaus, jotta voit hakea sen heksaanit uudelleen.', - readyHint: 'Kirjoita valikkoon !hexploration tai avaa "Hexploation - Command Deck" -moniste.', + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla Skannaa uudelleen, jotta sen heksat löytyvät taas.', + readyHint: + 'Kirjoita !hexploration avataksesi valikon, tai avaa moniste "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -3930,7 +3958,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', - notHex: 'Aseta sivun ruudukoksi heksadesimaali (V) tai heksa (H) Sivuasetuksissa.', + notHex: 'Aseta sivun ruudukoksi Hex (V) tai Hex (H) sivun asetuksista.', noPolygons: 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', @@ -3940,7 +3968,7 @@ const HexplorationMod = (() => { unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: - 'Napsauta merkki heksan keskelle ja valitse se. Valitse toinen saman rivin (Hex V) tai sarakkeen (Hex H) viereiseen heksaaniin napsautettu merkki ja korjaa myös heksadesimaalikoko.', + 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', @@ -3963,23 +3991,22 @@ const HexplorationMod = (() => { pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: - 'Rakenna sivun heksadesimaalilista uudelleen esimerkiksi sivun tai pelin kopioimisen jälkeen.', + 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', - journal: 'Rakenna Ohje- ja komentokansion monisteet uudelleen.', + journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', help: 'Näytä tämä luettelo.', handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', }, deck: { - subtitle: 'Komentolevy', drawDesc: - 'Piirrä muotoja alueen ympärille, valitse ne ja täytä. Kumoa kääntää viimeisen täytön.', + 'Piirrä muotoja alueen ympärille, valitse ne ja napsauta Täytä. Kumoa täyttö peruu viimeisimmän täytön.', revealDesc: - 'Valitse kuusiot, muodot tai merkit paljastaaksesi tai peittääksesi ne uudelleen. Tutki valittujen tokenien ympärillä olevia paljastuksia ikään kuin ne olisivat siirtyneet.', + 'Valitse heksoja, muotoja tai merkkejä paljastaaksesi ne tai peittääksesi ne uudelleen. Tutki paljastaa valittujen merkkien ympäristön ikään kuin ne olisivat juuri siirtyneet sinne.', locationsDesc: - 'Valitse tunnukset piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksadesimaalit tai merkit nimetäksesi heksan.', + 'Valitse merkit piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksoja tai merkkejä nimetäksesi heksan.', toolsDesc: 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', footer: 'Katso täydelliset ohjeet monisteesta "{help}".', @@ -3998,9 +4025,9 @@ const HexplorationMod = (() => { steps: [ 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', - 'Valitse muodot ja napsauta Täytä komentopakissa (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', - 'Valinnainen: ennen täyttämistä valitse tunnukset tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan kuusioiden alle ja ilmoitetaan, kun ne löydetään.', - 'Siirrä pelaajatunnusta. Jokainen heksa, jonka se kulkee, ja sen näköetäisyyden sisällä olevat heksat paljastetaan.', + 'Valitse muodot ja napsauta Command Deck -monisteessa Täytä (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: valitse ennen täyttöä merkit tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan heksojen alle, ja niistä ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajan merkkiä. Jokainen heksa, jonka läpi se kulkee, ja sen Näköetäisyyden sisällä olevat heksat paljastetaan.', ], }, commands: { @@ -4013,29 +4040,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Kuinka paljastaminen toimii', points: [ - 'Vain merkkikerroksen merkit paljastavat heksalukuja. Tokens That Reveal -pelimerkkien määrän määrittää oletusarvoisesti pelaajamerkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', - 'Token paljastaa jokaisen heksan, jonka se peittää (suuret merkit kattavat useita) ja, kun Reveal Along Path on päällä, jokaisen heksan reitillä, jota se vedettiin, mukaan lukien reittipisteet.', - 'Näköetäisyys paljastaa kunkin heksan ympärillä olevat heksat. Kun Line of Sight on päällä, kuusio tulee näkyviin vain, jos välissä ei ole peitettyä kuusiota.', - 'Hex Reveal Distance tallennetaan heksaan kun ne piirretään. Nuo heksat paljastuvat vain sisältäpäin, että monet heksat, kuinka kauas merkki näkee. Käytä sitä vuorille tai metsille, jotka piilottavat sen, mikä on takanaan.', - 'Glimpse-tilassa näkyvissä olevista kuusioista tulee läpinäkyviä sen sijaan, että ne katoavat, ja ne poistetaan, kun niihin tulee merkki.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', - 'API ei raportoi muiden modien tekemiä liikkeitä. TokenMod-liikkeet poimitaan automaattisesti; muita modeja varten valitse tunnukset ja napsauta Explore tai soita Hexploration.revealAround(token) omasta modistasi.', + 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat. Kun Näköyhteys on päällä, heksa paljastetaan vain, jos välissä ei ole peitettyä heksaa.', + 'Heksojen paljastusetäisyys tallennetaan heksoihin niitä piirrettäessä. Nämä heksat paljastuvat vain enintään näin monen heksan päästä, vaikka merkki näkisi kauemmas. Käytä sitä vuorille tai metsille, jotka kätkevät taakseen jäävän.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin.', + 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', + 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', ], }, locations: { heading: 'Nimetty Heksit ja sijainnit', points: [ - 'Mark Location muuttaa valitut tunnukset piilotetuiksi sijainneiksi. Heksan alla oleva merkki piilotetaan heti; muuten se piilotetaan seuraavalla sen peittävällä täytteellä.', + 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', - 'Name Hex antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle etikettinä GM-tasolla ja ilmoitetaan, kun hex paljastetaan.', - 'Announce Discoveries valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Ping Discoveries siirtää myös pelaajien näkymän paikkaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], }, settings: { heading: 'Asetukset', intro: - 'Muuta asetuksia !hexploration setillä (tai Asetukset-painikkeella). Hex Layer, Tokens That Reveal ja Language voidaan asettaa myös Modin asetussivulla.', + 'Muuta asetuksia komennolla !hexploration set (tai Asetukset-painikkeella). Heksatason, Paljastavat merkit ja Kielen voi asettaa myös modin asetussivulla.', colKey: 'Avain', colName: 'Asetus', colDesc: 'Kuvaus', @@ -4045,18 +4072,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate ja Legacy', points: [ 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', - 'Kun Hex Layer -asetuksena on Auto, heksat piirretään etualan tasolle, merkkien yläpuolelle, jotta pelaajat eivät näe, mitä alla on. Jos etualan kerrosta ei ole saatavilla, sen sijaan käytetään merkkikerrosta.', - 'Jumpgate piirtää matemaattisesti säännölliset heksat, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksaat eivät ole linjassa sivun ruudukon kanssa, kiinnitä merkki heksaanien keskipisteeseen, valitse se ja napsauta Kalibroi. Valitse kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) viereisistä heksadesistä korjataksesi myös heksadesiaalisen koon.', - 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnukset. Suorita uudelleenskannaus sivulla hakeaksesi ne uudelleen sekä niiden nimilaput ja sijaintitunnukset.', + 'Kun Heksataso on Automaattinen, heksat piirretään etualan tasolle merkkien yläpuolelle, joten pelaajat eivät näe, mitä alla on. Jos etualan taso ei ole käytettävissä, käytetään merkkitasoa.', + 'Jumpgate piirtää matemaattisesti säännöllisiä heksoja, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksat eivät osu sivun ruudukkoon, kiinnitä merkki heksan keskipisteeseen, valitse se ja napsauta Kalibroi. Korjaa myös heksan koko valitsemalla kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) vierekkäisistä heksoista.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnisteet. Suorita sivulla Skannaa uudelleen, jotta ne löytyvät taas nimilappuineen ja sijaintimerkkeineen.', ], }, upgrading: { heading: 'Päivitys versiosta 1', points: [ 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', - 'Nykyiset heksadesimaalikartat, nimet, sijaintitunnukset ja asetukset päivitetään automaattisesti ensimmäisen käynnistyksen yhteydessä.', + 'Nykyiset heksakartat, nimet, sijaintimerkit ja asetukset päivitetään automaattisesti ensimmäisellä käynnistyksellä.', 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', - 'Versio 1 antaa minkä tahansa merkkiä edustavan tunnuksen paljastaa heksalukuja. Aseta Paljastavat Tokenit Hahmotokeneiksi säilyttääksesi tämän käytöksen.', + 'Versiossa 1 mikä tahansa hahmoa edustava merkki paljasti heksoja. Säilytä tämä toiminta asettamalla Paljastavat merkit arvoon Hahmojen merkit.', ], colV1: 'Version 1 komento', colV2: 'Version 2 komento', @@ -4064,23 +4091,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Vianetsintä', points: [ - 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkikerroksella ja vastaa Tokens That Reveal -merkkejä ja että sivulla on heksioita (!hexploration status).', - 'Heksat ovat poissa ruudukosta: käytä Kalibrointia ja tarkista sitten tunnuksella muutamalla heksalla kartalla.', - 'Heksit lakkasivat paljastamasta sivun tai pelin kopioimisen jälkeen: suorita sivulla Rescan.', - 'Fill sanoo, että alueella ei ole heksadesimaalikeskuksia: muodon on sisällettävä vähintään yhden hex-keskipiste.', + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkitasolla ja vastaa Paljastavat merkit -asetusta ja että sivulla on heksoja (!hexploration status).', + 'Heksat ovat siirtyneet ruudukosta: käytä Kalibroi-toimintoa ja tarkista sitten merkillä muutama heksa eri puolilta karttaa.', + 'Heksat lakkasivat paljastumasta sivun tai pelin kopioinnin jälkeen: suorita sivulla Skannaa uudelleen.', + 'Täytä ilmoittaa, ettei alueella ole heksojen keskipisteitä: muodon on sisällettävä vähintään yhden heksan keskipiste.', 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', ], }, languages: { heading: 'Kielet', - body: 'Valitse kieli !hexploration set -kielellä. Käytettävissä olevat kielet:', + body: 'Valitse kieli komennolla !hexploration set language. Käytettävissä olevat kielet:', colLanguage: 'Kieli', - colNative: 'Alkuperäinen nimi', + colNative: 'Oma nimi', colCode: 'Koodi', }, credits: { heading: 'Krediitit', - original: 'Alkuperäinen mod', + original: 'Alkuperäisen modin tekijä', maintainer: 'Versio 2 ylläpitäjä', marketplace: 'Adan taidepaketit Roll20 Marketplacessa', support: @@ -4091,12 +4118,12 @@ const HexplorationMod = (() => { const TRANSLATION$f = { titles: { - ready: "L'exploration est prête.", - settings: "Paramètres d'exploration", + ready: 'Hexploration est prêt.', + settings: "Paramètres d'Hexploration", languages: 'Choisissez une langue', pageSettings: 'Paramètres de la page : {page}', - status: "Statut d'exploration : {page}", - help: "Commandes d'exploration", + status: "État d'Hexploration : {page}", + help: "Commandes d'Hexploration", confirm: 'Veuillez confirmer', }, discovery: { @@ -4119,18 +4146,18 @@ const HexplorationMod = (() => { conceal: 'Cacher', explore: 'Explorer', revealPage: 'Révéler la page', - resetPage: 'Page de réinitialisation', + resetPage: 'Réinitialiser la page', mark: "Marquer l'emplacement", - unmark: 'Décocher', - name: 'Nom Hex', + unmark: 'Démarquer', + name: "Nommer l'hexagone", settings: 'Paramètres', - pageSettings: 'Paramètres des pages', + pageSettings: 'Paramètres de la page', status: 'Statut', rescan: 'Nouvelle analyse', - calibrate: 'Étalonner', - calibrateReset: "Réinitialiser l'étalonnage", + calibrate: 'Calibrer', + calibrateReset: 'Réinitialiser le calibrage', help: 'Aide', - change: 'Changement', + change: 'Modifier', menu: 'Menu', clearOverrides: 'Effacer les remplacements', confirmReset: 'Oui, supprimer tous les hexagones', @@ -4139,13 +4166,13 @@ const HexplorationMod = (() => { name: 'Nom du lieu (laissez vide pour effacer)', }, values: { - on: 'Sur', + on: 'Activé', off: 'Désactivé', none: 'Aucun', hexLayer: { auto: 'Auto (premier plan si disponible)', foreground: 'calque de premier plan', - objects: 'couche de jetons', + objects: 'calque des jetons', }, revealBy: { players: 'Jetons de joueur', @@ -4153,12 +4180,12 @@ const HexplorationMod = (() => { all: 'Tous les jetons', }, revealMode: { - clear: 'Clair', + clear: 'Effacer', glimpse: 'Aperçu', }, announce: { all: 'Tout le monde', - gm: 'GM uniquement', + gm: 'MJ uniquement', off: 'Désactivé', }, orientation: { @@ -4177,7 +4204,7 @@ const HexplorationMod = (() => { desc: 'Langue des menus, des messages et des documents.', }, hexLayer: { - label: 'Couche hexagonale', + label: 'Calque des hexagones', desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', }, fillColor: { @@ -4193,15 +4220,15 @@ const HexplorationMod = (() => { desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', }, glimpseColor: { - label: 'Aperçu de la couleur', - desc: "Les hexagones de couleur changent lorsqu'ils sont aperçus (mode de révélation d'aperçu). Utilisez une couleur rgba() transparente.", + label: "Couleur d'aperçu", + desc: 'Couleur que prennent les hexagones aperçus (mode de révélation Aperçu). Utilisez une couleur rgba() transparente.', }, strokeWidth: { label: 'Largeur de la bordure', desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', }, maxDistance: { - label: 'Distance de révélation hexagonale', + label: 'Distance de révélation des hexagones', desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", }, revealDistance: { @@ -4217,19 +4244,19 @@ const HexplorationMod = (() => { desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { - label: 'Des jetons qui révèlent', + label: 'Jetons révélateurs', desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", }, revealMode: { - label: 'Mode Révéler', - desc: "Effacer supprime les hexagones en vue. Un aperçu les rend transparents à la place ; ils sont supprimés lorsqu'un jeton y pénètre.", + label: 'Mode de révélation', + desc: "Effacer supprime les hexagones à portée de vue. Aperçu les rend plutôt transparents ; ils sont supprimés lorsqu'un jeton y entre.", }, announce: { - label: 'Annoncer des découvertes', + label: 'Annoncer les découvertes', desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", }, pingDiscoveries: { - label: 'Découvertes Ping', + label: 'Pinger les découvertes', desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", }, hideCoveredTokens: { @@ -4240,19 +4267,19 @@ const HexplorationMod = (() => { status: { engine: 'Moteur de jeu', grid: 'Grille', - layer: 'Couche hexagonale', + layer: 'Calque des hexagones', hexes: 'Hexagones', - named: 'Hexs nommés', - icons: 'Jetons de localisation', - glimpsed: 'Hexs aperçus', - pending: "Emplacements en attente d'un remplissage", + named: 'Hexagones nommés', + icons: "Jetons d'emplacement", + glimpsed: 'Hexagones aperçus', + pending: 'Emplacements en attente de remplissage', calibrated: 'Calibré', overrides: 'Remplacements de page', - undo: 'Annuler disponible', + undo: 'Annulation disponible', }, messages: { filled: - 'Remplissez terminé. Hexs tirés : {created}. Restylé : {restyled}. Emplacements masqués : {icons}.', + 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', revealed: 'Hexs révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: @@ -4278,7 +4305,7 @@ const HexplorationMod = (() => { pruned: "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: - 'Tapez !hexploration pour le menu ou ouvrez le document « Hexploration - Command Deck ».', + 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -4349,16 +4376,15 @@ const HexplorationMod = (() => { 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', status: 'Montre ce que Hexploration sait de la page actuelle.', - journal: "Reconstruisez les documents d'aide et de commande.", + journal: 'Reconstruisez les documents Help et Command Deck.', help: 'Montrez cette liste.', handout: 'Les instructions complètes se trouvent dans le document « {name} ».', }, deck: { - subtitle: 'Pont de commandement', drawDesc: - "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez-les. Annuler annule le dernier remplissage.", + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez. Annuler le remplissage annule le dernier remplissage.", revealDesc: - "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir à nouveau. L'exploration révèle les jetons sélectionnés comme s'ils avaient bougé.", + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir. Explorer révèle les alentours des jetons sélectionnés comme s'ils venaient de s'y déplacer.", locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: @@ -4379,7 +4405,7 @@ const HexplorationMod = (() => { steps: [ 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', - 'Sélectionnez les formes et cliquez sur Remplir dans le jeu de commandes (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", ], @@ -4394,29 +4420,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Comment fonctionne la révélation', points: [ - 'Seuls les jetons sur la couche de jetons révèlent des hexagones. Le nombre de jetons est défini par Tokens That Reveal : les jetons de joueur par défaut, afin que le MJ puisse déplacer les monstres sans découvrir la carte.', + 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", - 'Sight Distance révèle les hexs autour de chacun de ces hexs. Avec la Ligne de Vue activée, un hex n’est révélé que si aucun hex couvert ne se trouve entre les deux.', - "La distance de révélation des hexs est stockée sur les hexs au fur et à mesure qu'ils sont dessinés. Ces hexagones ne sont révélés qu’à partir d’un certain nombre d’hexagones, quelle que soit la distance que peut voir un jeton. Utilisez-le pour les montagnes ou les forêts qui cachent ce qui se trouve derrière elles.", + "La distance de vue révèle les hexagones autour de chacun de ces hexagones. Avec Ligne de vue activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre les deux.", + "La distance de révélation des hexagones est enregistrée sur les hexagones au moment où ils sont dessinés. Ces hexagones ne sont révélés que depuis ce nombre d'hexagones au plus, quelle que soit la distance à laquelle un jeton peut voir. Utilisez-la pour des montagnes ou des forêts qui cachent ce qui se trouve derrière elles.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", - "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", ], }, locations: { heading: 'Hexs et emplacements nommés', points: [ - 'Mark Location transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est immédiatement caché ; sinon, il est masqué par le prochain remplissage qui le recouvre.', + "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", - "Name Hex donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur la couche GM et annoncé lorsque l'hex est révélé.", - "Annoncer les découvertes choisit si tout le monde, uniquement le MJ ou personne ne voit l'annonce. Ping Discoveries déplace également la vue des joueurs vers l’emplacement.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], }, settings: { heading: 'Paramètres', intro: - 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). La couche hexadécimale, les jetons révélés et la langue peuvent également être définis sur la page des paramètres du mod.', + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). Calque des hexagones, Jetons révélateurs et Langue peuvent aussi être définis sur la page de paramètres du mod.', colKey: 'Clé', colName: 'Paramètre', colDesc: 'Description', @@ -4426,7 +4452,7 @@ const HexplorationMod = (() => { heading: 'Jumpgate et héritage', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", - "Avec Hex Layer réglé sur Auto, les hexagones sont dessinés sur la couche de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si la couche de premier plan n'est pas disponible, la couche de jetons est utilisée à la place.", + "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", ], @@ -4437,7 +4463,7 @@ const HexplorationMod = (() => { "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', - "La version 1 permettait à n'importe quel jeton représentant un personnage de révéler des hexagones. Définissez les jetons qui révèlent des jetons de personnage pour conserver ce comportement.", + 'La version 1 permettait à tout jeton représentant un personnage de révéler des hexagones. Réglez Jetons révélateurs sur Jetons de personnage pour conserver ce comportement.', ], colV1: 'Commande version 1', colV2: 'Commande version 2', @@ -4445,10 +4471,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Dépannage', points: [ - "Rien ne se passe lorsqu'un jeton bouge : vérifiez que le jeton est sur la couche de jetons et correspond aux jetons qui révèlent, et que la page a des hexagones (!hétat d'exploration).", + 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", - "Fill indique que la zone n'a pas de centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], }, @@ -4456,7 +4482,7 @@ const HexplorationMod = (() => { heading: 'Langues', body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', colLanguage: 'Langue', - colNative: 'Nom natif', + colNative: "Nom d'origine", colCode: 'Code', }, credits: { @@ -4472,49 +4498,49 @@ const HexplorationMod = (() => { const TRANSLATION$e = { titles: { - ready: 'Hexploration ist fertig.', - settings: 'Erkundungseinstellungen', - languages: 'Wählen Sie eine Sprache', + ready: 'Hexploration ist bereit.', + settings: 'Hexploration-Einstellungen', + languages: 'Sprache wählen', pageSettings: 'Seiteneinstellungen: {page}', - status: 'Erkundungsstatus: {page}', - help: 'Erkundungsbefehle', + status: 'Hexploration-Status: {page}', + help: 'Hexploration-Befehle', confirm: 'Bitte bestätigen', }, discovery: { title: 'Standort entdeckt', }, menu: { - draw: 'Ziehen', - reveal: 'Enthüllen und Verstecken', + draw: 'Zeichnen', + reveal: 'Aufdecken und Verdecken', locations: 'Standorte', tools: 'Werkzeuge', - layerInUse: 'Auf dem {layer} werden neue Hexfelder gezeichnet.', + layerInUse: 'Neue Hexfelder werden auf der {layer} gezeichnet.', pageSettingsHelp: 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', }, buttons: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', undo: 'Füllung rückgängig machen', reveal: 'Aufdecken', conceal: 'Verbergen', explore: 'Erkunden', - revealPage: 'Seite enthüllen', + revealPage: 'Seite aufdecken', resetPage: 'Seite zurücksetzen', mark: 'Standort markieren', unmark: 'Markierung aufheben', - name: 'Name Hex', + name: 'Hexfeld benennen', settings: 'Einstellungen', pageSettings: 'Seiteneinstellungen', status: 'Status', rescan: 'Erneut scannen', calibrate: 'Kalibrieren', calibrateReset: 'Kalibrierung zurücksetzen', - help: 'Helfen', + help: 'Hilfe', change: 'Ändern', - menu: 'Speisekarte', + menu: 'Menü', clearOverrides: 'Überschreibungen löschen', - confirmReset: 'Ja, alle Verhexungen entfernen', + confirmReset: 'Ja, alle Hexfelder entfernen', }, prompts: { name: 'Standortname (zum Löschen leer lassen)', @@ -4522,11 +4548,11 @@ const HexplorationMod = (() => { values: { on: 'An', off: 'Aus', - none: 'Keiner', + none: 'Keine', hexLayer: { auto: 'Auto (Vordergrund, falls verfügbar)', foreground: 'Vordergrundebene', - objects: 'Token-Schicht', + objects: 'Token-Ebene', }, revealBy: { players: 'Spielertoken', @@ -4534,8 +4560,8 @@ const HexplorationMod = (() => { all: 'Alle Token', }, revealMode: { - clear: 'Klar', - glimpse: 'Blick', + clear: 'Entfernen', + glimpse: 'Durchsicht', }, announce: { all: 'Alle', @@ -4544,11 +4570,11 @@ const HexplorationMod = (() => { }, orientation: { vertical: 'Hex (V)', - horizontal: 'Sechskant (H)', + horizontal: 'Hex (H)', }, fillKind: { fill: 'Füllen', - fillInverse: 'Inverse Füllung', + fillInverse: 'Umgekehrt füllen', conceal: 'Verbergen', }, }, @@ -4558,8 +4584,8 @@ const HexplorationMod = (() => { desc: 'Sprache für Menüs, Nachrichten und Handouts.', }, hexLayer: { - label: 'Hex-Ebene', - desc: 'Wo neue Hexfelder gezeichnet werden. Automatisch versucht es mit der Vordergrundebene (über den Token) und greift auf die Tokenebene zurück, wenn das Spiel dies nicht unterstützt.', + label: 'Hexfeld-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. „Auto“ versucht es mit der Vordergrundebene (über den Token) und weicht auf die Token-Ebene aus, wenn das Spiel sie nicht unterstützt.', }, fillColor: { label: 'Füllfarbe', @@ -4570,19 +4596,19 @@ const HexplorationMod = (() => { desc: 'Farbe der Umrisse neuer Hexfelder.', }, labelColor: { - label: 'Etikettenfarbe', + label: 'Beschriftungsfarbe', desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', }, glimpseColor: { - label: 'Einblick in die Farbe', - desc: 'Die Farbverhexungen ändern sich, wenn man sie erblickt (Einblick-Enthüllungsmodus). Verwenden Sie eine durchsichtige rgba()-Farbe.', + label: 'Durchsicht-Farbe', + desc: 'Farbe, die Hexfelder annehmen, wenn sie durchsichtig werden (Aufdeckmodus „Durchsicht“). Verwenden Sie eine durchsichtige rgba()-Farbe.', }, strokeWidth: { label: 'Randbreite', desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', }, maxDistance: { - label: 'Hex-Enthüllungsabstand', + label: 'Aufdeckungsdistanz für Hexfelder', desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', }, revealDistance: { @@ -4594,23 +4620,23 @@ const HexplorationMod = (() => { desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', }, revealPath: { - label: 'Auf dem Weg enthüllen', + label: 'Entlang des Wegs aufdecken', desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', }, revealBy: { - label: 'Zeichen, die offenbaren', + label: 'Aufdeckende Token', desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', }, revealMode: { - label: 'Reveal-Modus', - desc: 'Clear entfernt Verhexungen in Sichtweite. Glimpse macht sie stattdessen durchsichtig; Sie werden entfernt, wenn ein Token in sie eindringt.', + label: 'Aufdeckmodus', + desc: '„Entfernen“ entfernt Hexfelder in Sichtweite. „Durchsicht“ macht sie stattdessen durchsichtig; sie werden entfernt, sobald ein Token sie betritt.', }, announce: { - label: 'Kündigen Sie Entdeckungen an', + label: 'Entdeckungen ankündigen', desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', }, pingDiscoveries: { - label: 'Ping-Entdeckungen', + label: 'Entdeckungen anpingen', desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', }, hideCoveredTokens: { @@ -4620,16 +4646,16 @@ const HexplorationMod = (() => { }, status: { engine: 'Spiel-Engine', - grid: 'Netz', - layer: 'Hex-Schicht', - hexes: 'Verhexungen', - named: 'Benannte Verhexungen', - icons: 'Standorttoken', - glimpsed: 'Gesehene Verhexungen', - pending: 'Orte, die auf eine Besetzung warten', + grid: 'Raster', + layer: 'Hexfeld-Ebene', + hexes: 'Hexfelder', + named: 'Benannte Hexfelder', + icons: 'Standort-Token', + glimpsed: 'Durchsichtige Hexfelder', + pending: 'Standorte, die auf eine Füllung warten', calibrated: 'Kalibriert', overrides: 'Seitenüberschreibungen', - undo: 'Rückgängig machen verfügbar', + undo: 'Rückgängig möglich', }, messages: { filled: @@ -4655,11 +4681,11 @@ const HexplorationMod = (() => { 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: - 'Ihre Hexploration 1.x-Hex-Karten wurden aktualisiert. Wenn dieses Spiel von einem Legacy-Spiel kopiert wurde, führen Sie Rescan auf jeder Hex-Kartenseite aus.', + 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', pruned: - 'Gespeicherte Hexen, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie „Rescan“ auf der Seite aus, um die Verhexungen wieder aufzunehmen.', + 'Gespeicherte Hexfelder, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie auf der Seite „Erneut scannen“ aus, um ihre Hexfelder wieder zu erfassen.', readyHint: - 'Geben Sie !hexploration für das Menü ein oder öffnen Sie das Handout „Hexploration – Command Deck“.', + 'Geben Sie !hexploration ein, um das Menü aufzurufen, oder öffnen Sie das Handout "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -4736,16 +4762,15 @@ const HexplorationMod = (() => { 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', - journal: 'Erstellen Sie die Handzettel für das Hilfe- und Befehlsdeck neu.', + journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', help: 'Diese Liste anzeigen.', handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', }, deck: { - subtitle: 'Kommandodeck', drawDesc: - 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie aus. Mit „Rückgängig“ wird die letzte Füllung rückgängig gemacht.', + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie dann. „Füllung rückgängig machen“ macht die letzte Füllung rückgängig.', revealDesc: - 'Wählen Sie Verhexungen, Formen oder Spielsteine ​​aus, um sie wieder freizulegen oder zu verdecken. Beim Erkunden wird die Umgebung ausgewählter Spielsteine ​​angezeigt, als ob sie sich bewegt hätten.', + 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: @@ -4766,9 +4791,9 @@ const HexplorationMod = (() => { steps: [ 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', - 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf „Fill“ (oder geben Sie „!hexploration fill“ ein). Die Formen werden durch Sechsecke ersetzt.', - 'Optional: Wählen Sie vor dem Ausfüllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie sind unter den Verhexungen versteckt und werden bekannt gegeben, wenn sie entdeckt werden.', - 'Verschiebe einen Spielermarker. Jedes Hexfeld, das es durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf Füllen (oder geben Sie !hexploration fill ein). Die Formen werden durch Hexfelder ersetzt.', + 'Optional: Wählen Sie vor dem Füllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie werden unter den Hexfeldern versteckt und bei ihrer Entdeckung angekündigt.', + 'Bewegen Sie einen Spieler-Token. Jedes Hexfeld, das er durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', ], }, commands: { @@ -4781,29 +4806,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Wie Offenlegung funktioniert', points: [ - 'Nur Spielsteine ​​auf der Spielsteinebene zeigen Hexfelder an. Die Anzahl der Spielsteine ​​wird standardmäßig durch „Tokens That Reveal: Player Tokens“ festgelegt, sodass der Spielleiter Monster bewegen kann, ohne die Karte aufzudecken.', - 'Ein Spielstein deckt jedes Hexfeld auf, das er abdeckt (große Spielsteine ​​decken mehrere ab) und, wenn „Entlang des Pfads anzeigen“ aktiviert ist, jedes Hexfeld auf der Route, entlang derer es gezogen wurde, einschließlich Wegpunkten.', - 'Die Sichtweite zeigt die Hexfelder um jedes dieser Hexfelder an. Bei aktivierter Sichtlinie wird ein Hexfeld nur dann aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', - 'Der Hex-Enthüllungsabstand wird auf den Hexfeldern gespeichert, während diese gezeichnet werden. Diese Verhexungen werden nur innerhalb von so vielen Verhexungen aufgedeckt, unabhängig davon, wie weit ein Spielstein reichen kann. Verwenden Sie es für Berge oder Wälder, die verbergen, was sich dahinter befindet.', - 'Im Glimpse-Modus werden Hexfelder in Sichtweite durchsichtig, anstatt zu verschwinden, und werden entfernt, wenn ein Token sie betritt.', - 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nur aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Zeichnen in den Hexfeldern gespeichert. Diese Hexfelder werden nur aus höchstens so vielen Hexfeldern Entfernung aufgedeckt, egal wie weit ein Token sehen kann. Nutzen Sie dies für Berge oder Wälder, die verbergen, was dahinter liegt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt.', + 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', ], }, locations: { heading: 'Benannte Hexfelder und Orte', points: [ - '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Orte. Ein Spielstein, der sich bereits unter einem Feld befindet, wird sofort ausgeblendet; andernfalls wird es von der nächsten Füllung verdeckt, die es bedeckt.', + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', - 'Name Hex gibt einem Hex einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und bekannt gegeben, wenn das Hex aufgedeckt wird.', - '„Entdeckungen ankündigen“ legt fest, ob jeder, nur der GM oder niemand die Ankündigung sieht. Ping Discoveries verschiebt auch die Sicht der Spieler auf den Ort.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', ], }, settings: { heading: 'Einstellungen', intro: - 'Ändern Sie die Einstellungen mit !hexploration set (oder der Schaltfläche „Einstellungen“). Hex Layer, Tokens That Reveal und Sprache können ebenfalls auf der Einstellungsseite des Mods eingestellt werden.', + 'Ändern Sie Einstellungen mit !hexploration set (oder über die Schaltfläche „Einstellungen“). „Hexfeld-Ebene“, „Aufdeckende Token“ und „Sprache“ lassen sich auch auf der Einstellungsseite des Mods festlegen.', colKey: 'Schlüssel', colName: 'Einstellung', colDesc: 'Beschreibung', @@ -4813,9 +4838,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate und Legacy', points: [ 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', - 'Wenn die Hex-Ebene auf „Auto“ eingestellt ist, werden Hexfelder auf der Vordergrundebene über den Spielsteinen gezeichnet, sodass Spieler nicht sehen können, was sich darunter befindet. Wenn die Vordergrundebene nicht verfügbar ist, wird stattdessen die Tokenebene verwendet.', - 'Jumpgate zeichnet mathematisch regelmäßige Verhexungen, die eine etwas andere Form als Legacy-Verhexungen haben. Wenn die Sechsecke nicht mit dem Raster einer Seite übereinstimmen, rasten Sie ein Token in der Mitte eines Sechsecks ein, wählen Sie es aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Spielsteine ​​in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', - 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie „Rescan“ auf der Seite aus, um sie zusammen mit ihren Namensschildern und Standorttokens wieder aufzunehmen.', + 'Ist „Hexfeld-Ebene“ auf „Auto“ gesetzt, werden Hexfelder auf der Vordergrundebene über den Token gezeichnet, sodass Spieler nicht sehen können, was darunter liegt. Ist die Vordergrundebene nicht verfügbar, wird stattdessen die Token-Ebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Hexfelder, deren Form leicht von Legacy-Hexfeldern abweicht. Wenn die Hexfelder nicht mit dem Raster einer Seite übereinstimmen, rasten Sie einen Token in der Mitte eines Hexfelds ein, wählen Sie ihn aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Token in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie auf der Seite „Erneut scannen“ aus, um sie zusammen mit ihren Namensbeschriftungen und Standort-Token wieder zu erfassen.', ], }, upgrading: { @@ -4824,7 +4849,7 @@ const HexplorationMod = (() => { 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', - 'In Version 1 konnte jeder Spielstein, der einen Charakter darstellte, Verhexungen aufdecken. Setzen Sie Offenbar-Token auf Charakter-Token, um dieses Verhalten beizubehalten.', + 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], colV1: 'Befehl der Version 1', colV2: 'Befehl der Version 2', @@ -4832,10 +4857,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Fehlerbehebung', points: [ - 'Es passiert nichts, wenn sich ein Token bewegt: Überprüfen Sie, ob sich der Token auf der Token-Ebene befindet und mit Tokens That Reveal übereinstimmt und ob die Seite Hexfelder hat (!hexploration-Status).', - 'Hexfelder sind vom Raster versetzt: Verwenden Sie „Kalibrieren“ und überprüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', - 'Verhexungen werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr angezeigt: Führen Sie „Rescan“ auf der Seite aus.', - 'Fill besagt, dass der Bereich keine Hex-Zentren hat: Die Form muss den Mittelpunkt von mindestens einem Hex enthalten.', + 'Nichts passiert, wenn sich ein Token bewegt: Prüfen Sie, ob der Token auf der Token-Ebene liegt und zu „Aufdeckende Token“ passt und ob die Seite Hexfelder hat (!hexploration status).', + 'Hexfelder sind gegenüber dem Raster versetzt: Verwenden Sie „Kalibrieren“ und prüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Hexfelder werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr aufgedeckt: Führen Sie auf der Seite „Erneut scannen“ aus.', + '„Füllen“ meldet, dass der Bereich keine Hexfeld-Mittelpunkte enthält: Die Form muss den Mittelpunkt von mindestens einem Hexfeld enthalten.', 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', ], }, @@ -4843,7 +4868,7 @@ const HexplorationMod = (() => { heading: 'Sprachen', body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', colLanguage: 'Sprache', - colNative: 'Einheimischer Name', + colNative: 'Eigenbezeichnung', colCode: 'Code', }, credits: { @@ -4859,19 +4884,19 @@ const HexplorationMod = (() => { const TRANSLATION$d = { titles: { - ready: 'Η εξερεύνηση είναι έτοιμη.', - settings: 'Ρυθμίσεις εξερεύνησης', + ready: 'Το Hexploration είναι έτοιμο.', + settings: 'Ρυθμίσεις Hexploration', languages: 'Επιλέξτε μια γλώσσα', pageSettings: 'Ρυθμίσεις σελίδας: {page}', - status: 'Κατάσταση εξερεύνησης: {page}', - help: 'Εντολές Εξερεύνησης', + status: 'Κατάσταση Hexploration: {page}', + help: 'Εντολές Hexploration', confirm: 'Επιβεβαιώστε', }, discovery: { title: 'Ανακαλύφθηκε τοποθεσία', }, menu: { - draw: 'Ισοπαλία', + draw: 'Σχεδίαση', reveal: 'Αποκάλυψη και απόκρυψη', locations: 'Τοποθεσίες', tools: 'Εργαλεία', @@ -4882,52 +4907,52 @@ const HexplorationMod = (() => { buttons: { fill: 'Γέμισμα', fillInverse: 'Αντίστροφο γέμισμα', - undo: 'Αναίρεση συμπλήρωσης', - reveal: 'Αποκαλύπτω', + undo: 'Αναίρεση γεμίσματος', + reveal: 'Αποκάλυψη', conceal: 'Απόκρυψη', - explore: 'Εξερευνώ', + explore: 'Εξερεύνηση', revealPage: 'Αποκάλυψη σελίδας', resetPage: 'Επαναφορά σελίδας', mark: 'Επισήμανση τοποθεσίας', unmark: 'Κατάργηση επισήμανσης', - name: 'Όνομα Hex', + name: 'Ονομασία εξαγώνου', settings: 'Ρυθμίσεις', pageSettings: 'Ρυθμίσεις σελίδας', status: 'Κατάσταση', - rescan: 'Εκ νέου σάρωση', - calibrate: 'Μετρώ την διάμετρο', + rescan: 'Επανασάρωση', + calibrate: 'Βαθμονόμηση', calibrateReset: 'Επαναφορά βαθμονόμησης', help: 'Βοήθεια', change: 'Αλλαγή', menu: 'Μενού', - clearOverrides: 'Εκκαθάριση παρακάμψεων', - confirmReset: 'Ναι, Κατάργηση όλων των εξάγωνων', + clearOverrides: 'Κατάργηση παρακάμψεων', + confirmReset: 'Ναι, αφαίρεση όλων των εξαγώνων', }, prompts: { name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', }, values: { - on: 'Επί', - off: 'Μακριά από', - none: 'Κανένας', + on: 'Ενεργό', + off: 'Ανενεργό', + none: 'Κανένα', hexLayer: { - auto: 'Αυτόματο (πρώτο πλάνο εάν είναι διαθέσιμο)', - foreground: 'στρώμα πρώτου πλάνου', - objects: 'συμβολικό στρώμα', + auto: 'Αυτόματο (πρώτο πλάνο, αν είναι διαθέσιμο)', + foreground: 'επίπεδο πρώτου πλάνου', + objects: 'επίπεδο διακριτικών', }, revealBy: { - players: 'Μαρκάρια παίκτη', - characters: 'Μαρκάρια χαρακτήρων', - all: 'Όλες οι μάρκες', + players: 'Διακριτικά παικτών', + characters: 'Διακριτικά χαρακτήρων', + all: 'Όλα τα διακριτικά', }, revealMode: { - clear: 'Σαφής', + clear: 'Καθαρισμός', glimpse: 'Ματιά', }, announce: { - all: 'Καθένας', + all: 'Όλοι', gm: 'Μόνο GM', - off: 'Μακριά από', + off: 'Ανενεργό', }, orientation: { vertical: 'Hex (V)', @@ -4945,8 +4970,8 @@ const HexplorationMod = (() => { desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', }, hexLayer: { - label: 'Εξάγωνο στρώμα', - desc: 'Όπου σχεδιάζονται νέα εξάγωνα. Το Auto δοκιμάζει το επίπεδο προσκηνίου (πάνω από τα κουπόνια) και επιστρέφει στο επίπεδο διακριτικών εάν το παιχνίδι δεν το υποστηρίζει.', + label: 'Επίπεδο εξαγώνων', + desc: 'Πού σχεδιάζονται τα νέα εξάγωνα. Το «Αυτόματο» δοκιμάζει το επίπεδο πρώτου πλάνου (πάνω από τα διακριτικά) και, αν το παιχνίδι δεν το υποστηρίζει, χρησιμοποιεί το επίπεδο διακριτικών.', }, fillColor: { label: 'Χρώμα πλήρωσης', @@ -4957,19 +4982,19 @@ const HexplorationMod = (() => { desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', }, labelColor: { - label: 'Χρώμα ετικέτας', + label: 'Χρώμα ετικετών', desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', }, glimpseColor: { - label: 'Χρώμα Glimpse', - desc: 'Τα εξάγωνα χρώματος αλλάζουν σε όταν τα δει κανείς (λειτουργία αποκάλυψης ματιά). Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + label: 'Χρώμα Ματιάς', + desc: 'Το χρώμα που παίρνουν τα εξάγωνα στη λειτουργία «Ματιά». Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', }, strokeWidth: { label: 'Πλάτος περιγράμματος', desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', }, maxDistance: { - label: 'Εξάγωνο αποκαλύπτουν απόσταση', + label: 'Απόσταση αποκάλυψης εξαγώνων', desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', }, revealDistance: { @@ -4985,37 +5010,37 @@ const HexplorationMod = (() => { desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', }, revealBy: { - label: 'Tokens που αποκαλύπτουν', + label: 'Διακριτικά που αποκαλύπτουν', desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', - desc: 'Το Clear αφαιρεί τα εξάγωνα που φαίνονται. Το Glimpse τους κάνει διαφανείς. αφαιρούνται όταν μπει ένα κουπόνι.', + desc: "Ο «Καθαρισμός» αφαιρεί τα εξάγωνα εντός όρασης. Η «Ματιά» τα κάνει αντί γι' αυτό διαφανή· αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.", }, announce: { - label: 'Ανακοινώστε Ανακαλύψεις', + label: 'Ανακοίνωση ανακαλύψεων', desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', }, pingDiscoveries: { - label: 'Ping ανακαλύψεις', + label: 'Ping στις ανακαλύψεις', desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', }, hideCoveredTokens: { - label: 'Απόκρυψη καλυμμένων κουπονιών', + label: 'Απόκρυψη καλυμμένων διακριτικών', desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { engine: 'Μηχανή παιχνιδιού', grid: 'Πλέγμα', - layer: 'Εξάγωνο στρώμα', + layer: 'Επίπεδο εξαγώνων', hexes: 'Εξάγωνα', named: 'Ονομασμένα εξάγωνα', - icons: 'Διακριτικά τοποθεσίας', - glimpsed: 'Καθαρά εξάγωνα', + icons: 'Διακριτικά τοποθεσιών', + glimpsed: 'Εξάγωνα σε Ματιά', pending: 'Τοποθεσίες που περιμένουν γέμισμα', calibrated: 'Βαθμονομημένο', - overrides: 'Σελίδα παρακάμπτει', + overrides: 'Παρακάμψεις σελίδας', undo: 'Αναίρεση διαθέσιμη', }, messages: { @@ -5042,11 +5067,11 @@ const HexplorationMod = (() => { 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: - 'Οι χάρτες σας Hexploration 1.x hex έχουν αναβαθμιστεί. Εάν αυτό το παιχνίδι αντιγράφηκε από ένα παιχνίδι παλαιού τύπου, εκτελέστε Εκ νέου σάρωση σε κάθε σελίδα του εξάγωνου χάρτη.', + 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', pruned: - 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πλέον και ξεχάστηκαν: {dropped}. Εάν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε Εκ νέου σάρωση στη σελίδα για να επαναλάβετε τα εξάγωνά της.', + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πια και ξεχάστηκαν: {dropped}. Αν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά τα εξάγωνά της.', readyHint: - 'Πληκτρολογήστε !hexploration για το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + 'Πληκτρολογήστε !hexploration για να ανοίξει το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -5058,7 +5083,7 @@ const HexplorationMod = (() => { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', - emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει δεκαεξαδικά κέντρα.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', @@ -5108,21 +5133,20 @@ const HexplorationMod = (() => { pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: - 'Δημιουργήστε ξανά τη δεκαεξαδική λίστα της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', - journal: 'Αναδημιουργήστε τα φυλλάδια Help and Command Deck.', + journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', help: 'Εμφάνιση αυτής της λίστας.', handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', }, deck: { - subtitle: 'Κατάστρωμα εντολών', drawDesc: - 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και μετά συμπληρώστε. Η αναίρεση αντιστρέφει το τελευταίο γέμισμα.', + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και κάντε «Γέμισμα». Η «Αναίρεση γεμίσματος» αναιρεί το τελευταίο γέμισμα.', revealDesc: - 'Επιλέξτε εξάγωνα, σχήματα ή μάρκες για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Εξερευνήστε αποκαλύψεις γύρω από επιλεγμένα διακριτικά σαν να είχαν μετακινηθεί.', + 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: @@ -5143,9 +5167,9 @@ const HexplorationMod = (() => { steps: [ 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', - 'Επιλέξτε τα σχήματα και κάντε κλικ στο Συμπλήρωση στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', - 'Προαιρετικά: πριν συμπληρώσετε, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην επιλογή Επισήμανση τοποθεσίας. Είναι κρυμμένα κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', - 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και οι εξάγωνοι εντός της Απόστασης όρασής του, αποκαλύπτονται.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Γέμισμα στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν από το γέμισμα, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην «Επισήμανση τοποθεσίας». Κρύβονται κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και τα εξάγωνα εντός της «Απόστασης όρασης» του, αποκαλύπτονται.', ], }, commands: { @@ -5158,29 +5182,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Πώς λειτουργεί η αποκάλυψη', points: [ - 'Μόνο τα κουπόνια στο στρώμα διακριτικών αποκαλύπτουν εξάγωνα. Το ποια μάρκα μετράει ορίζεται από το Tokens That Reveal: tokens παίκτη από προεπιλογή, έτσι ώστε η GM να μπορεί να μετακινήσει τέρατα χωρίς να αποκαλύψει τον χάρτη.', - 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με το Reveal Along Path να είναι ενεργοποιημένο, κάθε εξάγωνο στη διαδρομή που σύρθηκε, συμπεριλαμβανομένων των σημείων διαδρομής.', - 'Η απόσταση όρασης αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με το Line of Sight ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο στο μεταξύ.', - 'Το Hex Reveal Distance αποθηκεύεται σε εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται από μέσα μόνο τόσα εξάγωνα, όσο μακριά κι αν μπορεί να δει κανείς. Χρησιμοποιήστε το για βουνά ή δάση που κρύβουν ό,τι είναι πίσω τους.', - 'Στη λειτουργία Glimpse, τα εξάγωνα που είναι ορατά γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν εισέρχεται ένα διακριτικό.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', - 'Το API δεν αναφέρει κινήσεις που έγιναν από άλλα mods. Οι κινήσεις TokenMod λαμβάνονται αυτόματα. για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στο Explore ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο αποκαλύπτεται μόνο αν δεν παρεμβάλλεται καλυμμένο εξάγωνο.', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται στα εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται μόνο από απόσταση έως τόσα εξάγωνα, όσο μακριά κι αν βλέπει ένα διακριτικό. Χρησιμοποιήστε την για βουνά ή δάση που κρύβουν ό,τι βρίσκεται πίσω τους.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.', + 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', + 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', ], }, locations: { heading: 'Με όνομα Hexes and Locations', points: [ - 'Η επισήμανση τοποθεσίας μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από ένα εξάγωνο κρύβεται αμέσως. αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', - 'Όνομα Hex δίνει σε ένα hex ένα όνομα χωρίς διακριτικό. Το όνομα εμφανίζεται στο GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', - 'Το Announce Discoveries επιλέγει αν όλοι, μόνο ο GM ή κανείς δεν θα δει την ανακοίνωση. Το Ping Discoveries μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], }, settings: { heading: 'Ρυθμίσεις', intro: - 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί Ρυθμίσεις). Το Hex Layer, τα Tokens That Reveal και η Language μπορούν επίσης να οριστούν στη σελίδα ρυθμίσεων του Mod.', + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', colName: 'Σύνθεση', colDesc: 'Περιγραφή', @@ -5190,18 +5214,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate και Legacy', points: [ 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', - 'Με το Hex Layer σε Αυτόματο, τα εξάγωνα σχεδιάζονται στο πρώτο επίπεδο, πάνω από τα διακριτικά, έτσι οι παίκτες δεν μπορούν να δουν τι υπάρχει από κάτω. Εάν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικού.', - 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, τα οποία έχουν ελαφρώς διαφορετικό σχήμα από τα εξάγωνα παλαιού τύπου. Εάν τα hexes δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό σε ένα εξάγωνο κέντρο, επιλέξτε το και κάντε κλικ στο Calibrate. Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του hex.', - 'Όταν μια σελίδα ή ένα παιχνίδι αντιγράφεται, τα εξάγωνά του λαμβάνουν νέα αναγνωριστικά. Εκτελέστε Εκ νέου σάρωση στη σελίδα για να τα παραλάβετε ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσίας τους.', + 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', + 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', ], }, upgrading: { heading: 'Αναβάθμιση από την έκδοση 1', points: [ 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', - 'Οι υπάρχοντες δεκαεξαδικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσίας και οι ρυθμίσεις αναβαθμίζονται αυτόματα με την πρώτη εκκίνηση.', + 'Οι υπάρχοντες εξαγωνικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσιών και οι ρυθμίσεις αναβαθμίζονται αυτόματα στην πρώτη εκκίνηση.', 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', - 'Η έκδοση 1 επιτρέπει σε οποιοδήποτε διακριτικό που αντιπροσώπευε έναν χαρακτήρα να αποκαλύψει εξάγωνα. Ρυθμίστε τα Tokens That Reveal σε διακριτικά χαρακτήρων για να διατηρήσετε αυτή τη συμπεριφορά.', + 'Η έκδοση 1 επέτρεπε σε κάθε διακριτικό που αντιπροσώπευε χαρακτήρα να αποκαλύπτει εξάγωνα. Ορίστε τα «Διακριτικά που αποκαλύπτουν» σε «Διακριτικά χαρακτήρων» για να διατηρήσετε αυτή τη συμπεριφορά.', ], colV1: 'Εντολή έκδοσης 1', colV2: 'Εντολή έκδοσης 2', @@ -5209,10 +5233,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Αντιμετώπιση προβλημάτων', points: [ - 'Τίποτα δεν συμβαίνει όταν ένα διακριτικό μετακινείται: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο του διακριτικού και ταιριάζει με τα Tokens That Reveal και ότι η σελίδα έχει hexes (!hexploration status).', - 'Τα εξάγωνα μετατοπίζονται από το πλέγμα: χρησιμοποιήστε τη Βαθμονόμηση και, στη συνέχεια, ελέγξτε με ένα διακριτικό μερικά εξάγωνα στον χάρτη.', - 'Τα Hexes σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε Εκ νέου σάρωση στη σελίδα.', - 'Το Fill λέει ότι η περιοχή δεν έχει εξάγωνα κέντρα: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξάγωνου.', + 'Δεν συμβαίνει τίποτα όταν μετακινείται ένα διακριτικό: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο διακριτικών και ταιριάζει με τη ρύθμιση «Διακριτικά που αποκαλύπτουν», και ότι η σελίδα έχει εξάγωνα (!hexploration status).', + 'Τα εξάγωνα είναι μετατοπισμένα από το πλέγμα: χρησιμοποιήστε τη «Βαθμονόμηση» και μετά ελέγξτε με ένα διακριτικό μερικά εξάγωνα σε διάφορα σημεία του χάρτη.', + 'Τα εξάγωνα σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε «Επανασάρωση» στη σελίδα.', + 'Το «Γέμισμα» αναφέρει ότι η περιοχή δεν έχει κέντρα εξαγώνων: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξαγώνου.', 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', ], }, @@ -5220,7 +5244,7 @@ const HexplorationMod = (() => { heading: 'Γλώσσες', body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', - colNative: 'Εγγενές όνομα', + colNative: 'Όνομα στη γλώσσα της', colCode: 'Κώδικας', }, credits: { @@ -5236,93 +5260,93 @@ const HexplorationMod = (() => { const TRANSLATION$c = { titles: { - ready: 'החקירה מוכנה.', - settings: 'הגדרות החקירה', - languages: 'בחר שפה', + ready: 'Hexploration מוכן.', + settings: 'הגדרות Hexploration', + languages: 'בחירת שפה', pageSettings: 'הגדרות דף: {page}', - status: 'סטטוס החקירה: {page}', - help: 'פקודות החקירה', - confirm: 'אנא אשר', + status: 'מצב Hexploration: {page}', + help: 'פקודות Hexploration', + confirm: 'נא לאשר', }, discovery: { title: 'מיקום התגלה', }, menu: { - draw: 'לִמְשׁוֹך', - reveal: 'לגלות ולהסתיר', + draw: 'ציור', + reveal: 'חשיפה והסתרה', locations: 'מיקומים', - tools: 'כְּלֵי עֲבוֹדָה', - layerInUse: 'משושים חדשים מצוירים ב-{layer}.', + tools: 'כלים', + layerInUse: 'משושים חדשים מצוירים על {layer}.', pageSettingsHelp: 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', }, buttons: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - undo: 'בטל מילוי', - reveal: 'לְגַלוֹת', - conceal: 'לְהַסתִיר', - explore: 'לַחקוֹר', - revealPage: 'גלה עמוד', - resetPage: 'אפס דף', - mark: 'סמן מיקום', - unmark: 'בטל את הסימון', - name: 'שם הקס', + undo: 'ביטול מילוי', + reveal: 'חשיפה', + conceal: 'הסתרה', + explore: 'חקירה', + revealPage: 'חשיפת הדף', + resetPage: 'איפוס הדף', + mark: 'סימון מיקום', + unmark: 'ביטול סימון', + name: 'מתן שם למשושה', settings: 'הגדרות', - pageSettings: 'הגדרות עמוד', - status: 'סטָטוּס', - rescan: 'סרוק מחדש', - calibrate: 'לְדַרֵג', + pageSettings: 'הגדרות דף', + status: 'מצב', + rescan: 'סריקה מחדש', + calibrate: 'כיול', calibrateReset: 'אפס כיול', - help: 'עֶזרָה', - change: 'לְשַׁנוֹת', - menu: 'תַפרִיט', - clearOverrides: 'נקה עקיפות', + help: 'עזרה', + change: 'שינוי', + menu: 'תפריט', + clearOverrides: 'ניקוי עקיפות', confirmReset: 'כן, הסר את כל המשושים', }, prompts: { name: 'שם המיקום (השאירו ריק כדי לנקות)', }, values: { - on: 'עַל', + on: 'מופעל', off: 'כבוי', - none: 'אַף לֹא אֶחָד', + none: 'ללא', hexLayer: { - auto: 'אוטומטי (בחזית אם זמין)', - foreground: 'שכבת חזית', - objects: 'שכבת אסימונים', + auto: 'אוטומטי (שכבת החזית אם זמינה)', + foreground: 'שכבת החזית', + objects: 'שכבת האסימונים', }, revealBy: { - players: 'אסימוני שחקן', - characters: 'אסימוני תווים', + players: 'אסימוני שחקנים', + characters: 'אסימוני דמויות', all: 'כל האסימונים', }, revealMode: { - clear: 'בָּרוּר', - glimpse: 'הֲצָצָה', + clear: 'הסרה', + glimpse: 'הצצה', }, announce: { - all: 'כֹּל אֶחָד', + all: 'כולם', gm: 'GM בלבד', off: 'כבוי', }, orientation: { - vertical: 'משושה (V)', - horizontal: 'משושה (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'לְמַלֵא', + fill: 'מילוי', fillInverse: 'מילוי הפוך', - conceal: 'לְהַסתִיר', + conceal: 'הסתרה', }, }, settings: { language: { - label: 'שָׂפָה', + label: 'שפה', desc: 'שפה לתפריטים, הודעות ודפי מידע.', }, hexLayer: { - label: 'שכבת משושה', + label: 'שכבת המשושים', desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', }, fillColor: { @@ -5330,23 +5354,23 @@ const HexplorationMod = (() => { desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { - label: 'צבע גבול', + label: 'צבע מסגרת', desc: 'צבע קווי המתאר של משושות חדשות.', }, labelColor: { - label: 'צבע התווית', + label: 'צבע תווית', desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', }, glimpseColor: { label: 'צבע הצצה', - desc: 'משושי צבע משתנים לבעת הצצה (מצב חשיפת הצצה). השתמש בצבע rgba() שקוף.', + desc: 'הצבע שאליו משושים משתנים בעת הצצה (מצב החשיפה הצצה). השתמש בצבע rgba() שקוף.', }, strokeWidth: { - label: 'רוחב גבול', + label: 'עובי מסגרת', desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', }, maxDistance: { - label: 'מרחק חשיפת משושה', + label: 'מרחק חשיפת משושים', desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', }, revealDistance: { @@ -5358,42 +5382,42 @@ const HexplorationMod = (() => { desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', }, revealPath: { - label: 'גלה לאורך הנתיב', + label: 'חשיפה לאורך המסלול', desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', }, revealBy: { - label: 'אסימונים שחושפים', + label: 'אסימונים חושפים', desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', }, revealMode: { label: 'מצב חשיפה', - desc: 'קליר מסיר משושים בטווח ראייה. הצצה גורמת להם להיות שקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + desc: 'הסרה מסירה משושים שבטווח הראייה. הצצה הופכת אותם לשקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', }, announce: { - label: 'הכריזו על תגליות', + label: 'הכרזה על תגליות', desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", }, pingDiscoveries: { - label: 'פינג תגליות', + label: 'פינג לתגליות', desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', }, hideCoveredTokens: { label: 'הסתר אסימונים מכוסים', - desc: 'Roll20 מצייר שמות, מוטות והילות מעל משושים. כשהם מופעלים, לאסימונים מתחת לקסדה מכוסה השם שלהם גלוי לנגן, מוטות והילות כבויים, ומופעלים שוב כאשר הם נחשפים.', + desc: 'Roll20 מצייר שמות, פסים והילות מעל משושים. כשההגדרה מופעלת, השם, הפסים וההילות הגלויים לשחקנים של אסימונים שמתחת למשושה מכוסה נכבים, ומופעלים שוב כשהם נחשפים.', }, }, status: { engine: 'מנוע משחק', - grid: 'רֶשֶׁת', - layer: 'שכבת משושה', + grid: 'רשת', + layer: 'שכבת המשושים', hexes: 'משושים', - named: 'ששים בשם', + named: 'משושים עם שם', icons: 'אסימוני מיקום', - glimpsed: 'משושים נוצצים', + glimpsed: 'משושים בהצצה', pending: 'מיקומים ממתינים למילוי', - calibrated: 'מְכוּיָל', - overrides: 'עקיפת עמוד', - undo: 'בטל זמין', + calibrated: 'מכויל', + overrides: 'עקיפות דף', + undo: 'ניתן לבטל', }, messages: { filled: @@ -5417,11 +5441,11 @@ const HexplorationMod = (() => { 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: - 'מפות הקש של Hexploration 1.x שלך שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל Rescan בכל דף מפה משושה.', + 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', readyHint: - 'הקלד !hexploration עבור התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -5483,17 +5507,16 @@ const HexplorationMod = (() => { calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', - journal: 'בנה מחדש את דפי העזרה והפקודה.', + journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', help: 'הצג רשימה זו.', handout: 'ההנחיות המלאות נמצאות בדף "{name}".', }, deck: { - subtitle: 'סיפון פיקוד', - drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. בטל הופך את המילוי האחרון.', + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. ביטול מילוי מבטל את המילוי האחרון.', revealDesc: - 'בחר משושים, צורות או אסימונים כדי לחשוף או לכסות אותם שוב. חקור גילויים סביב אסימונים נבחרים כאילו הם זזו.', + 'בחר משושים, צורות או אסימונים כדי לחשוף אותם או לכסות אותם שוב. חקירה חושפת את הסביבה של האסימונים הנבחרים כאילו הם זזו לשם.', locationsDesc: - 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר hexes או אסימונים כדי לתת שם hex.', + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר משושים או אסימונים כדי לתת שם למשושה.', toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', footer: 'עיין בדף "{help}" להנחיות מלאות.', }, @@ -5503,7 +5526,7 @@ const HexplorationMod = (() => { footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', - body: 'האקספלורציה מכסה מפת hex עם hexes אטומים. כאשר המפלגה זזה, המשושים שהם עוברים דרכם (ואם תרצו, המשושים סביבם) מוסרים, כך שהמפה נחשפת משושה אחת בכל פעם. ניתן למקם מיקומים מוסתרים מתחת למשושים והם מוכרזים כאשר הם נמצאים. זה עובד במשחקי Jumpgate ו- Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + body: 'Hexploration מכסה מפת משושים במשושים אטומים. כשהחבורה זזה, המשושים שהיא עוברת דרכם (ואם תרצו, גם המשושים שסביבה) מוסרים, כך שהמפה נחשפת משושה אחר משושה. אפשר להציב מיקומים מוסתרים מתחת למשושים, והם מוכרזים כשהם נמצאים. הכלי עובד במשחקי Jumpgate ו-Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', demo: 'צפו בהדגמה קצרה (מגרסה 1)', }, quickStart: { @@ -5511,9 +5534,9 @@ const HexplorationMod = (() => { steps: [ 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', - 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות בשושים.', - 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סמן מיקום. הם מוסתרים מתחת למשושים ומוכרזים כאשר הם מתגלים.', - 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והשיושים במרחק הראייה שלו, מתגלים.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות במשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סימון מיקום. הם מוסתרים מתחת למשושים ומוכרזים כשהם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והמשושים שבתוך מרחק הראייה שלו, נחשפים.', ], }, commands: { @@ -5526,40 +5549,40 @@ const HexplorationMod = (() => { revealing: { heading: 'איך עובד גילוי', points: [ - 'רק אסימונים בשכבת האסימון מגלים משושים. איזה ספירת אסימונים נקבעת על ידי Tokens That Reveal: אסימוני שחקן כברירת מחדל, כך שה-GM יכול להזיז מפלצות מבלי לחשוף את המפה.', - 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה) ועם Reveal Along Path מופעל, כל משושה במסלול שהוא נגרר אליו, כולל נקודות ציון.', + 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', - 'מרחק חשיפת משושה מאוחסן על משושים בזמן שהם מצוירים. המשושים האלה מתגלים רק מבפנים כל כך הרבה משושים, עד כמה שאסימון יכול לראות. השתמש בו עבור הרים או יערות שמסתירים את מה שנמצא מאחוריהם.', + 'מרחק חשיפת משושים נשמר על המשושים בזמן שהם מצוירים. משושים אלה נחשפים רק מטווח של מספר המשושים הזה, לא משנה כמה רחוק אסימון יכול לראות. השתמש בו להרים או ליערות שמסתירים את מה שמאחוריהם.', 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', - 'ה-API אינו מדווח על מהלכים שנעשו על ידי אופנים אחרים. מהלכי TokenMod נקלטים באופן אוטומטי; עבור אופנים אחרים, בחר את האסימונים ולחץ על Explore, או התקשר ל-Hexploration.revealAround(token) מהמוד שלך.', + 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', + 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', ], }, locations: { heading: 'בשם משושים ומיקומים', points: [ - 'סמן מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר תחת משושה מוסתר מיד; אחרת הוא מוסתר על ידי המילוי הבא שמכסה אותו.', + 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', - 'Name Hex נותן hex שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כאשר ה-hex נחשף.', - 'הכרזה תגליות בוחרת אם כולם, רק ה-GM או אף אחד לא יראה את ההכרזה. Ping Discoveries גם מעביר את תצוגת השחקנים למיקום.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], }, settings: { heading: 'הגדרות', intro: - 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). ניתן להגדיר גם שכבת Hex Layer, Tokens That Reveal ושפה בדף ההגדרות של המוד.', + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', colName: 'סְבִיבָה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, jumpgate: { - heading: 'Jumpgate ומורשת', + heading: 'Jumpgate ו-Legacy', points: [ - 'האקספלורציה מגלה באיזה מנוע המשחק משתמש ומשרטטת את הצורה התואמת. ניתן למלא צורות שצוירו בכל אחד מהעורך.', - 'כאשר שכבת Hex Layer מוגדרת ל-Auto, משושים מצוירים בשכבת החזית, מעל אסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימון במקום זאת.', - 'Jumpgate מצייר hexes רגילים מתמטית, שהם צורה שונה במקצת מה-Legacy hexes. אם המשושים אינם מתיישבים עם הרשת של עמוד, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים בשושים שכנים של אותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'Hexploration מזהה באיזה מנוע המשחק משתמש ומצייר את סוג הצורה המתאים. אפשר למלא צורות שצוירו בכל אחד משני העורכים.', + 'כששכבת המשושים מוגדרת לאוטומטי, משושים מצוירים בשכבת החזית, מעל האסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימונים במקום זאת.', + 'Jumpgate מצייר משושים משוכללים מתמטית, שצורתם שונה מעט ממשושי Legacy. אם המשושים אינם מתיישרים עם הרשת של הדף, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים במשושים שכנים באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', ], }, @@ -5569,7 +5592,7 @@ const HexplorationMod = (() => { 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', - 'גרסה 1 מאפשרת לכל אסימון שייצג דמות לחשוף משושים. הגדר אסימונים שחושפים לאסימוני תווים כדי לשמור על התנהגות זו.', + 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], colV1: 'פקודה גרסה 1', colV2: 'פקודה גרסה 2', @@ -5577,9 +5600,9 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'פתרון בעיות', points: [ - 'שום דבר לא קורה כאשר אסימון זז: בדוק שהאסימון נמצא בשכבת האסימון ותואם ל-Tokens That Reveal, ושהדף מכיל hexes (!hexploration status).', - 'משושים מוסטים מהרשת: השתמש בכייל, ואז בדוק עם אסימון על כמה משושים על פני המפה.', - 'Hexes הפסיקו לחשוף לאחר העתקת עמוד או משחק: הפעל Rescan בדף.', + 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', + 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', + 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], @@ -5588,7 +5611,7 @@ const HexplorationMod = (() => { heading: 'שפות', body: 'בחר שפה עם !hexploration set language. שפות זמינות:', colLanguage: 'שָׂפָה', - colNative: 'שם יליד', + colNative: 'שם בשפת המקור', colCode: 'קוד', }, credits: { @@ -5604,61 +5627,61 @@ const HexplorationMod = (() => { const TRANSLATION$b = { titles: { - ready: 'A hexploration készen áll.', - settings: 'Hexexploration beállítások', + ready: 'A Hexploration készen áll.', + settings: 'Hexploration-beállítások', languages: 'Válasszon nyelvet', pageSettings: 'Oldalbeállítások: {page}', - status: 'Heti feltárás állapota: {page}', + status: 'Hexploration-állapot: {page}', help: 'Hexploration parancsok', confirm: 'Kérjük, erősítse meg', }, discovery: { - title: 'Hely felfedezve', + title: 'Helyszín felfedezve', }, menu: { - draw: 'Rajzolj', - reveal: 'Felfedni és elrejteni', + draw: 'Rajzolás', + reveal: 'Felfedés és elrejtés', locations: 'Helyszínek', tools: 'Eszközök', - layerInUse: 'Új hatszögek rajzolása folyamatban van a {layer}.', + layerInUse: 'Az új hatszögek ide kerülnek: {layer}.', pageSettingsHelp: 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', }, buttons: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', undo: 'Kitöltés visszavonása', - reveal: 'Felfedni', - conceal: 'Elrejteni', - explore: 'Fedezze fel', - revealPage: 'Oldal feltárása', + reveal: 'Felfedés', + conceal: 'Lefedés', + explore: 'Felderítés', + revealPage: 'Oldal felfedése', resetPage: 'Oldal visszaállítása', - mark: 'Hely megjelölése', - unmark: 'Törölje a jelölést', - name: 'Név Hex', - settings: 'Beállítások elemre', + mark: 'Helyszín megjelölése', + unmark: 'Jelölés törlése', + name: 'Hatszög elnevezése', + settings: 'Beállítások', pageSettings: 'Oldalbeállítások', status: 'Állapot', rescan: 'Újraszkennelés', - calibrate: 'Kalibrálni', + calibrate: 'Kalibrálás', calibrateReset: 'Kalibrálás visszaállítása', help: 'Segítség', - change: 'Változás', + change: 'Módosítás', menu: 'Menü', clearOverrides: 'Felülbírálások törlése', - confirmReset: 'Igen, távolítsa el az összes hexát', + confirmReset: 'Igen, minden hatszög eltávolítása', }, prompts: { name: 'Helynév (a törléshez hagyja üresen)', }, values: { - on: 'On', - off: 'Le', - none: 'Egyik sem', + on: 'Be', + off: 'Ki', + none: 'Nincs', hexLayer: { - auto: 'Automatikus (előtérben, ha elérhető)', - foreground: 'előtér réteg', - objects: 'token réteg', + auto: 'Automatikus (előtér, ha elérhető)', + foreground: 'előtérréteg', + objects: 'tokenréteg', }, revealBy: { players: 'Játékos tokenek', @@ -5666,22 +5689,22 @@ const HexplorationMod = (() => { all: 'Minden token', }, revealMode: { - clear: 'Világos', + clear: 'Eltávolítás', glimpse: 'Bepillantás', }, announce: { all: 'Mindenki', - gm: 'Csak GM', - off: 'Le', + gm: 'Csak a GM', + off: 'Ki', }, orientation: { vertical: 'Hex (V)', horizontal: 'Hex (H)', }, fillKind: { - fill: 'Töltse ki', + fill: 'Kitöltés', fillInverse: 'Inverz kitöltés', - conceal: 'Elrejteni', + conceal: 'Lefedés', }, }, settings: { @@ -5690,8 +5713,8 @@ const HexplorationMod = (() => { desc: 'A menük, üzenetek és tájékoztatók nyelve.', }, hexLayer: { - label: 'Hatlapos réteg', - desc: 'Ahol új hatszögeket rajzolnak. Az Auto megpróbálja az előtér réteget (a tokenek felett), és visszaesik a token rétegre, ha a játék nem támogatja.', + label: 'Hatszögek rétege', + desc: 'Hová kerülnek az új hatszögek. Az Automatikus az előtérréteggel próbálkozik (a tokenek fölött), és ha a játék ezt nem támogatja, a tokenréteget használja.', }, fillColor: { label: 'Kitöltés színe', @@ -5706,15 +5729,15 @@ const HexplorationMod = (() => { desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'A színes hatszögek bepillantáskor a következőre változnak (Glimpse discovery mód). Használjon átlátszó rgba() színt.', + label: 'Bepillantás színe', + desc: 'Az a szín, amelyre a hatszögek bepillantáskor váltanak (Bepillantás felfedési mód). Használjon átlátszó rgba() színt.', }, strokeWidth: { - label: 'Határ szélessége', + label: 'Szegély szélessége', desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', }, maxDistance: { - label: 'Hex Reveal távolság', + label: 'Hatszögek felfedési távolsága', desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', }, revealDistance: { @@ -5726,42 +5749,42 @@ const HexplorationMod = (() => { desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', }, revealPath: { - label: 'Fedezd fel az ösvényen', + label: 'Felfedés az útvonal mentén', desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', }, revealBy: { - label: 'Tokenek, amelyek felfedik', + label: 'Felfedő tokenek', desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', }, revealMode: { - label: 'Felfedezési mód', - desc: 'A Clear eltávolítja a hatszögleteket látótávolságon belül. A bepillantás ehelyett átlátszóvá teszi őket; eltávolítják őket, amikor egy token belép beléjük.', + label: 'Felfedési mód', + desc: 'Az Eltávolítás mód eltávolítja a látótávolságon belüli hatszögeket. A Bepillantás mód ehelyett átlátszóvá teszi őket; akkor tűnnek el, amikor egy token belép beléjük.', }, announce: { - label: 'Hirdesse a felfedezéseket', + label: 'Felfedezések bejelentése', desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', }, pingDiscoveries: { - label: 'Ping felfedezések', + label: 'Felfedezések pingelése', desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', }, hideCoveredTokens: { - label: 'Fedett tokenek elrejtése', + label: 'Lefedett tokenek elrejtése', desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', }, }, status: { - engine: 'Játék motor', + engine: 'Játékmotor', grid: 'Rács', - layer: 'Hatlapos réteg', - hexes: 'Hexák', - named: 'Elnevezett hexák', - icons: 'Helyjelzők', - glimpsed: 'Megpillantott hatszögek', - pending: 'Betöltésre váró helyek', + layer: 'Hatszögek rétege', + hexes: 'Hatszögek', + named: 'Elnevezett hatszögek', + icons: 'Helyszíntokenek', + glimpsed: 'Bepillantott hatszögek', + pending: 'Kitöltésre váró helyszínek', calibrated: 'Kalibrálva', - overrides: 'Oldal felülbírálása', - undo: 'Visszavonás elérhető', + overrides: 'Oldalszintű felülbírálások', + undo: 'Visszavonható', }, messages: { filled: @@ -5787,11 +5810,11 @@ const HexplorationMod = (() => { 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', migrated: - 'A Hexploration 1.x hexadecimális térképeidet frissítettük. Ha ezt a játékot egy régi játékból másolták, futtassa az Újrakeresést minden hexadecimális térképoldalon.', + 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: - 'Mentett hexák, amelyek már nem léteznek és elfelejtettek: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraellenőrzést az oldalon, hogy újra felvegye a hatszögleteket.', + 'Mentett hatszögek, amelyek már nem léteznek, és törlődtek a nyilvántartásból: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraszkennelést az oldalon, hogy újra felvegye a hatszögeit.', readyHint: - 'Írja be a !hexploration parancsot a menübe, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + 'A menühöz írja be a !hexploration parancsot, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', }, warnings: { foregroundUnavailable: @@ -5802,7 +5825,7 @@ const HexplorationMod = (() => { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', notHex: 'Ez az oldal nem használ hatszögletű rácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', - emptyArea: 'A kiválasztott terület nem tartalmaz hexadecimális középpontokat.', + emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', nothingToReveal: @@ -5832,7 +5855,7 @@ const HexplorationMod = (() => { calibrateNeedsTokens: 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', calibrateFailed: - 'Két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hexa) kell lennie, egymástól legalább egy hatszögre.', + 'A két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hex H) kell lennie, egymástól legalább egy hatszögnyire.', unexpected: 'A részletek az API-konzol naplójában találhatók.', }, help: { @@ -5845,7 +5868,7 @@ const HexplorationMod = (() => { revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', conceal: 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', - explore: 'Mutasd meg a kiválasztott tokenek körül, mintha csak most költöztek volna oda.', + explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', @@ -5853,22 +5876,20 @@ const HexplorationMod = (() => { set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', pageClear: 'Távolítsa el az aktuális oldal felülírásait.', - rescan: - 'Építse újra az oldal hexadecimális listáját, például egy oldal vagy játék másolása után.', + rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', - journal: 'Építsd újra a Help és Command Deck segédanyagokat.', + journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', help: 'Mutasd ezt a listát.', handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', }, deck: { - subtitle: 'Parancsnoki pakli', drawDesc: 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', revealDesc: - 'Válassza ki a hatszögleteket, alakzatokat vagy jelzőket, hogy ismét felfedje vagy lefedje őket. Fedezze fel a kiválasztott tokenek körüli felfedéseket, mintha elmozdultak volna.', + 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', toolsDesc: @@ -5881,7 +5902,7 @@ const HexplorationMod = (() => { footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', - body: 'A Hexploration egy hexadecimális térképet fed le átlátszatlan hatszögekkel. Ahogy a csapat mozog, a hatszögek, amelyeken áthaladnak (és ha úgy tetszik, a körülöttük lévő hatszögek) eltávolításra kerülnek, így a térkép egyenként hatszögletű kerül felfedésre. A rejtett helyek hatszögek alá helyezhetők, és a rendszer kijelenti, ha megtalálják. Működik a Jumpgate és Legacy játékokban, bármilyen méretű Hex (V) és Hex (H) rácson.', + body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', }, quickStart: { @@ -5889,8 +5910,8 @@ const HexplorationMod = (() => { steps: [ 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', - 'Jelölje ki az alakzatokat, és kattintson a Kitöltés gombra a Command Deckben (vagy írja be a !hexploration fill parancsot). Az alakzatokat hatszögek helyettesítik.', - 'Nem kötelező: a kitöltés előtt válassza ki a tokeneket a fontos helyekhez, és kattintson a Hely megjelölése lehetőségre. A hatszögek alatt vannak elrejtve, és felfedik őket, amikor felfedezik.', + 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', + 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', ], }, @@ -5904,29 +5925,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Hogyan működik a feltárás', points: [ - 'Csak a token rétegen lévő tokenek mutatnak hatszögeket. A tokenek számát a Tokens That Reveal: alapértelmezés szerint a játékos tokenek állítják be, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', - 'A token felfedi minden általa lefedett hatszöget (a nagy tokenek többre is kiterjednek), és ha a Reveal Along Path be van kapcsolva, minden hexát az útvonalon, amelyen végighúzták, beleértve az útpontokat is.', - 'A Sight Distance felfedi az egyes hatszögek körüli hatszögeket. Ha a Line of Sight be van kapcsolva, a hatszög csak akkor jelenik meg, ha nincs közöttük fedett hatszög.', - 'A hexadecimális feltárási távolságot a rendszer a hexákon tárolja, ahogy rajzolják. Azok a hatszögek csak belülről tárulnak fel annyi hatszögből, bármennyire is lát egy token. Használja hegyekre vagy erdőkre, amelyek elrejtik azt, ami mögöttük van.', - 'Pillantás módban a látótávolságon belüli hatszögek ahelyett, hogy eltűnnének, átlátszóvá válnak, és eltávolítódnak, amikor egy token belép beléjük.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját mododból.', - 'Az API nem jelenti a más modok által végrehajtott mozgásokat. A TokenMod lépéseit a rendszer automatikusan felveszi; más modok esetén válassza ki a tokeneket, és kattintson az Explore gombra, vagy hívja a Hexploration.revealAround(token)-t a saját modjából.', + 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel. Ha a Látóvonal be van kapcsolva, egy hatszög csak akkor fedődik fel, ha nincs közte és a token között lefedett hatszög.', + 'A Hatszögek felfedési távolsága a hatszögek megrajzolásakor kerül tárolásra rajtuk. Ezek a hatszögek csak ennyi hatszögnyi távolságon belülről fedhetők fel, bármilyen messzire lát is egy token. Hegyekhez vagy erdőkhöz használja, amelyek eltakarják, ami mögöttük van.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és akkor tűnnek el, amikor egy token belép beléjük.', + 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', + 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', ], }, locations: { heading: 'Hexák és helyek neve', points: [ - 'A Mark Location funkció rejtett helyekre változtatja a kiválasztott tokeneket. A már hatszög alatt lévő tokent azonnal elrejti; különben elrejti a következő kitöltés, amely lefedi.', + 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', - 'Name Hex ad egy hexa nevet token nélkül. A név megjelenik a GM-nek címkeként a GM rétegen, és közli, amikor a hatszög megjelenik.', - 'Az Announce Discoveries kiválasztja, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Ping Discoveries a játékosok nézetét is áthelyezi a helyszínre.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { heading: 'Beállítások elemre', intro: - 'Módosítsa a beállításokat a !hexploration set segítségével (vagy a Beállítások gombbal). A Hex Layer, a Tokens That Reveal és a Language is beállítható a Mod beállítási oldalán.', + 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', colKey: 'Kulcsfontosságú', colName: 'Beállítás', colDesc: 'Leírás', @@ -5936,9 +5957,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate és Legacy', points: [ 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', - 'Ha a Hex Layer Auto-ra van állítva, a hexák az előtér rétegre, a tokenek fölé kerülnek, így a játékosok nem láthatják, mi van alatta. Ha az előtér réteg nem érhető el, a rendszer a token réteget használja helyette.', - 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek kissé eltérnek az örökölt hatszögektől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszögletű középponthoz, jelölje ki, majd kattintson a Kalibrálás gombra. Válasszon ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögletéből a hexadecimális méret javításához.', - 'Amikor egy oldalt vagy játékot másol, a hatszögei új azonosítókat kapnak. Futtassa az Újrakeresést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyjelzőikkel együtt.', + 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', + 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', ], }, upgrading: { @@ -5947,7 +5968,7 @@ const HexplorationMod = (() => { 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', - 'Az 1-es verzió lehetővé teszi, hogy bármely karaktert ábrázoló token felfedjen hatszögleteket. Állítsa be a felfedő tokeneket karakterjelzőkre, hogy megtartsa ezt a viselkedést.', + 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], colV1: '1-es verzió parancs', colV2: '2-es verzió parancs', @@ -5955,23 +5976,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Hibaelhárítás', points: [ - 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, és egyezik-e a felfedő tokenekkel, és hogy az oldal rendelkezik-e hexákkal (!hexploration állapot).', + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, megfelel-e a Felfedő tokenek beállításnak, és vannak-e hatszögek az oldalon (!hexploration status).', 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', - 'Egy oldal vagy játék másolása után a hexák nem jelennek meg: futtassa az Újrakeresést az oldalon.', + 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', ], }, languages: { heading: 'Nyelvek', - body: 'Válasszon nyelvet a !hexploration beállított nyelvvel. Elérhető nyelvek:', + body: 'Nyelvet a !hexploration set language paranccsal választhat. Elérhető nyelvek:', colLanguage: 'Nyelv', - colNative: 'Natív név', + colNative: 'Saját név', colCode: 'Kód', }, credits: { heading: 'Kredit', - original: 'Eredeti mod által', + original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: @@ -5982,43 +6003,43 @@ const HexplorationMod = (() => { const TRANSLATION$a = { titles: { - ready: "L'esplorazione è pronta.", - settings: 'Impostazioni di esplorazione', + ready: 'Hexploration è pronto.', + settings: 'Impostazioni di Hexploration', languages: 'Scegli una lingua', pageSettings: 'Impostazioni pagina: {page}', - status: 'Stato esplorazione: {page}', - help: 'Comandi di esplorazione', - confirm: 'Per favore conferma', + status: 'Stato di Hexploration: {page}', + help: 'Comandi di Hexploration', + confirm: 'Conferma', }, discovery: { title: 'Posizione scoperta', }, menu: { - draw: 'Disegno', - reveal: 'Rivelare e nascondere', + draw: 'Disegna', + reveal: 'Rivela e nascondi', locations: 'Posizioni', - tools: 'Utensili', - layerInUse: 'Nuovi esagoni vengono disegnati su {layer}.', + tools: 'Strumenti', + layerInUse: 'I nuovi esagoni vengono disegnati sul {layer}.', pageSettingsHelp: 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', }, buttons: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', undo: 'Annulla riempimento', - reveal: 'Svelare', - conceal: 'Nascondere', - explore: 'Esplorare', + reveal: 'Rivela', + conceal: 'Nascondi', + explore: 'Esplora', revealPage: 'Rivela pagina', resetPage: 'Reimposta pagina', mark: 'Segna posizione', - unmark: 'Deseleziona', - name: 'Nome esadecimale', + unmark: 'Rimuovi segno', + name: 'Nomina esagono', settings: 'Impostazioni', - pageSettings: 'Impostazioni della pagina', + pageSettings: 'Impostazioni pagina', status: 'Stato', rescan: 'Nuova scansione', - calibrate: 'Calibrare', + calibrate: 'Calibra', calibrateReset: 'Ripristina calibrazione', help: 'Aiuto', change: 'Modifica', @@ -6030,36 +6051,36 @@ const HexplorationMod = (() => { name: 'Nome della posizione (lascia vuoto per cancellare)', }, values: { - on: 'SU', - off: 'Spento', + on: 'Attivo', + off: 'Disattivo', none: 'Nessuno', hexLayer: { auto: 'Automatico (in primo piano se disponibile)', - foreground: 'strato di primo piano', - objects: 'strato di token', + foreground: 'livello in primo piano', + objects: 'livello dei segnalini', }, revealBy: { - players: 'Gettoni del giocatore', - characters: 'Segnalini personaggio', - all: 'Tutti i gettoni', + players: 'Segnalini dei giocatori', + characters: 'Segnalini dei personaggi', + all: 'Tutti i segnalini', }, revealMode: { - clear: 'Chiaro', - glimpse: 'Occhiata', + clear: 'Elimina', + glimpse: 'Intravedi', }, announce: { all: 'Tutti', - gm: 'Solo GM', - off: 'Spento', + gm: 'Solo il GM', + off: 'Disattivo', }, orientation: { - vertical: 'Esadecimale (V)', - horizontal: 'Esadecimale (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Riempire', + fill: 'Riempi', fillInverse: 'Riempimento inverso', - conceal: 'Nascondere', + conceal: 'Nascondi', }, }, settings: { @@ -6068,12 +6089,12 @@ const HexplorationMod = (() => { desc: 'Lingua per menu, messaggi e dispense.', }, hexLayer: { - label: 'Strato esagonale', - desc: 'Dove vengono tracciati nuovi esagoni. Auto prova il livello in primo piano (sopra i token) e torna al livello token se il gioco non lo supporta.', + label: 'Livello degli esagoni', + desc: 'Dove vengono disegnati i nuovi esagoni. Automatico prova il livello in primo piano (sopra i segnalini) e ripiega sul livello dei segnalini se il gioco non lo supporta.', }, fillColor: { label: 'Colore riempimento', - desc: 'Colore dei nuovi esagoni. Utilizzare rgba() per esadecimali trasparenti, ad esempio rgba(0,0,0,0.8).', + desc: 'Colore dei nuovi esagoni. Usa rgba() per esagoni trasparenti, ad esempio rgba(0,0,0,0.8).', }, strokeColor: { label: 'Colore del bordo', @@ -6084,19 +6105,19 @@ const HexplorationMod = (() => { desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', }, glimpseColor: { - label: 'Colore scorcio', - desc: 'Gli esagoni colorati cambiano in quando vengono intravisti (modalità di rivelazione Glimpse). Utilizza un colore rgba() trasparente.', + label: 'Colore degli esagoni intravisti', + desc: 'Colore che assumono gli esagoni intravisti (modalità di rivelazione Intravedi). Usa un colore rgba() trasparente.', }, strokeWidth: { label: 'Larghezza del bordo', desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', }, maxDistance: { - label: 'Distanza di rivelazione esadecimale', + label: 'Distanza di rivelazione degli esagoni', desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', }, revealDistance: { - label: 'Distanza visiva', + label: 'Distanza di vista', desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', }, lineOfSight: { @@ -6112,40 +6133,40 @@ const HexplorationMod = (() => { desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', }, revealMode: { - label: 'Modalità Rivela', - desc: 'Pulito rimuove gli esagoni in vista. Glimpse li rende invece trasparenti; vengono rimossi quando un token vi entra.', + label: 'Modalità di rivelazione', + desc: 'Elimina rimuove gli esagoni in vista. Intravedi invece li rende trasparenti; vengono rimossi quando un segnalino vi entra.', }, announce: { - label: 'Annunciare le scoperte', + label: 'Annuncia le scoperte', desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', }, pingDiscoveries: { - label: 'Scoperte del ping', + label: 'Ping sulle scoperte', desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', }, hideCoveredTokens: { - label: 'Nascondi i token coperti', + label: 'Nascondi i segnalini coperti', desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', }, }, status: { engine: 'Motore di gioco', grid: 'Griglia', - layer: 'Strato esagonale', + layer: 'Livello degli esagoni', hexes: 'Esagoni', named: 'Esagoni con nome', - icons: 'Gettoni di posizione', + icons: 'Segnalini di posizione', glimpsed: 'Esagoni intravisti', pending: 'Posizioni in attesa di riempimento', calibrated: 'Calibrato', - overrides: "La pagina esegue l'override", - undo: 'Annulla disponibile', + overrides: 'Sostituzioni di pagina', + undo: 'Annullamento disponibile', }, messages: { filled: 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', - revealedPage: 'Ogni esadecimale sulla pagina è stato rivelato ({count}).', + revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', @@ -6165,11 +6186,11 @@ const HexplorationMod = (() => { 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: - 'Le tue mappe esadecimali Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Rescan su ogni pagina della mappa esadecimale.', + 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', pruned: - 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Rescan sulla pagina per riprenderne gli esagoni.', + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Nuova scansione sulla pagina per riprenderne gli esagoni.', readyHint: - 'Digita !esplorazione nel menu o apri il volantino "Esplorazione - Mazzo di comandi".', + 'Digita !hexploration per il menu, oppure apri la dispensa "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -6179,9 +6200,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Impossibile trovare la pagina su cui lavorare.', - notHex: 'Questa pagina non utilizza una griglia esadecimale.', + notHex: 'Questa pagina non usa una griglia esagonale.', noPolygons: 'Seleziona una o più forme disegnate da riempire.', - emptyArea: "L'area selezionata non contiene centri esadecimali.", + emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', @@ -6198,8 +6219,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', - notHex: - 'Imposta la griglia della pagina su Esadecimale (V) o Esadecimale (H) in Impostazioni pagina.', + notHex: 'Imposta la griglia della pagina su Hex (V) o Hex (H) nelle Impostazioni pagina.', noPolygons: "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", emptyArea: @@ -6210,7 +6230,7 @@ const HexplorationMod = (() => { unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: - 'Aggancia un gettone al centro di un esagono e selezionalo. Seleziona un secondo token agganciato a un esagono vicino nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.', + 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', @@ -6233,21 +6253,20 @@ const HexplorationMod = (() => { pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: - "Ricostruisci l'elenco esadecimale della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', - journal: 'Ricostruisci le dispense del mazzo di aiuto e di comando.', + journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', handout: 'Le istruzioni complete si trovano nel volantino "{name}".', }, deck: { - subtitle: 'Mazzo di comando', drawDesc: - "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla inverte l'ultimo riempimento.", + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla riempimento annulla l'ultimo riempimento.", revealDesc: - 'Seleziona esagoni, forme o gettoni per rivelarli o coprirli nuovamente. Esplora rivela i token selezionati come se si fossero spostati.', + 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', toolsDesc: @@ -6268,9 +6287,9 @@ const HexplorationMod = (() => { steps: [ 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", - 'Seleziona le forme e fai clic su Compila il mazzo di comandi (o digita! Hexploration fill). Le forme sono sostituite da esagoni.', - 'Facoltativo: prima di riempire, seleziona i token per i luoghi importanti e fai clic su Segna posizione. Sono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', - 'Muovi un gettone giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di Vista, vengono rivelati.', + 'Seleziona le forme e fai clic su Riempi nel Command Deck (oppure digita !hexploration fill). Le forme vengono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i segnalini dei luoghi importanti e fai clic su Segna posizione. Vengono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un segnalino giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di vista, vengono rivelati.', ], }, commands: { @@ -6283,29 +6302,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Come funziona la rivelazione', points: [ - 'Solo i gettoni sul livello dei gettoni rivelano gli esagoni. Quali token contano è stabilito da Tokens That Reveal: token del giocatore per impostazione predefinita, quindi il GM può spostare i mostri senza scoprire la mappa.', - 'Un gettone rivela ogni esagono che copre (i gettoni grandi ne coprono diversi) e, con Rivela lungo il percorso attivato, ogni esagono sul percorso lungo il quale è stato trascinato, compresi i waypoint.', - 'La Distanza di Vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con la Linea di Vista attiva, un esagono viene rivelato solo se nel mezzo non si trova alcun esagono coperto.', - "La distanza di rivelazione esadecimale viene memorizzata sugli esagoni man mano che vengono disegnati. Quegli esagoni vengono rivelati solo dall'interno di quel numero di esagoni, per quanto lontano possa vedere un segnalino. Usalo per montagne o foreste che nascondono ciò che c'è dietro di loro.", - 'Nella modalità Glimpse, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un token vi entra.', - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", - "L'API non segnala le mosse effettuate da altri mod. Le mosse TokenMod vengono rilevate automaticamente; per altre mod, seleziona i token e fai clic su Esplora o chiama Hexploration.revealAround(token) dalla tua mod.", + 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + "La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con Linea di vista attiva, un esagono viene rivelato solo se in mezzo non c'è alcun esagono coperto.", + "La Distanza di rivelazione degli esagoni viene memorizzata sugli esagoni nel momento in cui vengono disegnati. Quegli esagoni vengono rivelati solo da non più di quel numero di esagoni di distanza, per quanto lontano possa vedere un segnalino. Usala per montagne o foreste che nascondono ciò che c'è dietro.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra.', + 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', + "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", ], }, locations: { heading: 'Esagoni e posizioni con nome', points: [ - 'Segna posizione trasforma i token selezionati in posizioni nascoste. Un gettone già sotto un esagono viene immediatamente nascosto; altrimenti viene nascosto dal riempimento successivo che lo ricopre.', + 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', - "Nome esadecimale dà un nome a un esagono senza token. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", - "Annunciare le Scoperte sceglie se tutti, solo il GM o nessuno vedono l'annuncio. Ping Discoveries sposta anche la visuale dei giocatori sulla posizione.", + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], }, settings: { heading: 'Impostazioni', intro: - 'Modifica le impostazioni con !hexploration set (o il pulsante Impostazioni). Il livello esadecimale, i token rivelanti e la lingua possono essere impostati anche nella pagina delle impostazioni del Mod.', + 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', colName: 'Collocamento', colDesc: 'Descrizione', @@ -6315,18 +6334,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legacy', points: [ "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", - "Con Livello esadecimale impostato su Auto, gli esagoni vengono disegnati sul livello in primo piano, sopra i token, in modo che i giocatori non possano vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene utilizzato il livello token.", - "Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non si allineano con la griglia di una pagina, aggancia un token al centro dell'esagono, selezionalo e fai clic su Calibra. Seleziona due token negli esagoni vicini della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione esadecimale.", - 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai token di posizione.', + "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", + 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', ], }, upgrading: { heading: 'Aggiornamento dalla versione 1', points: [ 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', - 'Le mappe esadecimali, i nomi, i token di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'Le mappe a esagoni, i nomi, i segnalini di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', - 'La versione 1 permetteva a qualsiasi gettone che rappresentava un personaggio di rivelare esagoni. Imposta i gettoni che rivelano sui gettoni personaggio per mantenere quel comportamento.', + 'La versione 1 permetteva a qualsiasi segnalino che rappresentasse un personaggio di rivelare esagoni. Imposta Segnalini che rivelano su Segnalini dei personaggi per mantenere quel comportamento.', ], colV1: 'Comando della versione 1', colV2: 'Comando della versione 2', @@ -6334,10 +6353,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Risoluzione dei problemi', points: [ - 'Non succede nulla quando un token si muove: controlla che il token sia sul token layer e corrisponda a Tokens That Reveal e che la pagina abbia esagoni (stato!Hexploration).', - 'Gli esagoni sono spostati rispetto alla griglia: usa Calibra, quindi controlla con un gettone su alcuni esagoni sulla mappa.', - 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Rescan sulla pagina.', - "Riempi dice che l'area non ha centri esadecimali: la forma deve contenere il centro di almeno un esagono.", + 'Non succede nulla quando un segnalino si muove: controlla che il segnalino sia sul livello dei segnalini e corrisponda a Segnalini che rivelano, e che la pagina abbia esagoni (!hexploration status).', + 'Gli esagoni sono sfalsati rispetto alla griglia: usa Calibra, poi controlla con un segnalino su alcuni esagoni in vari punti della mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Nuova scansione sulla pagina.', + "Riempi indica che l'area non contiene centri di esagono: la forma deve contenere il centro di almeno un esagono.", 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', ], }, @@ -6345,7 +6364,7 @@ const HexplorationMod = (() => { heading: 'Lingue', body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", colLanguage: 'Lingua', - colNative: 'Nome nativo', + colNative: 'Nome originale', colCode: 'Codice', }, credits: { @@ -6361,61 +6380,61 @@ const HexplorationMod = (() => { const TRANSLATION$9 = { titles: { - ready: 'H探索の準備は完了です。', - settings: 'H探索設定', - languages: '言語を選択してください', + ready: 'Hexploration の準備ができました。', + settings: 'Hexploration 設定', + languages: '言語の選択', pageSettings: 'ページ設定: {page}', - status: 'H探索ステータス: {page}', - help: 'H探索コマンド', + status: 'Hexploration ステータス: {page}', + help: 'Hexploration コマンド', confirm: 'ご確認ください', }, discovery: { title: '場所が発見されました', }, menu: { - draw: '描く', + draw: '描画', reveal: '表示と非表示', - locations: '所在地', + locations: '場所', tools: 'ツール', layerInUse: '新しいヘクスが {layer} に描画されています。', pageSettingsHelp: 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', }, buttons: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', undo: '塗りつぶしを元に戻す', - reveal: '明らかにする', + reveal: '表示', conceal: '隠す', - explore: '探検する', - revealPage: 'ページを公開', + explore: '探索', + revealPage: 'ページを全表示', resetPage: 'ページをリセット', - mark: '位置をマークする', - unmark: 'マークを外す', - name: '名前の 16 進数', + mark: '場所としてマーク', + unmark: 'マーク解除', + name: 'ヘクスに名前を付ける', settings: '設定', pageSettings: 'ページ設定', - status: '状態', + status: 'ステータス', rescan: '再スキャン', - calibrate: '校正する', - calibrateReset: 'キャリブレーションをリセットする', + calibrate: '調整', + calibrateReset: '調整をリセット', help: 'ヘルプ', - change: '変化', + change: '変更', menu: 'メニュー', - clearOverrides: 'オーバーライドのクリア', - confirmReset: 'はい、すべてのヘクスを削除します', + clearOverrides: '上書きを解除', + confirmReset: 'はい、すべてのヘクスを削除', }, prompts: { name: '場所の名前 (クリアするには空白のままにします)', }, values: { - on: 'の上', + on: 'オン', off: 'オフ', none: 'なし', hexLayer: { - auto: '自動 (利用可能な場合は前景)', + auto: '自動（可能なら前景レイヤー）', foreground: '前景レイヤー', - objects: 'トークン層', + objects: 'トークンレイヤー', }, revealBy: { players: 'プレイヤートークン', @@ -6423,21 +6442,21 @@ const HexplorationMod = (() => { all: 'すべてのトークン', }, revealMode: { - clear: 'クリア', - glimpse: '垣間見る', + clear: '除去', + glimpse: '透過', }, announce: { - all: 'みんな', + all: '全員', gm: 'GMのみ', off: 'オフ', }, orientation: { - vertical: 'ヘックス(V)', - horizontal: '六角(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '埋める', - fillInverse: '逆塗りつぶし', + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', conceal: '隠す', }, }, @@ -6447,8 +6466,8 @@ const HexplorationMod = (() => { desc: 'メニュー、メッセージ、配布資料の言語。', }, hexLayer: { - label: 'ヘックスレイヤー', - desc: '新しいヘクスが描画される場所。 Auto はフォアグラウンド レイヤー (トークンの上) を試行し、ゲームがサポートしていない場合はトークン レイヤーにフォールバックします。', + label: 'ヘクスのレイヤー', + desc: '新しいヘクスを描画する場所。自動では前景レイヤー（トークンの上）を試し、ゲームが対応していない場合はトークンレイヤーを使用します。', }, fillColor: { label: '塗りつぶしの色', @@ -6463,19 +6482,19 @@ const HexplorationMod = (() => { desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', }, glimpseColor: { - label: '垣間見える色', - desc: 'チラッと見ると、ヘクスの色が に変わります (チラ見せモード)。シースルーの rgba() カラーを使用します。', + label: '透過色', + desc: '透過したときにヘクスが変わる色（表示モード「透過」）。半透明の rgba() カラーを使用してください。', }, strokeWidth: { label: '枠線の幅', desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', }, maxDistance: { - label: '16進数の表示距離', + label: 'ヘクスの公開距離', desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', }, revealDistance: { - label: '視距離', + label: '視界距離', desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', }, lineOfSight: { @@ -6483,42 +6502,42 @@ const HexplorationMod = (() => { desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', }, revealPath: { - label: 'パスに沿って表示', + label: '経路に沿って表示', desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', }, revealBy: { - label: '明らかにするトークン', - desc: 'トークン レイヤー上のどのトークンがヘックスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + label: '公開するトークン', + desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { - label: 'リビールモード', - desc: 'クリアは視界内のヘクスを削除します。 Glimpse では代わりにシースルーになります。トークンが入ると削除されます。', + label: '公開モード', + desc: '除去は視界内のヘクスを取り除きます。透過は代わりにヘクスを半透明にし、トークンが入ると取り除きます。', }, announce: { - label: '発見の発表', + label: '発見を通知', desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', }, pingDiscoveries: { - label: 'Ping の発見', + label: '発見地点をピン', desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', }, hideCoveredTokens: { - label: 'カバーされたトークンを非表示にする', + label: '覆われたトークンを隠す', desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', }, }, status: { engine: 'ゲームエンジン', grid: 'グリッド', - layer: 'ヘックスレイヤー', + layer: 'ヘクスレイヤー', hexes: 'ヘクス', named: '名前付きヘクス', - icons: '位置トークン', - glimpsed: '垣間見えるヘクス', - pending: '埋まりを待っている場所', - calibrated: '校正済み', + icons: '場所トークン', + glimpsed: '透過中のヘクス', + pending: '塗りつぶし待ちの場所', + calibrated: '調整済み', overrides: 'ページの上書き', - undo: '元に戻すことが可能', + undo: '元に戻せる操作', }, messages: { filled: @@ -6526,7 +6545,7 @@ const HexplorationMod = (() => { revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘックスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', @@ -6544,11 +6563,11 @@ const HexplorationMod = (() => { 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘックス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: - 'メニューに「!hexploration」と入力するか、配布資料「Hexploration - コマンドデッキ」を開きます。', + 'メニューを開くには !hexploration と入力するか、配布資料 "Hexploration - Command Deck" を開きます。', }, warnings: { foregroundUnavailable: @@ -6558,7 +6577,7 @@ const HexplorationMod = (() => { }, errors: { noPage: '作業するページが見つかりませんでした。', - notHex: 'このページでは 16 進グリッドは使用されていません。', + notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', emptyArea: '選択した領域には六角中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', @@ -6577,7 +6596,7 @@ const HexplorationMod = (() => { }, hints: { noPage: '作業したいページを開くか、ページ上で何かを選択します。', - notHex: 'ページ設定でページグリッドを 16 進数 (V) または 16 進数 (H) に設定します。', + notHex: 'ページ設定でページのグリッドを Hex (V) または Hex (H) に設定してください。', noPolygons: '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', @@ -6586,9 +6605,9 @@ const HexplorationMod = (() => { unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', calibrateNeedsTokens: - 'トークンをヘクスの中心にスナップして選択します。同じ行 (16 進数 V) または列 (16 進数 H) の隣接するヘクスにスナップされた 2 番目のトークンを選択して、16 進数のサイズも修正します。', + 'トークンをヘクスの中心にスナップして選択します。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにスナップした 2 つ目のトークンも選択すると、ヘクスのサイズも補正されます。', calibrateFailed: - '2 つのトークンは、同じ行 (16 進数 V) または同じ列 (16 進数 H) に、少なくとも 1 進数離れていなければなりません。', + '2 つのトークンは同じ行 (Hex V) または同じ列 (Hex H) にあり、少なくとも 1 ヘクス離れている必要があります。', unexpected: '詳細は API コンソールのログに記載されています。', }, help: { @@ -6607,21 +6626,20 @@ const HexplorationMod = (() => { set: '設定を変更するか、すべての設定を表示します。', pageSet: '現在のページでのみ公開設定をオーバーライドします。', pageClear: '現在のページのオーバーライドを削除します。', - rescan: 'たとえば、ページまたはゲームをコピーした後、ページの 16 進数リストを再構築します。', + rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', - journal: 'ヘルプとコマンドデッキの配布資料を再構築します。', + journal: 'ヘルプと Command Deck の配布資料を再構築します。', help: 'このリストを表示します。', handout: '完全な手順は配布資料「{name}」に記載されています。', }, deck: { - subtitle: 'コマンドデッキ', drawDesc: - '領域の周囲に図形を描画し、選択して塗りつぶします。元に戻すと、最後の塗りつぶしが元に戻ります。', + '領域の周囲に図形を描き、選択して塗りつぶします。「塗りつぶしを元に戻す」で最後の塗りつぶしを取り消せます。', revealDesc: - 'ヘックス、シェイプ、またはトークンを選択して、それらを再度表示またはカバーします。 Explore では、選択したトークンの周囲が移動したかのように表示されます。', + 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: @@ -6630,21 +6648,21 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'バージョン', - subtitle: 'Roll20 のヘックスごとの探索', + subtitle: 'Roll20 のヘクスごとの探索', footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', overview: { heading: '概要', - body: 'Hexploration は、不透明なヘクスでヘクス マップをカバーします。パーティが移動すると、パーティが通過するヘクス (および必要に応じてパーティの周囲のヘクス) が削除されるため、マップは一度に 1 ヘクスずつ明らかになります。隠し場所はヘクスの下に配置することができ、見つかった場合にはアナウンスされます。 Jumpgate および Legacy ゲームでは、任意のサイズの 16 進数 (V) および 16 進数 (H) グリッドで動作します。', + body: 'Hexploration は、ヘクスマップを不透明なヘクスで覆います。パーティが移動すると、通過したヘクス（必要に応じてその周囲のヘクスも）が取り除かれ、マップが 1 ヘクスずつ明らかになります。隠し場所をヘクスの下に配置でき、見つかるとアナウンスされます。Jumpgate と Legacy の両方のゲームで、任意のサイズの Hex (V) および Hex (H) グリッドで動作します。', demo: '短いデモを見る (バージョン 1 から)', }, quickStart: { heading: 'クイックスタート', steps: [ - 'グリッドが 16 進数 (V) または 16 進数 (H) に設定されているページを開きます。', + 'グリッドが Hex (V) または Hex (H) に設定されたページを開きます。', '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', - '図形を選択し、コマンド デッキで [塗りつぶし] をクリックします (または !hexploration fill と入力します)。形状は六角形に置き換えられます。', - 'オプション: 入力する前に、重要な場所のトークンを選択し、「場所をマーク」をクリックします。それらはヘクスの下に隠されており、発見されると発表されます。', - 'プレイヤートークンを移動します。通過するすべてのヘクスと、その視程距離内のヘクスが表示されます。', + '図形を選択し、Command Deck の「塗りつぶし」をクリックします（または !hexploration fill と入力します）。図形がヘクスに置き換わります。', + '任意: 塗りつぶす前に、重要な場所のトークンを選択して「場所としてマーク」をクリックします。それらはヘクスの下に隠され、発見されるとアナウンスされます。', + 'プレイヤートークンを移動します。通過したすべてのヘクスと、その視界距離内のヘクスが表示されます。', ], }, commands: { @@ -6657,40 +6675,40 @@ const HexplorationMod = (() => { revealing: { heading: '暴露の仕組み', points: [ - 'トークン層上のトークンのみがヘクスを明らかにします。どのトークンの数は、デフォルトでは明らかにするトークン: プレイヤー トークンによって設定されるため、GM はマップを明らかにすることなくモンスターを移動できます。', - 'トークンは、それがカバーするすべてのヘクスを表示し (大きなトークンは複数のヘクスをカバーします)、経路に沿って表示をオンにすると、ウェイポイントを含む、ドラッグされたルート上のすべてのヘクスが表示されます。', - '視程距離により、各ヘクスの周囲のヘクスが明らかになります。 Line of Sight がオンの場合、ヘクスは間に覆われたヘクスがない場合にのみ表示されます。', - 'ヘクス表示距離は、ヘクスが描画されるときにヘクスに保存されます。これらのヘクスは、トークンがどれだけ遠くまで見えても、その多くのヘクス内からのみ明らかにされます。背後にあるものを隠してしまう山や森に使用します。', - 'Glimpse モードでは、視界内のヘクスは消えるのではなく透明になり、トークンがヘクスに入ると削除されます。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', - 'API は他の MOD による動きを報告しません。 TokenMod の動きは自動的に取得されます。他の MOD の場合は、トークンを選択して [Explore] をクリックするか、独自の MOD から Hexploration.revealAround(token) を呼び出します。', + 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', + 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを表示します。「視線」がオンの場合、間に覆われたヘクスがないときだけヘクスが表示されます。', + '「ヘクスの公開距離」は、ヘクスを描画するときにそのヘクスに保存されます。それらのヘクスは、トークンがどれだけ遠くまで見えても、その数のヘクス以内からしか表示されません。背後を隠す山や森に使用します。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。', + 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', + 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', ], }, locations: { heading: '名前付きヘクスと場所', points: [ - '場所をマークすると、選択したトークンが非表示の場所に変わります。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、それを覆う次の塗りつぶしによって隠されます。', + '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', - 'Name Hex はトークンなしでヘックスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが公開されたときにアナウンスされます。', - '「発見の発表」では、発表を全員が見るか、GM のみが見るか、誰も見ないかを選択します。 Ping Discovery は、プレイヤーの視界をその場所に移動します。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], }, settings: { heading: '設定', intro: - '!hexploration set (または設定ボタン) で設定を変更します。 Hex Layer、Tokens That Reveal、言語も Mod の設定ページで設定できます。', + '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', colKey: '鍵', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', }, jumpgate: { - heading: 'ジャンプゲートとレガシー', + heading: 'Jumpgate と Legacy', points: [ 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', - 'ヘックス レイヤーを自動に設定すると、ヘックスは前景レイヤーのトークンの上に描画されるため、プレイヤーはその下にあるものを見ることができません。フォアグラウンド レイヤーが使用できない場合は、代わりにトークン レイヤーが使用されます。', - 'Jumpgate は数学的に規則的なヘクスを描画しますが、これはレガシー ヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃っていない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (16 進 V) または列 (16 進 H) の隣接するヘクスにある 2 つのトークンを選択して、16 進サイズも修正します。', + '「ヘクスのレイヤー」が「自動」の場合、ヘクスは前景レイヤー（トークンの上）に描画されるため、プレイヤーはその下にあるものを見ることができません。前景レイヤーが使用できない場合は、代わりにトークンレイヤーが使用されます。', + 'Jumpgate は数学的に正確な正六角形のヘクスを描画するため、Legacy のヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃わない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにある 2 つのトークンを選択すると、ヘクスのサイズも補正されます。', 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', ], }, @@ -6698,9 +6716,9 @@ const HexplorationMod = (() => { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘックス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', - 'バージョン 1 では、キャラクターを表すトークンにヘクスが表示されます。その動作を維持するには、[公開するトークン] を [文字トークン] に設定します。', + 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], colV1: 'バージョン1のコマンド', colV2: 'バージョン 2 コマンド', @@ -6708,10 +6726,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'トラブルシューティング', points: [ - 'トークンが移動しても何も起こりません。トークンがトークン レイヤー上にあり、明らかにするトークンと一致すること、およびページにヘクスがあること (!hexploration ステータス) を確認してください。', - 'ヘクスはグリッドからオフセットされています。キャリブレーションを使用して、マップ上のいくつかのヘクスでトークンを使用してチェックします。', - 'ページまたはゲームをコピーした後、ヘックスが表示されなくなりました。ページで再スキャンを実行してください。', - '塗りつぶしは、エリアに六角形の中心がないことを示します。形状には少なくとも 1 つの六角形の中心が含まれている必要があります。', + 'トークンを動かしても何も起こらない: トークンがトークンレイヤー上にあり「公開するトークン」の設定に合っていること、ページにヘクスがあること（!hexploration status）を確認してください。', + 'ヘクスがグリッドからずれている: 「調整」を使い、マップ上のいくつかのヘクスにトークンを置いて確認してください。', + 'ページまたはゲームをコピーした後、ヘクスが表示されなくなりました。ページで再スキャンを実行してください。', + '「塗りつぶし」で領域にヘクスの中心がないと表示される: 図形には少なくとも 1 つのヘクスの中心が含まれている必要があります。', 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', ], }, @@ -6719,12 +6737,12 @@ const HexplorationMod = (() => { heading: '言語', body: '!hexploration set language で言語を選択します。利用可能な言語:', colLanguage: '言語', - colNative: 'ネイティブネーム', + colNative: '現地語での名称', colCode: 'コード', }, credits: { heading: 'クレジット', - original: 'オリジナルMODによる', + original: 'オリジナル版の作者', maintainer: 'バージョン 2 の保守者', marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', support: @@ -6735,19 +6753,19 @@ const HexplorationMod = (() => { const TRANSLATION$8 = { titles: { - ready: '탐색이 준비되었습니다.', - settings: '탐색 설정', - languages: '언어를 선택하세요', + ready: 'Hexploration이 준비되었습니다.', + settings: 'Hexploration 설정', + languages: '언어 선택', pageSettings: '페이지 설정: {page}', - status: '탐색 상태: {page}', - help: '탐색 명령', + status: 'Hexploration 상태: {page}', + help: 'Hexploration 명령어', confirm: '확인해주세요', }, discovery: { - title: '발견된 위치', + title: '위치 발견', }, menu: { - draw: '그리다', + draw: '그리기', reveal: '공개 및 숨기기', locations: '위치', tools: '도구', @@ -6756,35 +6774,35 @@ const HexplorationMod = (() => { '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', }, buttons: { - fill: '채우다', - fillInverse: '역 채우기', - undo: '채우기 실행 취소', - reveal: '드러내다', - conceal: '숨기다', - explore: '탐구하다', - revealPage: '페이지 공개', - resetPage: '페이지 재설정', + fill: '채우기', + fillInverse: '반전 채우기', + undo: '채우기 취소', + reveal: '공개', + conceal: '숨기기', + explore: '탐색', + revealPage: '페이지 전체 공개', + resetPage: '페이지 초기화', mark: '위치 표시', unmark: '표시 해제', - name: '이름 헥스', + name: '헥스 이름 지정', settings: '설정', pageSettings: '페이지 설정', status: '상태', rescan: '다시 스캔', - calibrate: '교정', - calibrateReset: '교정 재설정', - help: '돕다', - change: '변화', + calibrate: '보정', + calibrateReset: '보정 초기화', + help: '도움말', + change: '변경', menu: '메뉴', clearOverrides: '재정의 지우기', - confirmReset: '예, 모든 16진수를 제거합니다.', + confirmReset: '예, 모든 헥스 제거', }, prompts: { name: '위치 이름(지우려면 비워 두세요)', }, values: { - on: '~에', - off: '끄다', + on: '켜짐', + off: '꺼짐', none: '없음', hexLayer: { auto: '자동(사용 가능한 경우 전경)', @@ -6797,22 +6815,22 @@ const HexplorationMod = (() => { all: '모든 토큰', }, revealMode: { - clear: '분명한', - glimpse: '일견', + clear: '제거', + glimpse: '반투명', }, announce: { - all: '모든 사람', + all: '모두', gm: 'GM 전용', - off: '끄다', + off: '꺼짐', }, orientation: { - vertical: '16진수(V)', - horizontal: '16진수(H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: '채우다', - fillInverse: '역 채우기', - conceal: '숨기다', + fill: '채우기', + fillInverse: '반전 채우기', + conceal: '숨기기', }, }, settings: { @@ -6821,12 +6839,12 @@ const HexplorationMod = (() => { desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', }, hexLayer: { - label: '육각 레이어', - desc: '새로운 육각형이 그려지는 곳. 자동은 전경 레이어(토큰 위)를 시도하고 게임이 지원하지 않으면 토큰 레이어로 대체합니다.', + label: '헥스 레이어', + desc: '새 헥스를 그릴 위치입니다. 자동은 전경 레이어(토큰 위)를 먼저 시도하고, 게임이 지원하지 않으면 토큰 레이어를 사용합니다.', }, fillColor: { label: '채우기 색상', - desc: '새로운 육각형의 색상입니다. 투명한 16진수에는 rgba()를 사용합니다(예: rgba(0,0,0,0.8)).', + desc: '새 헥스의 색상입니다. 비쳐 보이는 헥스를 원하면 rgba()를 사용하세요(예: rgba(0,0,0,0.8)).', }, strokeColor: { label: '테두리 색상', @@ -6837,19 +6855,19 @@ const HexplorationMod = (() => { desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', }, glimpseColor: { - label: '미리보기 색상', - desc: '엿볼 때 색상 육각형이 로 변경됩니다(Glimpse 공개 모드). 투명한 rgba() 색상을 사용하세요.', + label: '반투명 색상', + desc: '반투명 상태가 된 헥스의 색상입니다(반투명 공개 모드). 비쳐 보이는 rgba() 색상을 사용하세요.', }, strokeWidth: { label: '테두리 너비', desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', }, maxDistance: { - label: '16진수 공개 거리', + label: '헥스 공개 거리', desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', }, revealDistance: { - label: '시거리', + label: '시야 거리', desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', }, lineOfSight: { @@ -6861,36 +6879,36 @@ const HexplorationMod = (() => { desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', }, revealBy: { - label: '공개되는 토큰', - desc: '토큰 레이어의 토큰은 헥스(플레이어가 제어하는 ​​토큰, 모든 캐릭터를 나타내는 토큰 또는 모든 토큰)를 나타냅니다.', + label: '공개하는 토큰', + desc: '토큰 레이어의 어떤 토큰이 헥스를 공개할지 정합니다: 플레이어가 조종하는 토큰, 캐릭터를 나타내는 토큰 또는 모든 토큰.', }, revealMode: { label: '공개 모드', - desc: 'Clear는 시야 내의 타일을 제거합니다. Glimpse는 대신 투명하게 만듭니다. 토큰이 입력되면 제거됩니다.', + desc: '제거는 시야 안의 헥스를 없앱니다. 반투명은 대신 헥스를 비쳐 보이게 하며, 토큰이 들어가면 제거합니다.', }, announce: { - label: '발견 발표', + label: '발견 알림', desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', }, pingDiscoveries: { - label: '핑 발견', + label: '발견 위치 핑', desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', }, hideCoveredTokens: { - label: '적용 토큰 숨기기', - desc: 'Roll20은 육각형 위에 이름, 막대 및 아우라를 그립니다. 켜져 있으면 덮여 있는 헥스 아래에 있는 토큰의 이름이 플레이어에게 표시되고 막대와 오라가 꺼지고, 덮혀 있으면 다시 켜집니다.', + label: '덮인 토큰 숨기기', + desc: 'Roll20은 이름, 막대, 오라를 헥스 위에 그립니다. 켜져 있으면 덮인 헥스 아래에 있는 토큰의 플레이어에게 보이는 이름, 막대, 오라를 끄고, 덮개가 벗겨지면 다시 켭니다.', }, }, status: { engine: '게임 엔진', grid: '그리드', - layer: '육각층', + layer: '헥스 레이어', hexes: '헥스', named: '명명된 헥스', icons: '위치 토큰', - glimpsed: '살짝 엿본 육각형', + glimpsed: '반투명 헥스', pending: '채우기를 기다리는 위치', - calibrated: '교정됨', + calibrated: '보정됨', overrides: '페이지 재정의', undo: '실행 취소 가능', }, @@ -6898,16 +6916,16 @@ const HexplorationMod = (() => { filled: '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', revealed: '공개된 헥스: {count}.', - revealedPage: '페이지의 모든 16진수가 공개되었습니다({count}).', + revealedPage: '페이지의 모든 헥스를 공개했습니다({count}).', confirmReset: - '"{page}"({count})에서 모든 16진수를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 실행 취소하면 되돌릴 수 없습니다.', - resetPage: '페이지에서 제거된 16진수: {count}.', + '"{page}"의 모든 헥스({count})를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 이 작업은 실행 취소로 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거한 헥스: {count}.', undone: - '마지막 채우기가 취소되었습니다. 제거된 16진수: {removed}. 스타일이 변경된 16진수 복원: {restored}.', + '마지막 채우기를 취소했습니다. 제거한 헥스: {removed}. 원래 스타일로 복원한 헥스: {restored}.', named: '"{name}"이라는 헥스: {count}.', unnamed: '지워진 이름: {count}.', marked: - '기존 16진수에 숨겨진 위치: {attached}. 이를 포함하는 다음 채우기를 기다리는 중: {pending}.', + '기존 헥스 아래에 숨긴 위치: {attached}. 이 위치를 덮을 다음 채우기를 기다리는 위치: {pending}.', unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: @@ -6918,10 +6936,11 @@ const HexplorationMod = (() => { '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: - 'Heexploration 1.x 육각형 지도가 업그레이드되었습니다. 이 게임이 레거시 게임에서 복사된 경우 각 육각형 지도 페이지에서 다시 스캔을 실행하세요.', + 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', pruned: - '더 이상 존재하지 않고 잊혀진 저장된 헥스: {dropped}. 이 게임이나 페이지가 복사된 경우 페이지에서 다시 스캔을 실행하여 16진수를 다시 선택하세요.', - readyHint: '메뉴에 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 엽니다.', + '더 이상 존재하지 않아 잊어버린 저장된 헥스: {dropped}. 이 게임이나 페이지를 복사했다면 해당 페이지에서 다시 스캔을 실행해 헥스를 다시 인식시키세요.', + readyHint: + '메뉴를 보려면 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 여세요.', }, warnings: { foregroundUnavailable: @@ -6932,7 +6951,7 @@ const HexplorationMod = (() => { noPage: '작업할 페이지를 찾을 수 없습니다.', notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', - emptyArea: '선택한 영역에는 16진수 중심이 포함되어 있지 않습니다.', + emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', @@ -6949,18 +6968,18 @@ const HexplorationMod = (() => { }, hints: { noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', - notHex: '페이지 설정에서 페이지 격자를 16진수(V) 또는 16진수(H)로 설정하세요.', + notHex: '페이지 설정에서 페이지 격자를 Hex (V) 또는 Hex (H)로 설정하세요.', noPolygons: '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', - unknownCommand: '명령 목록을 보려면 !heexploration help를 입력하세요.', - unknownSetting: '모든 설정을 보려면 !heexploration set를 입력하세요.', + unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: - '토큰을 육각형 중앙에 놓고 선택합니다. 동일한 행(16진수 V) 또는 열(16진수 H)의 인접한 16진수에 스냅된 두 번째 토큰을 선택하여 16진수 크기도 수정합니다.', + '토큰 하나를 헥스 중심에 스냅한 뒤 선택하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 스냅한 두 번째 토큰도 선택하면 헥스 크기까지 보정합니다.', calibrateFailed: - '두 개의 토큰은 동일한 행(Hex V) 또는 동일한 열(Hex H)에 있어야 하며 최소 16진수 떨어져 있어야 합니다.', + '두 토큰은 같은 행(Hex V) 또는 같은 열(Hex H)에 있어야 하며, 적어도 헥스 한 칸 이상 떨어져 있어야 합니다.', unexpected: '세부정보는 API 콘솔 로그에 있습니다.', }, help: { @@ -6969,53 +6988,52 @@ const HexplorationMod = (() => { fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', - revealPage: '공지 없이 페이지의 모든 16진수를 공개합니다.', - conceal: '선택한 모양과 토큰 아래 영역을 다시 16진수로 덮습니다.', + revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', - resetPage: '페이지의 모든 16진수를 제거합니다(먼저 묻습니다).', + resetPage: '페이지의 모든 헥스를 제거합니다(먼저 확인합니다).', name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', set: '설정을 변경하거나 모든 설정을 표시합니다.', pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', pageClear: '현재 페이지의 재정의를 제거합니다.', - rescan: '예를 들어 페이지나 게임을 복사한 후 페이지의 16진수 목록을 다시 작성합니다.', - calibrate: - '16진수 중심에 맞춰진 하나 또는 두 개의 선택된 토큰을 사용하여 16진수 그리드를 정렬합니다.', + rescan: + '페이지의 헥스 목록을 다시 만듭니다. 예를 들어 페이지나 게임을 복사한 뒤에 사용합니다.', + calibrate: '헥스 중심에 스냅된 토큰 한두 개를 선택해 헥스 격자를 맞춥니다.', calibrateReset: '현재 페이지의 보정을 제거합니다.', - status: '현재 페이지에 대해 Heexploration이 알고 있는 내용을 보여줍니다.', - journal: '도움말 및 명령 데크 유인물을 재구성합니다.', + status: '현재 페이지에 대해 Hexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 Command Deck 유인물을 다시 만듭니다.', help: '이 목록을 보여주세요.', handout: '전체 지침은 "{name}" 유인물에 있습니다.', }, deck: { - subtitle: '커맨드 덱', drawDesc: - '영역 주위에 모양을 그리고 선택한 다음 채웁니다. 실행 취소는 마지막 채우기를 되돌립니다.', + '영역 주위에 도형을 그리고 선택한 다음 채웁니다. 채우기 취소는 마지막 채우기를 되돌립니다.', revealDesc: - '육각형, 모양 또는 토큰을 선택하여 다시 표시하거나 덮으세요. 선택한 토큰 주변을 마치 이동한 것처럼 탐색해 보세요.', + '헥스, 도형 또는 토큰을 선택해 공개하거나 다시 덮습니다. 탐색은 선택한 토큰이 그곳으로 막 이동한 것처럼 주변을 공개합니다.', locationsDesc: - '토큰을 선택하여 16진수 아래 위치로 숨기세요. 16진수 또는 토큰을 선택하여 16진수 이름을 지정하세요.', + '토큰을 선택해 헥스 아래의 위치로 숨기세요. 헥스나 토큰을 선택해 헥스에 이름을 붙이세요.', toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', footer: '전체 지침은 "{help}" 유인물을 참조하세요.', }, handout: { versionLabel: '버전', - subtitle: 'Roll20의 16진수 탐색', + subtitle: 'Roll20용 헥스 단위 탐험', footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', overview: { heading: '개요', - body: 'Heexploration은 불투명한 육각형 지도를 포함합니다. 파티가 이동함에 따라 그들이 통과하는 헥스(원하는 경우 주변의 헥스)가 제거되므로 지도는 한 번에 한 헥스씩 발견됩니다. 숨겨진 위치는 육각형 아래에 배치할 수 있으며 발견되면 알려줍니다. Jumpgate 및 Legacy 게임, 모든 크기의 Hex(V) 및 Hex(H) 그리드에서 작동합니다.', + body: 'Hexploration은 헥스 지도를 불투명한 헥스로 덮습니다. 파티가 이동하면 지나간 헥스(원하면 주변 헥스도)가 제거되어 지도가 한 헥스씩 드러납니다. 숨겨진 위치를 헥스 아래에 둘 수 있으며, 발견되면 알려줍니다. Jumpgate와 Legacy 게임 모두에서, 모든 크기의 Hex (V) 및 Hex (H) 그리드에서 작동합니다.', demo: '짧은 데모 보기(버전 1부터)', }, quickStart: { heading: '빠른 시작', steps: [ - '그리드가 16진수(V) 또는 16진수(H)로 설정된 페이지를 엽니다.', + '격자가 Hex (V) 또는 Hex (H)로 설정된 페이지를 엽니다.', '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', - '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !heexploration fill을 입력). 모양이 육각형으로 대체됩니다.', - '선택사항: 작성하기 전에 중요한 장소에 대한 토큰을 선택하고 위치 표시를 클릭하세요. 그것들은 육각형 아래에 숨겨져 있으며 발견되면 알려줍니다.', - '플레이어 토큰을 이동합니다. 통과하는 모든 헥스와 가시 거리 내에 있는 헥스가 공개됩니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !hexploration fill 입력). 모양이 헥스로 바뀝니다.', + '선택 사항: 채우기 전에 중요한 장소의 토큰을 선택하고 위치 표시를 클릭하세요. 토큰은 헥스 아래에 숨겨지고 발견되면 알려집니다.', + '플레이어 토큰을 움직입니다. 토큰이 지나가는 모든 헥스와 시야 거리 안의 헥스가 공개됩니다.', ], }, commands: { @@ -7028,40 +7046,40 @@ const HexplorationMod = (() => { revealing: { heading: '공개 작동 방식', points: [ - '토큰 레이어의 토큰만 16진수를 나타냅니다. 공개하는 토큰(Tokens That Reveal)에 의해 설정된 토큰 수는 기본적으로 플레이어 토큰이므로 GM은 지도를 열지 않고도 몬스터를 이동할 수 있습니다.', + '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', - 'Hex Reveal Distance는 그려진 헥스에 저장됩니다. 이러한 헥스는 토큰이 볼 수 있는 거리에 관계없이 그 만큼의 헥스 내에서만 드러납니다. 뒤에 있는 것이 숨겨져 있는 산이나 숲에 사용하세요.', - 'Glimpse 모드에서는 시야 내의 육각형이 사라지는 대신 투명해지며, 토큰이 들어갈 때 제거됩니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + '헥스 공개 거리는 헥스를 그릴 때 그 헥스에 저장됩니다. 그런 헥스는 토큰이 얼마나 멀리 볼 수 있든 그 헥스 수 이내에서만 공개됩니다. 뒤에 있는 것을 가리는 산이나 숲에 사용하세요.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다.', + 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { heading: '명명된 육각형 및 위치', points: [ - 'Mark Location은 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨집니다. 그렇지 않으면 그것을 덮는 다음 채우기에 의해 숨겨집니다.', + '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', - 'Name Hex는 토큰 없이 16진수에 이름을 부여합니다. 이름은 GM 레이어의 라벨로 GM에게 표시되며 헥스가 공개되면 알려집니다.', - '발견 발표는 모든 사람, GM만 볼 수 있는지, 아니면 아무도 볼 수 없는지 선택합니다. Ping Discoveries는 또한 플레이어의 시야를 해당 위치로 이동시킵니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', ], }, settings: { heading: '설정', intro: - '!heexploration set(또는 설정 버튼)을 사용하여 설정을 변경하세요. Hex Layer, Tokens That Reveal 및 언어도 Mod의 설정 페이지에서 설정할 수 있습니다.', + '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', colKey: '열쇠', colName: '환경', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, jumpgate: { - heading: '점프게이트와 레거시', + heading: 'Jumpgate와 Legacy', points: [ - 'Heexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 두 편집기 중 하나에서 그린 모양을 채울 수 있습니다.', - 'Hex Layer를 Auto로 설정하면 토큰 위의 전경 레이어에 육각형이 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없는 경우 토큰 레이어가 대신 사용됩니다.', - 'Jumpgate는 레거시 육각형과 모양이 약간 다른 수학적으로 규칙적인 육각형을 그립니다. 16진수가 페이지의 그리드와 일치하지 않으면 토큰을 16진수 중앙에 맞춰 선택하고 보정을 클릭하세요. 동일한 행(Hex V) 또는 열(Hex H)의 인접한 헥스에서 두 개의 토큰을 선택하여 16진수 크기도 수정합니다.', + 'Hexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 어느 편집기에서 그린 도형이든 채울 수 있습니다.', + '헥스 레이어를 자동으로 설정하면 헥스가 토큰 위의 전경 레이어에 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없으면 대신 토큰 레이어를 사용합니다.', + 'Jumpgate는 수학적으로 정확한 정육각형 헥스를 그리므로 Legacy 헥스와 모양이 약간 다릅니다. 헥스가 페이지 격자와 맞지 않으면 토큰 하나를 헥스 중심에 스냅하고 선택한 뒤 보정을 클릭하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 있는 토큰 두 개를 선택하면 헥스 크기까지 보정합니다.', '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', ], }, @@ -7069,9 +7087,9 @@ const HexplorationMod = (() => { heading: '버전 1에서 업그레이드', points: [ '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', - '기존 16진수 지도, 이름, 위치 토큰 및 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', - 'Heexploration_menu 매크로를 포함한 버전 1 명령은 여전히 ​​작동합니다.', - '버전 1에서는 문자를 나타내는 모든 토큰이 16진수를 표시할 수 있습니다. 해당 행동을 유지하려면 공개되는 토큰을 캐릭터 토큰으로 설정하세요.', + '기존 헥스 지도, 이름, 위치 토큰과 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Hexploration_menu 매크로를 포함한 버전 1 명령은 여전히 작동합니다.', + '버전 1에서는 캐릭터를 나타내는 토큰이면 무엇이든 헥스를 공개할 수 있었습니다. 이 동작을 유지하려면 공개하는 토큰을 캐릭터 토큰으로 설정하세요.', ], colV1: '버전 1 명령', colV2: '버전 2 명령', @@ -7079,23 +7097,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: '문제 해결', points: [ - '토큰이 이동할 때 아무 일도 일어나지 않습니다. 토큰이 토큰 레이어에 있고 공개되는 토큰과 일치하는지, 페이지에 16진수(!hexploration 상태)가 있는지 확인하세요.', - '육각형은 그리드에서 오프셋됩니다. 보정을 사용한 다음 지도 전체에 걸쳐 몇 개의 육각형에 대한 토큰을 확인하십시오.', - '페이지나 게임을 복사한 후 Hexes가 표시되지 않습니다. 페이지에서 다시 검색을 실행하세요.', - '채우기는 해당 영역에 16진수 중심이 없음을 나타냅니다. 모양에는 최소한 하나의 16진수 중심이 포함되어야 합니다.', + '토큰을 움직여도 아무 일도 일어나지 않음: 토큰이 토큰 레이어에 있고 공개하는 토큰 설정과 일치하는지, 페이지에 헥스가 있는지(!hexploration status) 확인하세요.', + '헥스가 격자에서 어긋남: 보정을 사용한 다음, 지도 곳곳의 몇몇 헥스에 토큰을 놓아 확인하세요.', + '페이지나 게임을 복사한 뒤 헥스가 더 이상 공개되지 않음: 해당 페이지에서 다시 스캔을 실행하세요.', + '채우기에서 영역에 헥스 중심이 없다고 나옴: 모양 안에 적어도 헥스 하나의 중심이 들어 있어야 합니다.', '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', ], }, languages: { heading: '언어', - body: '!heexploration set 언어로 언어를 선택하세요. 사용 가능한 언어:', + body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', - colNative: '본명', + colNative: '현지어 이름', colCode: '암호', }, credits: { heading: '크레딧', - original: '원본 모드 작성자:', + original: '원본 모드 제작자', maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', support: @@ -7106,84 +7124,84 @@ const HexplorationMod = (() => { const TRANSLATION$7 = { titles: { - ready: 'Heksploracja jest gotowa.', - settings: 'Ustawienia Heksploracji', + ready: 'Hexploration jest gotowy.', + settings: 'Ustawienia Hexploration', languages: 'Wybierz język', pageSettings: 'Ustawienia strony: {page}', - status: 'Stan heksploracji: {page}', - help: 'Komendy Heksploracji', + status: 'Stan Hexploration: {page}', + help: 'Polecenia Hexploration', confirm: 'Proszę potwierdzić', }, discovery: { - title: 'Lokalizacja odkryta', + title: 'Odkryto lokalizację', }, menu: { - draw: 'Rysować', - reveal: 'Odkryj i ukryj', + draw: 'Rysowanie', + reveal: 'Odkrywanie i ukrywanie', locations: 'Lokalizacje', tools: 'Narzędzia', - layerInUse: 'Nowe heksy są rysowane na {layer}.', + layerInUse: 'Warstwa, na której rysowane są nowe heksy: {layer}.', pageSettingsHelp: 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', }, buttons: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', undo: 'Cofnij wypełnienie', - reveal: 'Ujawnić', - conceal: 'Ukryć', - explore: 'Badać', + reveal: 'Odkryj', + conceal: 'Zakryj', + explore: 'Eksploruj', revealPage: 'Odkryj stronę', resetPage: 'Zresetuj stronę', - mark: 'Zaznacz lokalizację', - unmark: 'Odznacz', - name: 'Imię Hex', + mark: 'Oznacz lokalizację', + unmark: 'Usuń oznaczenie', + name: 'Nazwij heks', settings: 'Ustawienia', pageSettings: 'Ustawienia strony', status: 'Status', rescan: 'Skanuj ponownie', - calibrate: 'Kalibrować', + calibrate: 'Kalibruj', calibrateReset: 'Zresetuj kalibrację', help: 'Pomoc', - change: 'Zmiana', + change: 'Zmień', menu: 'Menu', - clearOverrides: 'Wyczyść zastąpienia', + clearOverrides: 'Usuń nadpisania', confirmReset: 'Tak, usuń wszystkie heksy', }, prompts: { name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', }, values: { - on: 'NA', - off: 'Wyłączony', - none: 'Nic', + on: 'Włączone', + off: 'Wyłączone', + none: 'Brak', hexLayer: { auto: 'Auto (pierwszy plan, jeśli jest dostępny)', foreground: 'warstwa pierwszego planu', - objects: 'warstwa tokenów', + objects: 'warstwa żetonów', }, revealBy: { players: 'Żetony graczy', characters: 'Żetony postaci', - all: 'Wszystkie tokeny', + all: 'Wszystkie żetony', }, revealMode: { - clear: 'Jasne', - glimpse: 'Dojrzeć', + clear: 'Usuwanie', + glimpse: 'Przebłysk', }, announce: { all: 'Wszyscy', - gm: "Tylko GM'a", - off: 'Wyłączony', + gm: 'Tylko MG', + off: 'Wyłączone', }, orientation: { - vertical: 'Sześciokąt (V)', - horizontal: 'Sześciokąt (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Wypełnić', + fill: 'Wypełnij', fillInverse: 'Odwrotne wypełnienie', - conceal: 'Ukryć', + conceal: 'Zakryj', }, }, settings: { @@ -7192,8 +7210,8 @@ const HexplorationMod = (() => { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa szesnastkowa', - desc: 'Gdzie rysowane są nowe heksy. Automatycznie próbuje warstwy pierwszego planu (nad tokenami) i wraca do warstwy tokenów, jeśli gra jej nie obsługuje.', + label: 'Warstwa heksagonów', + desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { label: 'Kolor wypełnienia', @@ -7209,18 +7227,18 @@ const HexplorationMod = (() => { }, glimpseColor: { label: 'Kolor przebłysku', - desc: 'Kolor heksów zmienia się na po dostrzeżeniu (tryb ujawnienia przez spojrzenie). Użyj przezroczystego koloru rgba().', + desc: 'Kolor, jaki przyjmują heksy objęte przebłyskiem (tryb odkrywania Przebłysk). Użyj przezroczystego koloru rgba().', }, strokeWidth: { label: 'Szerokość obramowania', desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość ujawnienia heksadecymalnego', + label: 'Odległość odkrywania heksagonów', desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', }, revealDistance: { - label: 'Odległość wzroku', + label: 'Zasięg wzroku', desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', }, lineOfSight: { @@ -7228,42 +7246,42 @@ const HexplorationMod = (() => { desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', }, revealPath: { - label: 'Odkryj wzdłuż ścieżki', + label: 'Odkrywaj wzdłuż ścieżki', desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { - label: 'Żetony, które ujawniają', + label: 'Żetony odkrywające', desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', }, revealMode: { - label: 'Tryb ujawnienia', - desc: 'Clear usuwa heksy w zasięgu wzroku. Zamiast tego Glimpse sprawia, że ​​są przezroczyste; są usuwane, gdy wejdzie do nich żeton.', + label: 'Tryb odkrywania', + desc: 'Usuwanie usuwa heksy w zasięgu wzroku. Przebłysk zamiast tego czyni je przezroczystymi; są usuwane, gdy wejdzie na nie żeton.', }, announce: { - label: 'Ogłoś odkrycia', + label: 'Ogłaszaj odkrycia', desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', }, pingDiscoveries: { - label: 'Odkrycia pingowe', + label: 'Pinguj odkrycia', desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', }, hideCoveredTokens: { - label: 'Ukryj zakryte tokeny', + label: 'Ukrywaj zakryte żetony', desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', }, }, status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa sześciokątna', + layer: 'Warstwa heksagonów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', - glimpsed: 'Prześwietlone heksy', - pending: 'Lokalizacje oczekujące na zapełnienie', - calibrated: 'Kalibrowane', - overrides: 'Zastąpienia strony', - undo: 'Cofnij dostępne', + glimpsed: 'Heksy w przebłysku', + pending: 'Lokalizacje czekające na wypełnienie', + calibrated: 'Skalibrowano', + overrides: 'Nadpisania strony', + undo: 'Można cofnąć', }, messages: { filled: @@ -7289,10 +7307,11 @@ const HexplorationMod = (() => { 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: - 'Twoje heksowe mapy Heexploration 1.x zostały ulepszone. Jeśli ta gra została skopiowana z gry Legacy, uruchom ponowne skanowanie na każdej stronie mapy heksadecymalnej.', + 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', pruned: - 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom ponowne skanowanie strony, aby ponownie zebrać heksy.', - readyHint: 'Wpisz !hexploration w menu lub otwórz ulotkę „Hexploration – Talia poleceń”.', + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom „Skanuj ponownie” na stronie, aby ponownie odnaleźć jej heksy.', + readyHint: + 'Wpisz !hexploration, aby otworzyć menu, lub otwórz materiał informacyjny "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -7302,9 +7321,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', - notHex: 'Na tej stronie nie jest używana siatka szesnastkowa.', + notHex: 'Ta strona nie używa siatki heksowej.', noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', - emptyArea: 'Wybrany obszar nie zawiera żadnych środków heksadecymalnych.', + emptyArea: 'Zaznaczony obszar nie zawiera żadnych środków heksów.', tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', @@ -7348,25 +7367,24 @@ const HexplorationMod = (() => { resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', mark: 'Zamień wybrane żetony w ukryte lokalizacje.', - unmark: 'Zatrzymaj wybrane tokeny jako ukryte lokalizacje.', + unmark: 'Spraw, by zaznaczone żetony przestały być ukrytymi lokalizacjami.', set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', pageClear: 'Usuń zastąpienia bieżącej strony.', - rescan: 'Odbuduj listę szesnastkową strony, na przykład po skopiowaniu strony lub gry.', + rescan: 'Odbuduj listę heksów strony, na przykład po skopiowaniu strony lub gry.', calibrate: 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', calibrateReset: 'Usuń kalibrację bieżącej strony.', - status: 'Pokaż, co Heexploration wie o bieżącej stronie.', - journal: 'Odbuduj materiały informacyjne dotyczące talii pomocy i dowodzenia.', + status: 'Pokaż, co Hexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne „Pomoc” i „Command Deck”.', help: 'Pokaż tę listę.', handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', }, deck: { - subtitle: 'Pokład dowodzenia', drawDesc: 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', revealDesc: - 'Wybierz heksy, kształty lub żetony, aby ponownie je odkryć lub zakryć. Przeglądaj odkrycia wokół wybranych żetonów, tak jakby się poruszyły.', + 'Zaznacz heksy, kształty lub żetony, aby je odkryć lub ponownie zakryć. „Eksploruj” odkrywa okolicę zaznaczonych żetonów, jakby właśnie się przesunęły.', locationsDesc: 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', toolsDesc: @@ -7388,28 +7406,28 @@ const HexplorationMod = (() => { steps: [ 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', - 'Wybierz kształty i kliknij Wypełnij talię poleceń (lub wpisz !hexploration fill). Kształty są zastępowane przez heksy.', - 'Opcjonalnie: przed wypełnieniem wybierz żetony dla ważnych miejsc i kliknij Zaznacz lokalizację. Są ukryte pod heksami i ogłaszane po odkryciu.', - 'Przesuń żeton gracza. Każdy heks, przez który przechodzi, oraz heks w zasięgu jego wzroku, zostają ujawnione.', + 'Zaznacz kształty i kliknij „Wypełnij” w Command Deck (lub wpisz !hexploration fill). Kształty zostaną zastąpione heksami.', + 'Opcjonalnie: przed wypełnieniem zaznacz żetony ważnych miejsc i kliknij „Oznacz lokalizację”. Zostaną ukryte pod heksami i ogłoszone po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przejdzie, oraz heksy w jego zasięgu wzroku (ustawienie „Zasięg wzroku”) zostaną odkryte.', ], }, commands: { heading: 'Polecenia', intro: 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', - colCommand: 'Rozkaz', + colCommand: 'Polecenie', colDesc: 'Co to robi', }, revealing: { heading: 'Jak działa odkrywanie', points: [ - 'Tylko żetony na warstwie żetonów ujawniają heksy. Liczba żetonów jest ustalana przez Tokeny, które ujawniają: domyślnie są to żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', - 'Żeton odkrywa każdy heks, który obejmuje (duże żetony obejmują kilka), a przy włączonej opcji „Odkryj wzdłuż ścieżki” każdy heks na trasie, po której został przeciągnięty, łącznie z punktami orientacyjnymi.', - 'Odległość wzroku ujawnia heksy wokół każdego z tych heksów. Gdy pole widzenia jest włączone, heks zostaje ujawniony tylko wtedy, gdy pomiędzy nim nie znajduje się żaden zakryty heks.', - 'Odległość ujawnienia heksów jest zapisywana na heksach w miarę ich rysowania. Te heksy są odkrywane tylko z określonej liczby heksów, niezależnie od tego, jak daleko sięga żeton. Używaj go do gór lub lasów, które ukrywają to, co jest za nimi.', - 'W trybie Przejrzenia heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API nie raportuje ruchów wykonanych przez inne mody. Ruchy TokenMod są pobierane automatycznie; w przypadku innych modów wybierz tokeny i kliknij Eksploruj lub wywołaj Hexploration.revealAround(token) z własnego moda.', + 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów. Gdy „Linia wzroku” jest włączona, heks zostaje odkryty tylko wtedy, gdy między nim a żetonem nie leży żaden zakryty heks.', + '„Odległość odkrywania heksagonów” jest zapisywana na heksach w chwili ich rysowania. Takie heksy można odkryć tylko z odległości najwyżej tylu heksów, niezależnie od tego, jak daleko widzi żeton. Używaj jej dla gór lub lasów, które zasłaniają to, co jest za nimi.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', + 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', ], }, locations: { @@ -7418,15 +7436,15 @@ const HexplorationMod = (() => { 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - 'Nazwa Heks nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie GM i ogłaszana po odkryciu heksu.', - 'Announce Discoveries decyduje, czy wszyscy, tylko GM, czy nikt nie zobaczy ogłoszenia. Ping Discoveries przenosi także widok graczy na lokalizację.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmień ustawienia za pomocą zestawu !hexploration (lub przycisku Ustawienia). Warstwa heksów, ujawniające tokeny i język można również ustawić na stronie ustawień moda.', - colKey: 'Klawisz', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', @@ -7435,9 +7453,9 @@ const HexplorationMod = (() => { heading: 'Jumpgate i Dziedzictwo', points: [ 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy warstwa heksów jest ustawiona na wartość Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu nie jest dostępna, zamiast niej używana jest warstwa tokenów.', - 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksa, wybierz go i kliknij Kalibruj. Wybierz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby również skorygować rozmiar heksaksu.', - 'Kiedy strona lub gra zostanie skopiowana, jej heksy otrzymują nowe identyfikatory. Uruchom ponownie skanowanie na stronie, aby je ponownie zebrać wraz z etykietami z nazwami i tokenami lokalizacji.', + 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', + 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], }, upgrading: { @@ -7445,8 +7463,8 @@ const HexplorationMod = (() => { points: [ 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', - 'Polecenia wersji 1, w tym makro Heexploration_menu, nadal działają.', - 'Wersja 1 pozwala, aby dowolny żeton reprezentujący postać ujawniał heksy. Ustaw żetony, które ujawniają, na żetony postaci, aby zachować to zachowanie.', + 'Polecenia wersji 1, w tym makro Hexploration_menu, nadal działają.', + 'W wersji 1 heksy mógł odkrywać każdy żeton reprezentujący postać. Aby zachować to zachowanie, ustaw „Żetony odkrywające” na „Żetony postaci”.', ], colV1: 'Polecenie wersji 1', colV2: 'Polecenie wersji 2', @@ -7454,18 +7472,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Rozwiązywanie problemów', points: [ - 'Nic się nie dzieje, gdy token się porusza: sprawdź, czy token znajduje się na warstwie tokenów i pasuje do Tokenów, które ujawniają, oraz czy strona ma heksy (status!hexploration).', + 'Nic się nie dzieje, gdy żeton się porusza: sprawdź, czy żeton jest na warstwie żetonów i pasuje do ustawienia „Żetony odkrywające” oraz czy strona ma heksy (!hexploration status).', 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', - 'Heksy przestały się ujawniać po skopiowaniu strony lub gry: uruchom ponownie skanowanie na stronie.', - 'Wypełnienie mówi, że obszar nie ma środków heksów: kształt musi zawierać środek co najmniej jednego heksa.', + 'Heksy przestały się odkrywać po skopiowaniu strony lub gry: uruchom „Skanuj ponownie” na stronie.', + '„Wypełnij” zgłasza, że obszar nie zawiera środków heksów: kształt musi zawierać środek co najmniej jednego heksu.', 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', ], }, languages: { heading: 'Języki', - body: 'Wybierz język z ustawionym językiem !hexploration. Dostępne języki:', + body: 'Wybierz język poleceniem !hexploration set language. Dostępne języki:', colLanguage: 'Język', - colNative: 'Imię rodzime', + colNative: 'Nazwa rodzima', colCode: 'Kod', }, credits: { @@ -7481,46 +7499,46 @@ const HexplorationMod = (() => { const TRANSLATION$6 = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Definições do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Definições da página: {page}', - status: 'Estado de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Estado do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão a ser desenhados em {layer}.', + layerInUse: 'Os novos hexágonos estão a ser desenhados na {layer}.', pageSettingsHelp: 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', - settings: 'Configurações', - pageSettings: 'Configurações de página', - status: 'Estatuto', - rescan: 'Digitalizar novamente', + name: 'Nomear hexágono', + settings: 'Definições', + pageSettings: 'Definições da página', + status: 'Estado', + rescan: 'Reanalisar', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -7529,26 +7547,26 @@ const HexplorationMod = (() => { name: 'Nome do local (deixar em branco para limpar)', }, values: { - on: 'Em', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de fichas', }, revealBy: { - players: 'Tokens de jogador', + players: 'Fichas de jogador', characters: 'Fichas de personagem', - all: 'Todos os tokens', + all: 'Todas as fichas', }, revealMode: { - clear: 'Claro', - glimpse: 'Relance', + clear: 'Limpar', + glimpse: 'Vislumbre', }, announce: { all: 'Toda a gente', - gm: 'Apenas GM', + gm: 'Apenas o GM', off: 'Desligado', }, orientation: { @@ -7557,8 +7575,8 @@ const HexplorationMod = (() => { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { @@ -7567,8 +7585,8 @@ const HexplorationMod = (() => { desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', - desc: 'Onde são desenhados novos hexágonos. O Auto tenta a camada de primeiro plano (acima dos tokens) e volta à camada de tokens se o jogo não o suportar.', + label: 'Camada dos hexágonos', + desc: 'Onde são desenhados os novos hexágonos. Automático tenta a camada de primeiro plano (acima das fichas) e recorre à camada de fichas se o jogo não a suportar.', }, fillColor: { label: 'Cor de preenchimento', @@ -7583,15 +7601,15 @@ const HexplorationMod = (() => { desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Utilize uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Utilize uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -7607,37 +7625,37 @@ const HexplorationMod = (() => { desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', }, revealBy: { - label: 'Tokens que revelam', + label: 'Fichas que revelam', desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove os hexágonos à vista. O vislumbre torna-os transparentes; são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre torna-os transparentes; são removidos quando uma ficha entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', }, hideCoveredTokens: { - label: 'Ocultar tokens cobertos', + label: 'Ocultar fichas cobertas', desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', }, }, status: { engine: 'Motor de jogo', - grid: 'Rede', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + grid: 'Grelha', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Fichas de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Fichas de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais a aguardar preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -7646,7 +7664,7 @@ const HexplorationMod = (() => { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização regressam à camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -7664,10 +7682,11 @@ const HexplorationMod = (() => { 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Os seus mapas hexadecimais do Hexploration 1. x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute uma nova verificação na página para recuperar os seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos guardados que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute Reanalisar na página para recuperar os seus hexágonos.', + readyHint: + 'Escreva !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -7677,9 +7696,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não utiliza uma grelha hexadecimal.', + notHex: 'Esta página não utiliza uma grelha hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -7690,7 +7709,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', unexpected: 'Algo correu mal: {message}', }, @@ -7706,9 +7725,9 @@ const HexplorationMod = (() => { unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e seleccione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe uma ficha no centro de um hexágono e selecione-a. Selecione uma segunda ficha encaixada num hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'As duas fichas têm de estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log da consola da API.', }, help: { @@ -7720,8 +7739,9 @@ const HexplorationMod = (() => { 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: + 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -7729,34 +7749,33 @@ const HexplorationMod = (() => { pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grelha hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grelha hexagonal com uma ou duas fichas selecionadas encaixadas em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: - 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último enchimento.', + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para os revelar ou cobrir novamente. Explore as revelações em torno dos tokens selecionados como se se tivessem movido.', + 'Selecione hexágonos, formas ou fichas para os revelar ou voltar a cobrir. Explorar revela à volta das fichas selecionadas como se se tivessem movido.', locationsDesc: - 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Utilize o folheto "{deck}" para controlos de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos por onde passam (e, se preferir, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Os locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se desloca, os hexágonos por onde passa (e, se quiser, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Podem ser colocados locais escondidos sob os hexágonos, que são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -7764,9 +7783,9 @@ const HexplorationMod = (() => { steps: [ 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mover uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro da sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione fichas de locais importantes e clique em Marcar local. Ficam escondidas sob os hexágonos e são anunciadas quando descobertas.', + 'Mova uma ficha de jogador. Cada hexágono por onde passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -7779,29 +7798,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por defeito, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Estes hexágonos só são revelados dentro desse número de hexágonos, por mais longe que uma ficha consiga ver. Utilize-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + 'A Distância de revelação dos hexágonos é guardada nos hexágonos quando são desenhados. Esses hexágonos só são revelados a, no máximo, esse número de hexágonos de distância, por mais longe que uma ficha consiga ver. Utilize-a para montanhas ou florestas que escondem o que está por trás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'O Mark Location transforma os tokens selecionados em locais escondidos. Uma ficha que já esteja sob um hexágono é imediatamente ocultada; caso contrário, ficará oculto pelo próximo enchimento que o cobrir.', + 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. O Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as definições com !hexploration set (ou o botão Definições). A camada hexadecimal, os tokens que revelam e o idioma também podem ser definidos na página de definições do Mod.', + 'Altere as definições com !hexploration set (ou com o botão Definições). Camada dos hexágonos, Fichas que revelam e Idioma também podem ser definidos na página de definições do Mod.', colKey: 'Chave', colName: 'Definição', colDesc: 'Descrição', @@ -7811,18 +7830,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, será utilizada a camada de token.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grelha da página, encaixe um token num centro hexadecimal, seleccione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Rescan na página para os voltar a apanhar, juntamente com os seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com uma forma ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não ficarem alinhados com a grelha da página, encaixe uma ficha no centro de um hexágono, selecione-a e clique em Calibrar. Selecione duas fichas em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Reanalisar na página para os voltar a apanhar, juntamente com as suas etiquetas de nome e fichas de local.', ], }, upgrading: { heading: 'Atualização da versão 1', points: [ 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', - 'Os mapas hexadecimais, os nomes, os tokens de localização e as definições existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, fichas de localização e definições existentes são atualizados automaticamente no primeiro arranque.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitia que qualquer token que representasse uma personagem revelasse hexágonos. Defina os Tokens que Revelam como tokens de Personagem para manter este comportamento.', + 'A versão 1 permitia que qualquer ficha que representasse uma personagem revelasse hexágonos. Defina Fichas que revelam como Fichas de personagem para manter este comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -7830,10 +7849,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página tem hexágonos (status !hexploration).', - 'Os hexágonos são deslocados da grelha: usa Calibrar e verifica com um token alguns hexágonos no mapa.', - 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute uma nova verificação na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Nada acontece quando uma ficha se move: verifique se a ficha está na camada de fichas e corresponde a Fichas que revelam, e se a página tem hexágonos (!hexploration status).', + 'Os hexágonos estão desalinhados com a grelha: use Calibrar e verifique depois com uma ficha em alguns hexágonos do mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute Reanalisar na página.', + 'Preencher indica que a área não tem centros de hexágonos: a forma tem de conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', ], }, @@ -7841,7 +7860,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Idioma', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { @@ -7857,46 +7876,46 @@ const HexplorationMod = (() => { const TRANSLATION$5 = { titles: { - ready: 'A Hexploração está pronta.', - settings: 'Configurações de exploração', + ready: 'O Hexploration está pronto.', + settings: 'Configurações do Hexploration', languages: 'Escolha um idioma', pageSettings: 'Configurações da página: {page}', - status: 'Status de exploração: {page}', - help: 'Comandos de Hexploração', - confirm: 'Por favor confirme', + status: 'Status do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', }, discovery: { - title: 'Localização descoberta', + title: 'Local descoberto', }, menu: { - draw: 'Empate', + draw: 'Desenhar', reveal: 'Revelar e ocultar', locations: 'Locais', tools: 'Ferramentas', - layerInUse: 'Novos hexágonos estão sendo desenhados em {layer}.', + layerInUse: 'Novos hexágonos estão sendo desenhados na {layer}.', pageSettingsHelp: 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', }, buttons: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', + fillInverse: 'Preenchimento inverso', undo: 'Desfazer preenchimento', reveal: 'Revelar', - conceal: 'Esconder', + conceal: 'Ocultar', explore: 'Explorar', revealPage: 'Revelar página', resetPage: 'Redefinir página', - mark: 'Marcar localização', + mark: 'Marcar local', unmark: 'Desmarcar', - name: 'Nome hexadecimal', + name: 'Nomear hexágono', settings: 'Configurações', - pageSettings: 'Configurações de página', + pageSettings: 'Configurações da página', status: 'Status', - rescan: 'Digitalizar novamente', + rescan: 'Reescanear', calibrate: 'Calibrar', calibrateReset: 'Redefinir calibração', help: 'Ajuda', - change: 'Mudar', + change: 'Alterar', menu: 'Menu', clearOverrides: 'Limpar substituições', confirmReset: 'Sim, remover todos os hexágonos', @@ -7905,21 +7924,21 @@ const HexplorationMod = (() => { name: 'Nome do local (deixe em branco para limpar)', }, values: { - on: 'Sobre', + on: 'Ligado', off: 'Desligado', none: 'Nenhum', hexLayer: { auto: 'Automático (primeiro plano, se disponível)', foreground: 'camada de primeiro plano', - objects: 'camada de token', + objects: 'camada de tokens', }, revealBy: { players: 'Tokens de jogador', - characters: 'Fichas de personagem', + characters: 'Tokens de personagem', all: 'Todos os tokens', }, revealMode: { - clear: 'Claro', + clear: 'Limpar', glimpse: 'Vislumbre', }, announce: { @@ -7933,17 +7952,17 @@ const HexplorationMod = (() => { }, fillKind: { fill: 'Preencher', - fillInverse: 'Preenchimento Inverso', - conceal: 'Esconder', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', }, }, settings: { language: { - label: 'Linguagem', + label: 'Idioma', desc: 'Idioma para menus, mensagens e folhetos.', }, hexLayer: { - label: 'Camada hexadecimal', + label: 'Camada dos hexágonos', desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', }, fillColor: { @@ -7955,19 +7974,19 @@ const HexplorationMod = (() => { desc: 'Cor do contorno dos novos hexágonos.', }, labelColor: { - label: 'Cor da etiqueta', + label: 'Cor do rótulo', desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', }, glimpseColor: { - label: 'Vislumbre de cor', - desc: 'Os hexágonos coloridos mudam para quando vislumbrados (modo de revelação de vislumbre). Use uma cor rgba() transparente.', + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Use uma cor rgba() transparente.', }, strokeWidth: { label: 'Largura da borda', desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', }, maxDistance: { - label: 'Distância de revelação hexadecimal', + label: 'Distância de revelação dos hexágonos', desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', }, revealDistance: { @@ -7988,14 +8007,14 @@ const HexplorationMod = (() => { }, revealMode: { label: 'Modo de revelação', - desc: 'Limpar remove hexágonos à vista. O vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + desc: 'Limpar remove os hexágonos à vista. Vislumbre os torna transparentes; eles são removidos quando um token entra neles.', }, announce: { - label: 'Anuncie descobertas', + label: 'Anunciar descobertas', desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', }, pingDiscoveries: { - label: 'Descobertas de ping', + label: 'Pingar descobertas', desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', }, hideCoveredTokens: { @@ -8006,14 +8025,14 @@ const HexplorationMod = (() => { status: { engine: 'Motor de jogo', grid: 'Grade', - layer: 'Camada hexadecimal', - hexes: 'Feitiços', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', named: 'Hexágonos nomeados', - icons: 'Tokens de localização', - glimpsed: 'Feitiços vislumbrados', + icons: 'Tokens de local', + glimpsed: 'Hexágonos vislumbrados', pending: 'Locais aguardando preenchimento', calibrated: 'Calibrado', - overrides: 'Substituições de página', + overrides: 'Substituições da página', undo: 'Desfazer disponível', }, messages: { @@ -8022,7 +8041,7 @@ const HexplorationMod = (() => { revealed: 'Feitiços revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: - 'Remover todos os hexadecimais de "{page}" ({count})? Os tokens de localização retornam para a camada de tokens. Desfazer não pode reverter isso.', + 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', resetPage: 'Hexágonos removidos da página: {count}.', undone: 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', @@ -8040,10 +8059,11 @@ const HexplorationMod = (() => { 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: - 'Seus mapas hexadecimais do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Rescan em cada página do mapa hexadecimal.', + 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', pruned: - 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute uma nova varredura na página para recuperar seus hexágonos novamente.', - readyHint: 'Digite !hexploration no menu ou abra o folheto "Hexploration - Command Deck".', + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute Reescanear na página para recuperar seus hexágonos.', + readyHint: + 'Digite !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8053,9 +8073,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Não foi possível encontrar a página para trabalhar.', - notHex: 'Esta página não usa uma grade hexadecimal.', + notHex: 'Esta página não usa uma grade hexagonal.', noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', - emptyArea: 'A área selecionada não contém centros hexadecimais.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', @@ -8066,7 +8086,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', - calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados nos centros hexadecimais.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', unexpected: 'Algo deu errado: {message}', }, @@ -8082,13 +8102,13 @@ const HexplorationMod = (() => { unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: - 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token ajustado a um hexadecimal vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token encaixado em um hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', calibrateFailed: - 'Dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), separados por pelo menos um hexadecimal.', + 'Os dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', unexpected: 'Os detalhes estão no log do console da API.', }, help: { - menu: 'Mostre o cardápio.', + menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', @@ -8096,8 +8116,9 @@ const HexplorationMod = (() => { 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', - explore: 'Revele os tokens selecionados como se eles tivessem acabado de se mudar para lá.', - resetPage: 'Remova todos os hexadecimais da página (pergunta primeiro).', + explore: + 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta antes).', name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', mark: 'Transforme os tokens selecionados em locais ocultos.', unmark: 'Impede que os tokens selecionados sejam locais ocultos.', @@ -8105,34 +8126,33 @@ const HexplorationMod = (() => { pageSet: 'Substituir uma configuração de revelação somente na página atual.', pageClear: 'Remova as substituições da página atual.', rescan: - 'Reconstrua a lista hexadecimal da página, por exemplo, após copiar uma página ou jogo.', + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', calibrate: - 'Alinhe a grade hexadecimal com um ou dois tokens selecionados encaixados nos centros hexadecimais.', + 'Alinhe a grade hexagonal com um ou dois tokens selecionados encaixados em centros de hexágonos.', calibrateReset: 'Remova a calibração da página atual.', status: 'Mostre o que o Hexploration sabe sobre a página atual.', - journal: 'Reconstrua os folhetos da Ajuda e da Plataforma de Comando.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', help: 'Mostre esta lista.', handout: 'As instruções completas estão no folheto "{name}".', }, deck: { - subtitle: 'Convés de Comando', drawDesc: 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', revealDesc: - 'Selecione hexágonos, formas ou fichas para revelá-los ou cobri-los novamente. Explore as revelações em torno dos tokens selecionados como se eles tivessem se movido.', + 'Selecione hexágonos, formas ou tokens para revelá-los ou cobri-los novamente. Explorar revela ao redor dos tokens selecionados como se eles tivessem se movido.', locationsDesc: - 'Selecione fichas para ocultá-las como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { versionLabel: 'Versão', - subtitle: 'Exploração hexadecimal para Roll20', + subtitle: 'Exploração hexágono a hexágono para Roll20', footer: 'Use o folheto "{deck}" para controles de um clique.', overview: { heading: 'Visão geral', - body: 'Hexploração cobre um mapa hexadecimal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais eles passam (e, se preferir, os hexágonos ao seu redor) são removidos, então o mapa é descoberto um hexágono de cada vez. Locais ocultos podem ser colocados em hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais ele passa (e, se você quiser, os hexágonos ao redor) são removidos, de modo que o mapa é descoberto um hexágono por vez. Locais ocultos podem ser colocados sob os hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', demo: 'Assista a uma breve demonstração (da versão 1)', }, quickStart: { @@ -8140,9 +8160,9 @@ const HexplorationMod = (() => { steps: [ 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', - 'Selecione as formas e clique em Preencher no painel de comandos (ou digite !hexploration fill). As formas são substituídas por hexágonos.', - 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar Localização. Eles estão escondidos sob os hexágonos e anunciados quando descobertos.', - 'Mova uma ficha de jogador. Cada hexágono que ele passa e os hexágonos dentro de sua Distância de Visão são revelados.', + 'Selecione as formas e clique em Preencher no Command Deck (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar local. Eles ficam ocultos sob os hexágonos e são anunciados quando descobertos.', + 'Mova um token de jogador. Cada hexágono pelo qual ele passa e os hexágonos dentro da sua Distância de visão são revelados.', ], }, commands: { @@ -8155,31 +8175,31 @@ const HexplorationMod = (() => { revealing: { heading: 'Como funciona a revelação', points: [ - 'Apenas os tokens na camada de tokens revelam hexágonos. A contagem de fichas é definida por Tokens That Reveal: fichas de jogador por padrão, para que o Mestre possa mover monstros sem descobrir o mapa.', - 'Uma ficha revela cada hexágono que cobre (fichas grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono na rota pela qual foi arrastado, incluindo pontos de referência.', + 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', + 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', - 'A distância de revelação hexadecimal é armazenada em hexadecimais à medida que são desenhados. Esses hexágonos só são revelados dentro daquele número de hexágonos, não importa quão longe uma ficha possa ver. Use-o para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Glimpse, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando uma ficha entra neles.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + 'A Distância de revelação dos hexágonos é gravada nos hexágonos quando eles são desenhados. Esses hexágonos só são revelados a no máximo essa quantidade de hexágonos de distância, por mais longe que um token consiga ver. Use-a para montanhas ou florestas que escondem o que há atrás delas.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles.', + 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', ], }, locations: { heading: 'Hexes e locais nomeados', points: [ - 'Mark Location transforma os tokens selecionados em locais ocultos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ele ficará oculto pelo próximo preenchimento que o cobre.', + 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', - 'Name Hex dá um nome hexadecimal sem um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', - 'Anunciar Descobertas escolhe se todos, apenas o GM, ou ninguém verá o anúncio. Ping Discoveries também move a visão dos jogadores para o local.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], }, settings: { heading: 'Configurações', intro: - 'Altere as configurações com !hexploration set (ou o botão Configurações). Camada hexadecimal, tokens que revelam e idioma também podem ser definidos na página de configurações do Mod.', + 'Altere as configurações com !hexploration set (ou com o botão Configurações). Camada dos hexágonos, Tokens que revelam e Idioma também podem ser definidos na página de configurações do Mod.', colKey: 'Chave', - colName: 'Contexto', + colName: 'Configuração', colDesc: 'Descrição', perPage: '(Pode ser definido por página.)', }, @@ -8187,18 +8207,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate e Legado', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', - 'Com a camada hexadecimal definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de token será usada.', - 'Jumpgate desenha hexágonos matematicamente regulares, que têm uma forma ligeiramente diferente dos hexágonos Legacy. Se os hexágonos não estiverem alinhados com a grade da página, encaixe um token em um centro hexadecimal, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho hexadecimal.', - 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Rescan na página para pegá-los novamente, junto com seus rótulos de nome e tokens de localização.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com um formato ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não se alinharem com a grade da página, encaixe um token no centro de um hexágono, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Reescanear na página para recuperá-los, junto com seus rótulos de nome e tokens de local.', ], }, upgrading: { heading: 'Atualizando da versão 1', points: [ 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', - 'Mapas hexadecimais, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os mapas de hexágonos, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', - 'A versão 1 permitiu que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que Revelam como tokens de Personagem para manter esse comportamento.', + 'A versão 1 permitia que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que revelam como Tokens de personagem para manter esse comportamento.', ], colV1: 'Comando da versão 1', colV2: 'Comando da versão 2', @@ -8206,10 +8226,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solução de problemas', points: [ - 'Nada acontece quando um token se move: verifique se o token está na camada de token e corresponde aos Tokens That Reveal e se a página possui hexágonos (status !hexploration).', + 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', - 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute uma nova varredura na página.', - 'Fill diz que a área não tem centros hexadecimais: a forma deve conter o centro de pelo menos um hexadecimal.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', + 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', ], }, @@ -8217,7 +8237,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', colLanguage: 'Linguagem', - colNative: 'Nome nativo', + colNative: 'Nome original', colCode: 'Código', }, credits: { @@ -8233,84 +8253,84 @@ const HexplorationMod = (() => { const TRANSLATION$4 = { titles: { - ready: 'Геразведка готова.', + ready: 'Hexploration готова.', settings: 'Настройки Hexploration', languages: 'Выберите язык', pageSettings: 'Настройки страницы: {page}', - status: 'Статус гексоразведки: {page}', - help: 'Команды гексоразведки', + status: 'Статус Hexploration: {page}', + help: 'Команды Hexploration', confirm: 'Пожалуйста, подтвердите', }, discovery: { - title: 'Местоположение обнаружено', + title: 'Локация обнаружена', }, menu: { - draw: 'Рисовать', - reveal: 'Показать и скрыть', + draw: 'Рисование', + reveal: 'Раскрытие и скрытие', locations: 'Локации', tools: 'Инструменты', - layerInUse: 'Новые гексы рисуются на {layer}.', + layerInUse: 'Новые гексы рисуются на этом слое: {layer}.', pageSettingsHelp: 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', }, buttons: { - fill: 'Наполнять', + fill: 'Заполнить', fillInverse: 'Обратная заливка', undo: 'Отменить заливку', - reveal: 'Раскрывать', + reveal: 'Раскрыть', conceal: 'Скрыть', explore: 'Исследовать', - revealPage: 'Открыть страницу', + revealPage: 'Раскрыть страницу', resetPage: 'Сбросить страницу', - mark: 'Отметить местоположение', + mark: 'Отметить локацию', unmark: 'Снять отметку', - name: 'Шестнадцатеричное имя', + name: 'Назвать гекс', settings: 'Настройки', pageSettings: 'Настройки страницы', status: 'Статус', - rescan: 'Повторное сканирование', - calibrate: 'Калибровка', - calibrateReset: 'Сброс калибровки', - help: 'Помощь', - change: 'Изменять', + rescan: 'Пересканировать', + calibrate: 'Калибровать', + calibrateReset: 'Сбросить калибровку', + help: 'Справка', + change: 'Изменить', menu: 'Меню', - clearOverrides: 'Очистить переопределения', - confirmReset: 'Да, удалить все шестигранники', + clearOverrides: 'Сбросить переопределения', + confirmReset: 'Да, удалить все гексы', }, prompts: { name: 'Название местоположения (оставьте пустым, чтобы очистить)', }, values: { - on: 'На', - off: 'Выключенный', - none: 'Никто', + on: 'Вкл.', + off: 'Выкл.', + none: 'Нет', hexLayer: { - auto: 'Авто (на переднем плане, если доступно)', - foreground: 'передний слой', + auto: 'Авто (передний план, если доступен)', + foreground: 'слой переднего плана', objects: 'слой токенов', }, revealBy: { - players: 'Жетоны игроков', - characters: 'Жетоны персонажей', + players: 'Токены игроков', + characters: 'Токены персонажей', all: 'Все токены', }, revealMode: { - clear: 'Прозрачный', - glimpse: 'Случайно заметить', + clear: 'Очистка', + glimpse: 'Проблеск', }, announce: { - all: 'Каждый', - gm: 'только ГМ', - off: 'Выключенный', + all: 'Все', + gm: 'Только ГМ', + off: 'Выкл.', }, orientation: { - vertical: 'Шестигранник (В)', - horizontal: 'Шестигранник (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Наполнять', + fill: 'Заливка', fillInverse: 'Обратная заливка', - conceal: 'Скрыть', + conceal: 'Скрытие', }, }, settings: { @@ -8319,8 +8339,8 @@ const HexplorationMod = (() => { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Шестнадцатеричный слой', - desc: 'Где рисуются новые гексы. Автоматически пробует слой переднего плана (над жетонами) и возвращается к слою жетонов, если игра его не поддерживает.', + label: 'Слой шестиугольников', + desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', @@ -8331,19 +8351,19 @@ const HexplorationMod = (() => { desc: 'Цвет контура новых гексов.', }, labelColor: { - label: 'Цвет этикетки', + label: 'Цвет меток', desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', }, glimpseColor: { - label: 'Взгляд цвета', - desc: 'Цветные гексы меняются при взгляде (режим просмотра). Используйте прозрачный цвет rgba().', + label: 'Цвет проблеска', + desc: 'Цвет, который принимают гексы в режиме «Проблеск». Используйте полупрозрачный цвет rgba().', }, strokeWidth: { label: 'Ширина границы', desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Расстояние раскрытия шестигранника', + label: 'Дальность раскрытия шестиугольников', desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -8355,50 +8375,50 @@ const HexplorationMod = (() => { desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', }, revealPath: { - label: 'Показать вдоль пути', + label: 'Раскрывать вдоль пути', desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', }, revealBy: { - label: 'Жетоны, которые раскрывают', + label: 'Раскрывающие токены', desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', }, revealMode: { label: 'Режим раскрытия', - desc: 'Очистить удаляет гексы в пределах видимости. Вместо этого Glimpse делает их прозрачными; они удаляются, когда в них входит токен.', + desc: '«Очистка» удаляет гексы в пределах видимости. «Проблеск» вместо этого делает их полупрозрачными; они удаляются, когда в них входит токен.', }, announce: { label: 'Объявлять об открытиях', desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', }, pingDiscoveries: { - label: 'Пинг-открытия', + label: 'Пинговать находки', desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', }, hideCoveredTokens: { - label: 'Скрыть покрытые токены', + label: 'Скрывать токены под гексами', desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', }, }, status: { engine: 'Игровой движок', grid: 'Сетка', - layer: 'Шестнадцатеричный слой', - hexes: 'шестиугольники', - named: 'Именованные шестигранники', - icons: 'Жетоны местоположения', - glimpsed: 'Замеченные гексы', - pending: 'Места, ожидающие заполнения', - calibrated: 'Калиброванный', - overrides: 'Переопределения страниц', - undo: 'Отмена доступна', + layer: 'Слой гексов', + hexes: 'Гексы', + named: 'Именованные гексы', + icons: 'Токены локаций', + glimpsed: 'Гексы в проблеске', + pending: 'Локации, ожидающие заливки', + calibrated: 'Откалибровано', + overrides: 'Переопределения страницы', + undo: 'Доступна отмена', }, messages: { filled: 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', revealed: 'Обнаружены гексы: {count}.', - revealedPage: 'Раскрыты все шестнадцатеричные числа на странице ({count}).', + revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: - 'Удалить все шестнадцатеричные числа из "{page}" ({count})? Токены местоположения возвращаются на уровень токенов. Отмена не может отменить это.', + 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', resetPage: 'Со страницы удалены шестигранники: {count}.', undone: 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', @@ -8416,11 +8436,11 @@ const HexplorationMod = (() => { 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: - 'Ваши шестигранные карты Hexploration 1.x были обновлены. Если эта игра была скопирована из игры Legacy, запустите повторное сканирование на каждой странице шестнадцатеричной карты.', + 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', pruned: - 'Сохранены гексы, которые больше не существуют и были забыты: {dropped}. Если эта игра или страница были скопированы, запустите повторное сканирование страницы, чтобы снова найти ее шестигранники.', + 'Забыты сохранённые гексы, которых больше нет: {dropped}. Если эта игра или страница была скопирована, выполните «Пересканировать» на странице, чтобы снова найти её гексы.', readyHint: - 'Введите !hexploration в меню или откройте раздаточный материал «Hexploration — Command Deck».', + 'Введите !hexploration, чтобы открыть меню, или откройте раздаточный материал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8460,9 +8480,9 @@ const HexplorationMod = (() => { unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: - 'Прикрепите жетон к центру шестиугольника и выберите его. Выберите второй жетон, привязанный к соседнему шестиграннику в той же строке (шестнадцатеричный V) или столбце (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', + 'Привяжите токен к центру гекса и выделите его. Чтобы заодно исправить размер гекса, выделите второй токен, привязанный к соседнему гексу в той же строке (Hex V) или в том же столбце (Hex H).', calibrateFailed: - 'Два жетона должны находиться в одной строке (шестнадцатеричный V) или в одном столбце (шестнадцатеричный H), на расстоянии не менее одного шестигранника.', + 'Два токена должны находиться в одной строке (Hex V) или в одном столбце (Hex H) на расстоянии не менее одного гекса друг от друга.', unexpected: 'Подробности в журнале консоли API.', }, help: { @@ -8474,29 +8494,27 @@ const HexplorationMod = (() => { revealPage: 'Раскройте каждый гекс на странице без объявлений.', conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', - resetPage: 'Удалите все шестнадцатеричные числа на странице (сначала спрашивает).', + resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', pageSet: 'Переопределить настройку отображения только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', - rescan: - 'Перестройте шестнадцатеричный список страницы, например, после копирования страницы или игры.', + rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', - journal: 'Восстановите раздаточные материалы «Помощь» и «Командная колода».', + journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', help: 'Покажите этот список.', handout: 'Полные инструкции приведены в раздаточном материале «{name}».', }, deck: { - subtitle: 'Командная колода', drawDesc: - 'Нарисуйте фигуры вокруг области, выберите их, затем заполните. Отменить отменяет последнюю заливку.', + 'Обведите область фигурами, выделите их и нажмите «Заполнить». «Отменить заливку» отменяет последнюю заливку.', revealDesc: - 'Выбирайте шестигранники, фигуры или жетоны, чтобы снова показать или закрыть их. Исследуйте объекты вокруг выбранных жетонов, как если бы они переместились.', + 'Выделите гексы, фигуры или токены, чтобы раскрыть их или снова скрыть. «Исследовать» раскрывает гексы вокруг выбранных токенов, как если бы они туда переместились.', locationsDesc: 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', toolsDesc: @@ -8505,11 +8523,11 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Версия', - subtitle: 'Шестнадцатеричное исследование для Roll20', + subtitle: 'Исследование гекс за гексом для Roll20', footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', overview: { heading: 'Обзор', - body: 'Hexploration покрывает шестнадцатеричную карту непрозрачными шестигранниками. По мере движения группы гексы, через которые они проходят (и, если хотите, гексы вокруг них) удаляются, поэтому карта открывается по одному гексу за раз. Скрытые локации могут быть размещены под гексами, и о их обнаружении будет объявлено. Он работает в играх Jumpgate и Legacy на сетках Hex (V) и Hex (H) любого размера.', + body: 'Hexploration закрывает гексовую карту непрозрачными гексами. По мере продвижения группы гексы, через которые она проходит (и, при желании, гексы вокруг них), удаляются, так что карта открывается гекс за гексом. Под гексами можно разместить скрытые локации — при обнаружении о них будет объявлено. Работает в играх Jumpgate и Legacy, на сетках Hex (V) и Hex (H) любого размера.', demo: 'Посмотрите короткую демонстрацию (из версии 1)', }, quickStart: { @@ -8517,9 +8535,9 @@ const HexplorationMod = (() => { steps: [ 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', - 'Выделите фигуры и нажмите «Заполнить командную колоду» (или введите !hexploration fill). Фигуры заменяются шестигранниками.', - 'Необязательно: перед заполнением выберите жетоны для важных мест и нажмите «Отметить местоположение». Они спрятаны под гексами и объявляются об обнаружении.', - 'Переместите жетон игрока. Каждый гекс, через который он проходит, и гексы в пределах его видимости раскрываются.', + 'Выделите фигуры и нажмите «Заполнить» в Command Deck (или введите !hexploration fill). Фигуры заменятся гексами.', + 'Необязательно: перед заливкой выделите токены важных мест и нажмите «Отметить локацию». Они будут спрятаны под гексами, а при обнаружении о них будет объявлено.', + 'Переместите токен игрока. Каждый гекс, через который он проходит, и гексы в пределах его «Расстояния обзора» раскрываются.', ], }, commands: { @@ -8532,29 +8550,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Как работает выявление', points: [ - 'Только жетоны на слое жетонов имеют шестигранники. Количество жетонов задается жетонами, которые раскрываются: жетоны игроков по умолчанию, поэтому GM может перемещать монстров, не открывая карту.', - 'Жетон показывает каждый гекс, который он покрывает (большие жетоны покрывают несколько), а при включенной функции «Показать вдоль пути» - каждый гекс на маршруте, по которому он протащился, включая путевые точки.', - 'Расстояние обзора показывает гексы вокруг каждого из этих гексов. При включенной линии видимости гекс открывается только в том случае, если между ним нет покрытого гекса.', - 'Расстояние раскрытия шестигранников сохраняется в шестигранниках по мере их рисования. Эти гексы открываются только внутри определенного количества гексов, независимо от того, насколько далеко может видеть фишка. Используйте его для гор или лесов, которые скрывают то, что находится за ними.', - 'В режиме «Проблеск» гексы в пределах видимости становятся прозрачными, а не исчезают, и удаляются, когда в них попадает жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не сообщает о действиях, сделанных другими модами. Ходы TokenMod подбираются автоматически; для других модов выберите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из вашего собственного мода.', + 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', + 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов. При включённой «Линии видимости» гекс раскрывается, только если между ним и токеном нет закрытого гекса.', + '«Дальность раскрытия шестиугольников» сохраняется в гексах при их рисовании. Такие гексы раскрываются только с расстояния не больше этого числа гексов, как бы далеко ни видел токен. Используйте её для гор или лесов, скрывающих то, что за ними.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен.', + 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', + 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', ], }, locations: { heading: 'Именованные гексы и локации', points: [ - 'Отметить местоположение превращает выбранные токены в скрытые места. Фишка, уже находящаяся под гексом, сразу прячется; в противном случае он скрыт следующей заливкой, закрывающей его.', + '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - 'Name Hex дает шестнадцатеричному имени без токена. Имя отображается ГМу в виде метки на слое ГМ и объявляется при раскрытии шестнадцатеричного числа.', - 'Объявление открытий позволяет выбрать, будут ли объявления видеть все, только ГМ или никто. Ping Discoveries также перемещает взгляд игроков на локацию.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Измените настройки с помощью набора !hexploration (или кнопки «Настройки»). Шестнадцатеричный слой, отображаемые токены и язык также можно установить на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', @@ -8564,18 +8582,18 @@ const HexplorationMod = (() => { heading: 'Джампгейт и Наследие', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для Hex Layer установлено значение Auto, гексагоны рисуются на переднем слое над жетонами, поэтому игроки не могут видеть, что находится под ними. Если слой переднего плана недоступен, вместо него используется слой токена.', - 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если шестигранники не совпадают с сеткой страницы, привяжите жетон к центру шестигранника, выберите его и нажмите «Калибровать». Выберите два жетона в соседних шестиугольниках одной и той же строки (шестнадцатеричный V) или столбца (шестнадцатеричный H), чтобы также исправить размер шестнадцатеричного числа.', - 'Когда страница или игра копируется, ее гексы получают новые идентификаторы. Запустите повторное сканирование страницы, чтобы снова найти их вместе с метками их имен и жетонами местоположения.', + 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', + 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], }, upgrading: { heading: 'Обновление с версии 1', points: [ 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', - 'Существующие шестнадцатеричные карты, имена, маркеры местоположения и настройки обновляются автоматически при первом запуске.', + 'Существующие гексовые карты, имена, токены локаций и настройки обновляются автоматически при первом запуске.', 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', - 'Версия 1 позволяла любому жетону, представляющему персонажа, показывать гексы. Установите жетоны, которые раскрываются, на жетоны персонажей, чтобы сохранить такое поведение.', + 'В версии 1 гексы мог раскрывать любой токен, представляющий персонажа. Чтобы сохранить такое поведение, установите для «Раскрывающие токены» значение «Токены персонажей».', ], colV1: 'Команда версии 1', colV2: 'Команда версии 2', @@ -8583,18 +8601,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Поиск неисправностей', points: [ - 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токена и соответствует токенам, которые раскрываются, а также что страница имеет шестнадцатеричные значения (статус!hexploration).', - 'Гексаксисы смещены от сетки: используйте «Калибровку», затем проверьте жетоном несколько гексов по карте.', - 'Шестигранники перестали проявляться после копирования страницы или игры: запустите повторное сканирование страницы.', - 'Заливка говорит, что область не имеет шестигранных центров: фигура должна содержать центр хотя бы одного шестигранника.', + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токенов и подходит под настройку «Раскрывающие токены», а на странице есть гексы (!hexploration status).', + 'Гексы смещены относительно сетки: нажмите «Калибровать», затем проверьте токеном несколько гексов в разных частях карты.', + 'Гексы перестали раскрываться после копирования страницы или игры: выполните «Пересканировать» на странице.', + '«Заполнить» сообщает, что в области нет центров гексов: фигура должна содержать центр хотя бы одного гекса.', 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', ], }, languages: { heading: 'Языки', - body: 'Выберите язык с помощью !hexploration set Language. Доступные языки:', + body: 'Выберите язык командой !hexploration set language. Доступные языки:', colLanguage: 'Язык', - colNative: 'Родное имя', + colNative: 'Самоназвание', colCode: 'Код', }, credits: { @@ -8610,13 +8628,13 @@ const HexplorationMod = (() => { const TRANSLATION$3 = { titles: { - ready: 'La hexploración está lista.', - settings: 'Configuración de hexploración', + ready: 'Hexploration está listo.', + settings: 'Configuración de Hexploration', languages: 'Elige un idioma', pageSettings: 'Configuración de página: {page}', - status: 'Estado de exploración: {page}', - help: 'Comandos de hexploración', - confirm: 'Por favor confirme', + status: 'Estado de Hexploration: {page}', + help: 'Comandos de Hexploration', + confirm: 'Por favor, confirme', }, discovery: { title: 'Ubicación descubierta', @@ -8626,12 +8644,12 @@ const HexplorationMod = (() => { reveal: 'Revelar y ocultar', locations: 'Ubicaciones', tools: 'Herramientas', - layerInUse: 'Se están dibujando nuevos hexágonos en {layer}.', + layerInUse: 'Se están dibujando nuevos hexágonos en la {layer}.', pageSettingsHelp: 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', }, buttons: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', undo: 'Deshacer relleno', reveal: 'Revelar', @@ -8641,8 +8659,8 @@ const HexplorationMod = (() => { resetPage: 'Restablecer página', mark: 'Marcar ubicación', unmark: 'Desmarcar', - name: 'Nombre hexadecimal', - settings: 'Ajustes', + name: 'Nombrar hexágono', + settings: 'Configuración', pageSettings: 'Configuración de página', status: 'Estado', rescan: 'Volver a escanear', @@ -8658,34 +8676,34 @@ const HexplorationMod = (() => { name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', }, values: { - on: 'En', - off: 'Apagado', + on: 'Activado', + off: 'Desactivado', none: 'Ninguno', hexLayer: { auto: 'Auto (primer plano si está disponible)', foreground: 'capa de primer plano', - objects: 'capa de token', + objects: 'capa de fichas', }, revealBy: { - players: 'fichas de jugador', + players: 'Fichas de jugador', characters: 'Fichas de personaje', all: 'Todas las fichas', }, revealMode: { - clear: 'Claro', + clear: 'Despejar', glimpse: 'Vistazo', }, announce: { all: 'Todos', - gm: 'solo GM', - off: 'Apagado', + gm: 'Solo el DJ', + off: 'Desactivado', }, orientation: { - vertical: 'Hexágono (V)', - horizontal: 'Hexagonal (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Llenar', + fill: 'Rellenar', fillInverse: 'Relleno inverso', conceal: 'Ocultar', }, @@ -8696,7 +8714,7 @@ const HexplorationMod = (() => { desc: 'Idioma para menús, mensajes y folletos.', }, hexLayer: { - label: 'Capa hexagonal', + label: 'Capa de hexágonos', desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', }, fillColor: { @@ -8712,15 +8730,15 @@ const HexplorationMod = (() => { desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', }, glimpseColor: { - label: 'Color de vislumbre', - desc: 'Los hexágonos de color cambian cuando se vislumbran (modo de revelación Glimpse). Utilice un color rgba() transparente.', + label: 'Color de vistazo', + desc: 'Color que toman los hexágonos al vislumbrarse (modo de revelación Vistazo). Use un color rgba() transparente.', }, strokeWidth: { label: 'Ancho del borde', desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', }, maxDistance: { - label: 'Distancia de revelación hexagonal', + label: 'Distancia de revelación de hexágonos', desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', }, revealDistance: { @@ -8740,38 +8758,38 @@ const HexplorationMod = (() => { desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', }, revealMode: { - label: 'Modo revelar', - desc: 'Borrar elimina hexágonos a la vista. En cambio, Glimpse los hace transparentes; se eliminan cuando una ficha ingresa en ellos.', + label: 'Modo de revelación', + desc: 'Despejar elimina los hexágonos a la vista. Vistazo, en cambio, los vuelve transparentes; se eliminan cuando una ficha entra en ellos.', }, announce: { label: 'Anunciar descubrimientos', desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', }, pingDiscoveries: { - label: 'Descubrimientos de ping', + label: 'Hacer ping a los descubrimientos', desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', }, hideCoveredTokens: { - label: 'Ocultar tokens cubiertos', + label: 'Ocultar fichas cubiertas', desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', }, }, status: { - engine: 'motor de juego', - grid: 'Red', - layer: 'capa hexagonal', + engine: 'Motor de juego', + grid: 'Cuadrícula', + layer: 'Capa de hexágonos', hexes: 'Hexágonos', named: 'Hexágonos con nombre', icons: 'Fichas de ubicación', glimpsed: 'Hexágonos vislumbrados', - pending: 'Ubicaciones esperando ser llenadas', + pending: 'Ubicaciones pendientes de relleno', calibrated: 'Calibrado', overrides: 'Anulaciones de página', undo: 'Deshacer disponible', }, messages: { filled: - 'Llenar completo. Hexágonos dibujados: {created}. Rediseñado: {restyled}. Ubicaciones ocultas: {icons}.', + 'Relleno completado. Hexágonos dibujados: {created}. Con nuevo estilo: {restyled}. Ubicaciones ocultas: {icons}.', revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: @@ -8793,11 +8811,11 @@ const HexplorationMod = (() => { 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: - 'Tus mapas hexadecimales de Hexploration 1.x han sido actualizados. Si este juego fue copiado de un juego heredado, ejecuta Volver a escanear en cada página del mapa hexadecimal.', + 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', pruned: 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', readyHint: - 'Escriba !hexploration para el menú o abra el folleto "Hexploration - Command Deck".', + 'Escriba !hexploration para ver el menú o abra el folleto "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -8807,9 +8825,9 @@ const HexplorationMod = (() => { }, errors: { noPage: 'No se pudo encontrar la página para trabajar.', - notHex: 'Esta página no utiliza una cuadrícula hexadecimal.', + notHex: 'Esta página no utiliza una cuadrícula hexagonal.', noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', - emptyArea: 'El área seleccionada no contiene ningún centro hexadecimal.', + emptyArea: 'El área seleccionada no contiene ningún centro de hexágono.', tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', @@ -8820,7 +8838,7 @@ const HexplorationMod = (() => { unknownSetting: 'Configuración desconocida: {key}', unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', invalidValue: '"{value}" no es un valor válido para {key}.', - calibrateNeedsTokens: 'Seleccione una o dos fichas colocadas en centros hexadecimales.', + calibrateNeedsTokens: 'Seleccione una o dos fichas ajustadas a centros de hexágonos.', calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', unexpected: 'Algo salió mal: {message}', }, @@ -8862,21 +8880,20 @@ const HexplorationMod = (() => { pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: - 'Reconstruya la lista hexadecimal de la página, por ejemplo, después de copiar una página o un juego.', + 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', - journal: 'Reconstruya los folletos de Ayuda y Comando.', + journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', help: 'Muestra esta lista.', handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', }, deck: { - subtitle: 'Cubierta de mando', drawDesc: - 'Dibuja formas alrededor de un área, selecciónalas y luego rellénalas. Deshacer invierte el último relleno.', + 'Dibuja formas alrededor de un área, selecciónalas y luego rellena. Deshacer relleno revierte el último relleno.', revealDesc: - 'Selecciona hexágonos, formas o fichas para revelarlos o cubrirlos nuevamente. Explore las revelaciones alrededor de las fichas seleccionadas como si se hubieran movido.', + 'Selecciona hexágonos, formas o fichas para revelarlos o volver a cubrirlos. Explorar revela alrededor de las fichas seleccionadas como si se hubieran movido.', locationsDesc: 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', toolsDesc: @@ -8897,7 +8914,7 @@ const HexplorationMod = (() => { steps: [ 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', - 'Seleccione las formas y haga clic en Rellenar en Command Deck (o escriba !hexploration fill). Las formas son reemplazadas por hexágonos.', + 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], @@ -8912,29 +8929,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Cómo funciona la revelación', points: [ - 'Sólo las fichas en la capa de fichas revelan hexágonos. El número de fichas lo establece Fichas que revelan: fichas de jugador de forma predeterminada, por lo que el DJ puede mover monstruos sin descubrir el mapa.', + 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'La API no informa movimientos realizados por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otras modificaciones, seleccione los tokens y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', + 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', ], }, locations: { heading: 'Hexágonos y ubicaciones con nombre', points: [ - 'Marcar ubicación convierte los tokens seleccionados en ubicaciones ocultas. Una ficha que ya se encuentra bajo un hexágono se oculta inmediatamente; de lo contrario, queda oculto por el siguiente relleno que lo cubre.', + 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', - 'Name Hex le da a un hexágono un nombre sin ficha. El nombre se muestra al DJ como una etiqueta en la capa del GM y se anuncia cuando se revela el hexágono.', - 'Announce Discoveries elige si todos, solo el DJ o nadie, ven el anuncio. Ping Discoveries también mueve la vista de los jugadores a la ubicación.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], }, settings: { heading: 'Ajustes', intro: - 'Cambie la configuración con el conjunto de exploración (o el botón Configuración). La capa hexagonal, los tokens que revelan y el idioma también se pueden configurar en la página de configuración del Mod.', + 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', colKey: 'Llave', colName: 'Configuración', colDesc: 'Descripción', @@ -8944,18 +8961,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate y legado', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', - 'Con Hex Layer configurada en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se utiliza la capa de token en su lugar.', - 'Jumpgate dibuja hexágonos matemáticamente regulares, que tienen una forma ligeramente diferente a los hexágonos Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha a un centro hexadecimal, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', - 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos nuevamente, junto con sus etiquetas de nombre y tokens de ubicación.', + 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, cuya forma es ligeramente distinta de la de los hexágonos de Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha al centro de un hexágono, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos, junto con sus etiquetas de nombre y fichas de ubicación.', ], }, upgrading: { heading: 'Actualización desde la versión 1', points: [ 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', - 'Los mapas hexadecimales, los nombres, las fichas de ubicación y las configuraciones existentes se actualizan automáticamente en el primer inicio.', + 'Los mapas de hexágonos, nombres, fichas de ubicación y ajustes existentes se actualizan automáticamente la primera vez que se inicia.', 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', - 'La versión 1 permitía que cualquier ficha que representara un personaje revelara hexágonos. Establezca fichas que revelen fichas de personaje para mantener ese comportamiento.', + 'La versión 1 permitía que cualquier ficha que representara a un personaje revelara hexágonos. Ajuste Fichas que revelan a Fichas de personaje para mantener ese comportamiento.', ], colV1: 'Comando versión 1', colV2: 'Comando versión 2', @@ -8963,10 +8980,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Solución de problemas', points: [ - 'No sucede nada cuando un token se mueve: verifique que el token esté en la capa del token y coincida con los Tokens que revelan, y que la página tenga hexágonos (!hestado de exploración).', + 'No pasa nada cuando una ficha se mueve: compruebe que la ficha está en la capa de fichas y coincide con Fichas que revelan, y que la página tiene hexágonos (!hexploration status).', 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', - 'Los maleficios dejaron de revelarse después de copiar una página o un juego: ejecuta Volver a escanear en la página.', - 'Fill dice que el área no tiene centros de hexágonos: la forma debe contener el centro de al menos un hexágono.', + 'Los hexágonos dejaron de revelarse tras copiar una página o un juego: ejecute Volver a escanear en la página.', + 'Rellenar dice que el área no tiene centros de hexágono: la forma debe contener el centro de al menos un hexágono.', 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', ], }, @@ -8974,7 +8991,7 @@ const HexplorationMod = (() => { heading: 'Idiomas', body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', colLanguage: 'Idioma', - colNative: 'nombre nativo', + colNative: 'Nombre original', colCode: 'Código', }, credits: { @@ -8991,37 +9008,37 @@ const HexplorationMod = (() => { const TRANSLATION$2 = { titles: { ready: 'Hexploration är redo.', - settings: 'Heexploration Inställningar', + settings: 'Hexploration-inställningar', languages: 'Välj ett språk', pageSettings: 'Sidinställningar: {page}', - status: 'Hexploration Status: {page}', - help: 'Hexploration kommandon', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandon', confirm: 'Vänligen bekräfta', }, discovery: { title: 'Plats upptäckt', }, menu: { - draw: 'Dra', - reveal: 'Avslöja och göm', + draw: 'Rita', + reveal: 'Avslöja och dölj', locations: 'Platser', tools: 'Verktyg', - layerInUse: 'Nya sexkanter ritas på {layer}.', + layerInUse: 'Nya hexar ritas på {layer}.', pageSettingsHelp: 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', }, buttons: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - undo: 'Ångra Fyll', + undo: 'Ångra fyllning', reveal: 'Avslöja', - conceal: 'Dölja', + conceal: 'Dölj', explore: 'Utforska', - revealPage: 'Avslöja sidan', + revealPage: 'Avslöja sida', resetPage: 'Återställ sida', mark: 'Markera plats', unmark: 'Avmarkera', - name: 'Namn Hex', + name: 'Namnge hex', settings: 'Inställningar', pageSettings: 'Sidinställningar', status: 'Status', @@ -9043,12 +9060,12 @@ const HexplorationMod = (() => { none: 'Ingen', hexLayer: { auto: 'Auto (förgrund om tillgängligt)', - foreground: 'förgrundsskikt', - objects: 'symbollager', + foreground: 'förgrundslagret', + objects: 'tokenlagret', }, revealBy: { - players: 'Spelarpoletter', - characters: 'Karaktärspoletter', + players: 'Spelartokens', + characters: 'Rollpersonstokens', all: 'Alla tokens', }, revealMode: { @@ -9065,9 +9082,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Fylla', + fill: 'Fyll', fillInverse: 'Omvänd fyllning', - conceal: 'Dölja', + conceal: 'Dölj', }, }, settings: { @@ -9076,12 +9093,12 @@ const HexplorationMod = (() => { desc: 'Språk för menyer, meddelanden och åhörarkopior.', }, hexLayer: { - label: 'Hexlager', + label: 'Lager för hexar', desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', - desc: 'Färg på nya sexkanter. Använd rgba() för genomskinliga hexadecimaler, till exempel rgba(0,0,0,0.8).', + desc: 'Färg på nya hexar. Använd rgba() för genomskinliga hexar, till exempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfärg', @@ -9092,15 +9109,15 @@ const HexplorationMod = (() => { desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', }, glimpseColor: { - label: 'Glimt färg', - desc: 'Hexfärgade färger ändras till när de skymtas (Glimpse-avslöjningsläge). Använd en genomskinlig rgba()-färg.', + label: 'Glimtfärg', + desc: 'Färgen som hexar byter till när de skymtas (avslöjandeläget Glimt). Använd en genomskinlig rgba()-färg.', }, strokeWidth: { label: 'Kantbredd', desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', }, maxDistance: { - label: 'Hexavslöjande avstånd', + label: 'Avslöjandeavstånd för hexar', desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', }, revealDistance: { @@ -9108,7 +9125,7 @@ const HexplorationMod = (() => { desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', }, lineOfSight: { - label: 'Synlinje', + label: 'Siktlinje', desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', }, revealPath: { @@ -9120,33 +9137,33 @@ const HexplorationMod = (() => { desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', }, revealMode: { - label: 'Avslöjande läge', - desc: 'Clear tar bort sexkanter inom synhåll. Glimpse gör dem genomskinliga istället; de tas bort när en token kommer in i dem.', + label: 'Avslöjandeläge', + desc: 'Rensa tar bort hexar inom synhåll. Glimt gör dem i stället genomskinliga; de tas bort när en token går in i dem.', }, announce: { label: 'Tillkännage upptäckter', desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', }, pingDiscoveries: { - label: 'Ping upptäckter', + label: 'Pinga upptäckter', desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', }, hideCoveredTokens: { - label: 'Dölj täckta polletter', + label: 'Dölj täckta tokens', desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', }, }, status: { engine: 'Spelmotor', grid: 'Rutnät', - layer: 'Hexskikt', - hexes: 'Hex', + layer: 'Hexlager', + hexes: 'Hexar', named: 'Namngivna hexar', - icons: 'Platsskyltar', - glimpsed: 'Glimmade hexar', + icons: 'Platstokens', + glimpsed: 'Genomskinliga hexar', pending: 'Platser som väntar på fyllning', calibrated: 'Kalibrerad', - overrides: 'Sida åsidosätter', + overrides: 'Sidåsidosättningar', undo: 'Ångra tillgängligt', }, messages: { @@ -9157,11 +9174,11 @@ const HexplorationMod = (() => { 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', resetPage: 'Hexen har tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen har ångrats. Hex borttagna: {removed}. Återställda hexadecimaler: {restored}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', named: 'Hex med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: - 'Platser dolda i befintliga hexadecimaler: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: @@ -9172,11 +9189,11 @@ const HexplorationMod = (() => { 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: - 'Dina Hexploration 1.x hex-kartor har uppgraderats. Om det här spelet kopierades från ett Legacy-spel, kör Rescan på varje hex-kartasida.', + 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', pruned: - 'Sparade hexar som inte längre finns och glömdes bort: {dropped}. Om det här spelet eller sidan kopierades, kör Rescan på sidan för att plocka upp dess hexes igen.', + 'Sparade hexar som inte längre finns och har glömts bort: {dropped}. Om det här spelet eller sidan kopierades kör du Skanna igen på sidan för att hitta dess hexar igen.', readyHint: - 'Skriv !hexploration för menyn, eller öppna utdelningen "Hexploration - Command Deck".', + 'Skriv !hexploration för menyn, eller öppna handouten "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -9215,7 +9232,7 @@ const HexplorationMod = (() => { calibrateNeedsTokens: 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', calibrateFailed: - 'Två tokens måste vara i samma rad (Hex V) eller samma kolumn (Hex H), med minst en hexadecimal isär.', + 'Två tokens måste ligga i samma rad (Hex V) eller samma kolumn (Hex H), minst en hex från varandra.', unexpected: 'Detaljer finns i API-konsolloggen.', }, help: { @@ -9239,16 +9256,15 @@ const HexplorationMod = (() => { calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', - journal: 'Bygg om hjälp- och kommandodäcken.', + journal: 'Bygg om handouterna Help och Command Deck.', help: 'Visa den här listan.', handout: 'Fullständiga instruktioner finns i "{name}" handout.', }, deck: { - subtitle: 'Kommandodäck', drawDesc: - 'Rita former runt ett område, markera dem och fyll sedan. Ångra vänder den senaste fyllningen.', + 'Rita former runt ett område, markera dem och fyll sedan. Ångra fyllning tar bort den senaste fyllningen.', revealDesc: - 'Välj hex, former eller tokens för att avslöja eller täcka dem igen. Utforska avslöjar runt utvalda tokens som om de hade rört sig.', + 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', toolsDesc: @@ -9269,9 +9285,9 @@ const HexplorationMod = (() => { steps: [ 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', - 'Välj formerna och klicka på Fyll i kommandodäcket (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', - 'Flytta en spelartoken. Varje hex den passerar igenom, och hexen inom dess siktavstånd, avslöjas.', + 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, commands: { @@ -9284,13 +9300,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Hur avslöjande fungerar', points: [ - 'Endast polletter på tokenlagret avslöjar sexkanter. Vilket antal tokens bestäms av Tokens That Reveal: spelartokens som standard, så GM kan flytta monster utan att avslöja kartan.', - 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Reveal Along Path på, varje hex på rutten den släpades längs, inklusive waypoints.', - 'Sight Distance avslöjar hexen runt var och en av dessa hexes. Med Line of Sight på avslöjas en hex endast om ingen täckt hex ligger emellan.', - 'Hexavslöjande avstånd lagras på hexar när de ritas. Dessa hexes avslöjas bara inifrån så många hexes, hur långt en token än kan se. Använd den för berg eller skogar som döljer vad som finns bakom dem.', - 'I Glimpse-läget blir hexar inom synhåll genomskinliga istället för att försvinna och tas bort när en token kommer in i dem.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API:et rapporterar inte rörelser gjorda av andra mods. TokenMod-drag plockas upp automatiskt; för andra moddar, välj tokens och klicka på Utforska, eller ring Hexploration.revealAround(token) från din egen mod.', + 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar. Med Siktlinje på avslöjas en hex bara om ingen täckt hex ligger emellan.', + 'Avslöjandeavstånd för hexar lagras på hexarna när de ritas. Dessa hexar avslöjas bara inom så många hexars avstånd, hur långt en token än kan se. Använd det för berg eller skogar som döljer vad som finns bakom dem.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem.', + 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', + 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', ], }, locations: { @@ -9299,14 +9315,14 @@ const HexplorationMod = (() => { 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', - 'Namn Hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och meddelas när hexen avslöjas.', - 'Announce Discoveries väljer om alla, bara GM, eller ingen ser tillkännagivandet. Ping Discoveries flyttar också spelarnas vy till platsen.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], }, settings: { heading: 'Inställningar', intro: - 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Hexlager, Tokens That Reveal och Language kan också ställas in på modens inställningssida.', + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', colName: 'Miljö', colDesc: 'Beskrivning', @@ -9316,18 +9332,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate och Legacy', points: [ 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', - 'Med Hex Layer inställt på Auto, ritas hex på förgrundslagret, ovanför tokens, så att spelare inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret istället.', - 'Jumpgate ritar matematiskt regelbundna hexes, som är en något annorlunda form från Legacy hexes. Om hexadelarna inte stämmer överens med en sidas rutnät, fäster du en token till en hex-centrum, markerar den och klickar på Kalibrera. Välj två tokens i angränsande hexadecimaler i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', - 'När en sida eller ett spel kopieras får dess hexar nya ID. Kör Rescan på sidan för att plocka upp dem igen, tillsammans med deras namnetiketter och platssymboler.', + 'När Lager för hexar är inställt på Auto ritas hexar på förgrundslagret, ovanför tokens, så att spelarna inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret i stället.', + 'Jumpgate ritar matematiskt regelbundna hexar, som har en något annan form än Legacy-hexar. Om hexarna inte stämmer med en sidas rutnät, fäst en token i mitten av en hex, markera den och klicka på Kalibrera. Markera två tokens i angränsande hexar i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID:n. Kör Skanna igen på sidan för att hitta dem igen, tillsammans med deras namnetiketter och platstokens.', ], }, upgrading: { heading: 'Uppgraderar från version 1', points: [ 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', - 'Befintliga hexadecimala kartor, namn, platssymboler och inställningar uppgraderas automatiskt vid första starten.', + 'Befintliga hexkartor, namn, platstokens och inställningar uppgraderas automatiskt vid första starten.', 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', - 'Version 1 låter vilken token som helst som representerade en karaktär avslöja hexes. Ställ in Tokens That Reveal till Character-tokens för att behålla det beteendet.', + 'I version 1 kunde varje token som representerade en rollperson avslöja hexar. Ställ in Tokens som avslöjar på Rollpersonstokens för att behålla det beteendet.', ], colV1: 'Kommandot version 1', colV2: 'Kommandot version 2', @@ -9335,10 +9351,10 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Felsökning', points: [ - 'Ingenting händer när en token rör sig: kontrollera att token finns på tokenlagret och matchar Tokens That Reveal, och att sidan har hexes (!hexploration-status).', + 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', - 'Hexes slutade avslöjas efter att ha kopierat en sida eller ett spel: kör Rescan på sidan.', - 'Fill säger att området inte har några sexkantscentrum: formen måste innehålla mitten av minst en sexkant.', + 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', + 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', ], }, @@ -9346,7 +9362,7 @@ const HexplorationMod = (() => { heading: 'Språk', body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', colLanguage: 'Språk', - colNative: 'Inhemskt namn', + colNative: 'Eget namn', colCode: 'Koda', }, credits: { @@ -9362,46 +9378,46 @@ const HexplorationMod = (() => { const TRANSLATION$1 = { titles: { - ready: 'Keşif hazır.', - settings: 'Keşif Ayarları', + ready: 'Hexploration hazır.', + settings: 'Hexploration Ayarları', languages: 'Bir Dil Seçin', pageSettings: 'Sayfa Ayarları: {page}', - status: 'Keşif Durumu: {page}', - help: 'Keşif Komutları', + status: 'Hexploration Durumu: {page}', + help: 'Hexploration Komutları', confirm: 'Lütfen Onaylayın', }, discovery: { title: 'Konum Keşfedildi', }, menu: { - draw: 'Çizmek', - reveal: 'Göster ve Gizle', + draw: 'Çizim', + reveal: 'Açığa Çıkarma ve Gizleme', locations: 'Konumlar', - tools: 'Aletler', - layerInUse: '{layer} üzerinde yeni altıgenler çiziliyor.', + tools: 'Araçlar', + layerInUse: 'Yeni altıgenler şu katmana çiziliyor: {layer}.', pageSettingsHelp: 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', }, buttons: { - fill: 'Doldurmak', - fillInverse: 'Ters Doldurma', + fill: 'Doldur', + fillInverse: 'Ters Doldur', undo: 'Doldurmayı Geri Al', - reveal: 'Ortaya çıkarmak', + reveal: 'Açığa Çıkar', conceal: 'Gizle', - explore: 'Keşfetmek', - revealPage: 'Sayfayı Göster', + explore: 'Keşfet', + revealPage: 'Sayfayı Açığa Çıkar', resetPage: 'Sayfayı Sıfırla', mark: 'Konumu İşaretle', - unmark: 'İşareti kaldır', - name: 'Ad Hex', + unmark: 'İşareti Kaldır', + name: 'Altıgeni Adlandır', settings: 'Ayarlar', pageSettings: 'Sayfa Ayarları', status: 'Durum', - rescan: 'Yeniden tara', - calibrate: 'Kalibre et', + rescan: 'Yeniden Tara', + calibrate: 'Kalibre Et', calibrateReset: 'Kalibrasyonu Sıfırla', help: 'Yardım', - change: 'Değiştirmek', + change: 'Değiştir', menu: 'Menü', clearOverrides: 'Geçersiz Kılmaları Temizle', confirmReset: 'Evet, Tüm Altıgenleri Kaldır', @@ -9414,18 +9430,18 @@ const HexplorationMod = (() => { off: 'Kapalı', none: 'Hiçbiri', hexLayer: { - auto: 'Otomatik (varsa ön planda)', + auto: 'Otomatik (varsa ön plan)', foreground: 'ön plan katmanı', - objects: 'belirteç katmanı', + objects: 'jeton katmanı', }, revealBy: { players: 'Oyuncu jetonları', - characters: 'Karakter belirteçleri', + characters: 'Karakter jetonları', all: 'Tüm jetonlar', }, revealMode: { - clear: 'Temizlemek', - glimpse: 'Kısa bakış', + clear: 'Temizleme', + glimpse: 'Bakış', }, announce: { all: 'Herkes', @@ -9433,23 +9449,23 @@ const HexplorationMod = (() => { off: 'Kapalı', }, orientation: { - vertical: 'Altıgen (V)', - horizontal: 'Altıgen (H)', + vertical: 'Hex (V)', + horizontal: 'Hex (H)', }, fillKind: { - fill: 'Doldurmak', + fill: 'Doldurma', fillInverse: 'Ters Doldurma', - conceal: 'Gizle', + conceal: 'Gizleme', }, }, settings: { language: { label: 'Dil', - desc: 'Menüler, mesajlar ve bildiriler için dil.', + desc: 'Menüler, mesajlar ve broşürler için dil.', }, hexLayer: { - label: 'Altıgen Katman', - desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (belirteçlerin üstünde) dener ve oyun desteklemiyorsa simge katmanına geri döner.', + label: 'Altıgen Katmanı', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (jetonların üstünde) dener; oyun bunu desteklemiyorsa jeton katmanına geri döner.', }, fillColor: { label: 'Dolgu Rengi', @@ -9465,14 +9481,14 @@ const HexplorationMod = (() => { }, glimpseColor: { label: 'Bakış Rengi', - desc: 'Renk altıgenleri, göz atıldığında (Glimpse ortaya çıkarma modu) olarak değişir. Şeffaf bir rgba() rengi kullanın.', + desc: 'Altıgenlerin Bakış modunda aldığı renk. Yarı saydam bir rgba() rengi kullanın.', }, strokeWidth: { - label: 'Kenar Genişliği', + label: 'Kenarlık Kalınlığı', desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', }, maxDistance: { - label: 'Hex Ortaya Çıkma Mesafesi', + label: 'Altıgen Açığa Çıkarma Mesafesi', desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', }, revealDistance: { @@ -9484,42 +9500,42 @@ const HexplorationMod = (() => { desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', }, revealPath: { - label: 'Yol Boyunca Ortaya Çıkar', + label: 'Yol Boyunca Açığa Çıkar', desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', }, revealBy: { - label: 'Ortaya Çıkan Tokenlar', + label: 'Açığa Çıkaran Jetonlar', desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', }, revealMode: { - label: 'Ortaya Çıkarma Modu', - desc: 'Clear, görüş alanındaki altıgenleri kaldırır. Glimpse onların içini görmelerini sağlar; bir jeton onlara girdiğinde kaldırılırlar.', + label: 'Açığa Çıkarma Modu', + desc: 'Temizleme, görüş alanındaki altıgenleri kaldırır. Bakış ise onları yarı saydam yapar; içlerine bir jeton girdiğinde kaldırılırlar.', }, announce: { - label: 'Keşifleri Duyurun', + label: 'Keşifleri Duyur', desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', }, pingDiscoveries: { - label: 'Ping Keşifleri', + label: 'Keşifleri Pingle', desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', }, hideCoveredTokens: { - label: 'Kapalı Jetonları Gizle', + label: 'Örtülü Jetonları Gizle', desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', }, }, status: { engine: 'Oyun motoru', grid: 'Izgara', - layer: 'Altıgen katman', + layer: 'Altıgen katmanı', hexes: 'Altıgenler', named: 'Adlandırılmış altıgenler', - icons: 'Konum belirteçleri', - glimpsed: 'Kısa bir bakış altıgenler', - pending: 'Doldurulmayı bekleyen yerler', + icons: 'Konum jetonları', + glimpsed: 'Bakış altındaki altıgenler', + pending: 'Doldurma bekleyen konumlar', calibrated: 'Kalibre edildi', overrides: 'Sayfa geçersiz kılmaları', - undo: 'Geri alma seçeneği mevcut', + undo: 'Geri alma mevcut', }, messages: { filled: @@ -9528,7 +9544,7 @@ const HexplorationMod = (() => { revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', - resetPage: 'Onaltılıklar sayfadan kaldırıldı: {count}.', + resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', named: '"{name}" adlı altıgenler: {count}.', @@ -9543,12 +9559,12 @@ const HexplorationMod = (() => { 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', calibrationReset: 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', - journalRebuilt: '"{help}" ve "{deck}" bildirileri yeniden oluşturuldu.', + journalRebuilt: '"{help}" ve "{deck}" broşürleri yeniden oluşturuldu.', migrated: - 'Heexploration 1.x hex haritalarınız yükseltildi. Bu oyun Eski bir oyundan kopyalanmışsa, her altıgen harita sayfasında Yeniden Taramayı çalıştırın.', + "Hexploration 1.x altıgen haritalarınız yükseltildi. Bu oyun bir Legacy oyunundan kopyalandıysa, her altıgen harita sayfasında Yeniden Tara'yı çalıştırın.", pruned: - "Artık mevcut olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenleri tekrar almak için sayfada Yeniden Tarama'yı çalıştırın.", - readyHint: 'Menüye !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + "Artık var olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenlerini yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + readyHint: 'Menü için !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', }, warnings: { foregroundUnavailable: @@ -9587,9 +9603,9 @@ const HexplorationMod = (() => { unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: - 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlere tutturulmuş ikinci bir jeton seçin.', + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgene tutturulmuş ikinci bir jeton seçin.', calibrateFailed: - 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir onaltılık aralıkta olması gerekir.', + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir altıgen aralıkla olması gerekir.', unexpected: 'Ayrıntılar API konsolu günlüğündedir.', }, help: { @@ -9610,21 +9626,20 @@ const HexplorationMod = (() => { pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: - 'Örneğin bir sayfayı veya oyunu kopyaladıktan sonra sayfanın onaltılı listesini yeniden oluşturun.', + 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', calibrate: 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', - status: "Heexploration'ın mevcut sayfa hakkında bildiklerini gösterin.", - journal: 'Yardım ve Komut Paneli bildirilerini yeniden oluşturun.', + status: "Hexploration'ın geçerli sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Command Deck broşürlerini yeniden oluşturun.', help: 'Bu listeyi göster.', handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', }, deck: { - subtitle: 'Komut Güvertesi', drawDesc: - 'Bir alanın etrafına şekiller çizin, bunları seçin ve ardından doldurun. Geri al, son dolguyu tersine çevirir.', + "Bir alanın çevresine şekiller çizin, onları seçin ve Doldur'a tıklayın. Doldurmayı Geri Al, son doldurmayı geri alır.", revealDesc: - 'Tekrar ortaya çıkarmak veya kaplamak için altıgenleri, şekilleri veya jetonları seçin. Seçili tokenların etrafındaki gösterimleri sanki hareket etmişler gibi keşfedin.', + 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', toolsDesc: @@ -9637,7 +9652,7 @@ const HexplorationMod = (() => { footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', - body: 'Heexploration, opak altıgenlere sahip bir altıgen haritayı kapsar. Grup ilerledikçe içinden geçtikleri altıgenler (ve isterseniz etraflarındaki altıgenler) kaldırılır, böylece harita her seferinde bir altıgen olarak ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduğunda duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + body: 'Hexploration, bir altıgen haritayı opak altıgenlerle kaplar. Grup ilerledikçe içinden geçtiği altıgenler (ve isterseniz çevresindeki altıgenler) kaldırılır; böylece harita altıgen altıgen ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduklarında duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', demo: "Kısa bir demo izleyin (versiyon 1'den)", }, quickStart: { @@ -9645,7 +9660,7 @@ const HexplorationMod = (() => { steps: [ 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', - "Şekilleri seçin ve Komut Panelinde Doldur'a tıklayın (veya !hexploration fill yazın). Şekillerin yerini altıgenler alır.", + "Şekilleri seçin ve Command Deck'te Doldur'a tıklayın (veya !hexploration fill yazın). Şekiller altıgenlerle değiştirilir.", "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', ], @@ -9660,13 +9675,13 @@ const HexplorationMod = (() => { revealing: { heading: 'Açığa Çıkarma Nasıl Çalışır?', points: [ - 'Yalnızca jeton katmanındaki jetonlar altıgenleri ortaya çıkarır. Hangi jetonların sayılacağı, Ortaya Çıkarılan Jetonlar tarafından belirlenir: varsayılan olarak oyuncu jetonları, böylece GM, haritayı açığa çıkarmadan canavarları hareket ettirebilir.', - 'Bir jeton, kapsadığı her altıgeni (büyük jetonlar birkaçını kapsar) ve Yol Boyunca Göster açıkken, ara noktalar da dahil olmak üzere sürüklendiği rotadaki her altıgeni ortaya çıkarır.', - 'Görüş Mesafesi, bu altıgenlerin her birinin etrafındaki altıgenleri ortaya çıkarır. Görüş Hattı açıkken, bir altıgen yalnızca arada kapalı bir altıgen bulunmadığında ortaya çıkar.', - 'Hex Reveal Distance, altıgenler çizildikçe depolanır. Bu büyüler, bir jetonun görebileceği kadar uzağa, yalnızca o kadar çok büyünün içinden ortaya çıkar. Arkalarında olanı gizleyen dağlar veya ormanlar için kullanın.', - 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine şeffaf hale gelir ve içlerine bir jeton girdiğinde kaldırılır.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - "API, diğer modların yaptığı hareketleri raporlamaz. TokenMod hareketleri otomatik olarak alınır; diğer modlar için belirteçleri seçin ve Araştır'a tıklayın veya kendi modunuzdan Heexploration.revealAround(token) öğesini çağırın.", + 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', + 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri açığa çıkarır. Görüş Hattı açıkken bir altıgen yalnızca arada örtülü bir altıgen yoksa açığa çıkar.', + 'Altıgen Açığa Çıkarma Mesafesi, altıgenler çizilirken onlara kaydedilir. Bu altıgenler, bir jeton ne kadar uzağı görürse görsün, yalnızca o kadar altıgen mesafeden açığa çıkar. Arkasındakini gizleyen dağlar veya ormanlar için kullanın.', + 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır.', + 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', + "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", ], }, locations: { @@ -9675,14 +9690,14 @@ const HexplorationMod = (() => { 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', - "Name Hex, onaltılıya belirteci olmayan bir ad verir. İsim, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen ortaya çıktığında duyurulur.", - "Announce Discoveries, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi görmeyeceğini seçer. Ping Discoveries ayrıca oyuncuların görünümünü konuma taşır.", + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], }, settings: { heading: 'Ayarlar', intro: - '!hexploration setiyle (veya Ayarlar düğmesiyle) ayarları değiştirin. Hex Katmanı, Ortaya Çıkan Tokenlar ve Dil ayrıca Modun ayarlar sayfasından da ayarlanabilir.', + "Ayarları !hexploration set ile (veya Ayarlar düğmesiyle) değiştirin. Altıgen Katmanı, Açığa Çıkaran Jetonlar ve Dil, Mod'un ayarlar sayfasından da ayarlanabilir.", colKey: 'Anahtar', colName: 'Ayar', colDesc: 'Tanım', @@ -9691,10 +9706,10 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate ve Eski', points: [ - 'Heexploration, oyunun hangi motoru kullandığını bulur ve ona uygun şekli çizer. Her iki düzenleyicide de çizilen şekiller doldurulabilir.', - 'Hex Layer Auto (Otomatik) olarak ayarlandığında, altıgenler ön plan katmanında jetonların üzerine çizilir, böylece oyuncular altta ne olduğunu göremez. Ön plan katmanı mevcut değilse bunun yerine simge katmanı kullanılır.', - "Jumpgate, Eski altıgenlerden biraz farklı bir şekle sahip olan matematiksel olarak düzenli altıgenler çizer. Altıgenler sayfanın ızgarasıyla aynı hizada değilse, altıgen merkeze bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Onaltılı boyutu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerden iki jeton seçin.", - "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Bunları ad etiketleri ve konum belirteçleriyle birlikte yeniden almak için sayfada Yeniden Tarama'yı çalıştırın.", + 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', + 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', + "Jumpgate matematiksel olarak düzgün altıgenler çizer; bunların şekli Legacy altıgenlerinden biraz farklıdır. Altıgenler sayfanın ızgarasıyla hizalı değilse bir altıgenin merkezine bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerde iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Onları ad etiketleri ve konum jetonlarıyla birlikte yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", ], }, upgrading: { @@ -9702,8 +9717,8 @@ const HexplorationMod = (() => { points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', - 'Heexploration_menu makrosu da dahil olmak üzere sürüm 1 komutları hala çalışıyor.', - 'Sürüm 1, bir karakteri temsil eden herhangi bir jetonun altıgenleri ortaya çıkarmasına izin veriyor. Bu davranışı korumak için Ortaya Çıkan Jetonları Karakter jetonlarına ayarlayın.', + 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', + "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], colV1: 'Sürüm 1 komutu', colV2: 'Sürüm 2 komutu', @@ -9711,23 +9726,23 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Sorun giderme', points: [ - 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu, Ortaya Çıkan Jetonlarla eşleştiğini ve sayfada altıgenlerin (!hexploration durumu) bulunduğunu kontrol edin.', - "Altıgenler ızgaradan kaydırılmıştır: Kalibre Et'i kullanın, ardından haritadaki birkaç altıgeni bir jetonla kontrol edin.", - "Bir sayfayı veya oyunu kopyaladıktan sonra Hexes'in görüntülenmesi durduruldu: Sayfada Yeniden Tarama'yı çalıştırın.", - 'Fill, alanda altıgen merkezinin bulunmadığını söylüyor: şeklin en az bir altıgen merkezi içermesi gerekiyor.', + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu ve Açığa Çıkaran Jetonlar ayarına uyduğunu, sayfada da altıgenler bulunduğunu (!hexploration status) kontrol edin.', + "Altıgenler ızgaradan kaymış: Kalibre Et'i kullanın, ardından haritanın farklı yerlerindeki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra altıgenler açığa çıkmıyor: sayfada Yeniden Tara'yı çalıştırın.", + 'Doldur, alanda altıgen merkezi olmadığını söylüyor: şeklin en az bir altıgenin merkezini içermesi gerekir.', 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', ], }, languages: { heading: 'Diller', - body: '!hexploration set diliyle bir dil seçin. Mevcut diller:', + body: '!hexploration set language ile bir dil seçin. Mevcut diller:', colLanguage: 'Dil', colNative: 'Yerel ad', colCode: 'Kod', }, credits: { heading: 'Kredi', - original: 'Orijinal mod', + original: 'Orijinal modun yapımcısı', maintainer: 'Versiyon 2 tarafından sürdürülen', marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: @@ -9741,20 +9756,20 @@ const HexplorationMod = (() => { ready: 'Hexploration готовий.', settings: 'Налаштування Hexploration', languages: 'Виберіть мову', - pageSettings: 'Параметри сторінки: {page}', - status: 'Статус дослідження: {page}', + pageSettings: 'Налаштування сторінки: {page}', + status: 'Статус Hexploration: {page}', help: 'Команди Hexploration', confirm: 'Будь ласка, підтвердьте', }, discovery: { - title: 'Розташування виявлено', + title: 'Локацію виявлено', }, menu: { - draw: 'малювати', - reveal: 'Відкрити і приховати', - locations: 'Розташування', + draw: 'Малювання', + reveal: 'Розкриття і приховування', + locations: 'Локації', tools: 'Інструменти', - layerInUse: 'Нові гекси малюються на {layer}.', + layerInUse: 'Нові гекси малюються на цьому шарі: {layer}.', pageSettingsHelp: 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', }, @@ -9764,22 +9779,22 @@ const HexplorationMod = (() => { undo: 'Скасувати заповнення', reveal: 'Розкрити', conceal: 'Приховати', - explore: 'Досліджуйте', - revealPage: 'Відкрити сторінку', + explore: 'Дослідити', + revealPage: 'Розкрити сторінку', resetPage: 'Скинути сторінку', - mark: 'Позначте розташування', + mark: 'Позначити локацію', unmark: 'Зняти позначку', - name: "Ім'я Hex", + name: 'Назвати гекс', settings: 'Налаштування', - pageSettings: 'Параметри сторінки', + pageSettings: 'Налаштування сторінки', status: 'Статус', - rescan: 'Повторне сканування', + rescan: 'Пересканувати', calibrate: 'Відкалібрувати', calibrateReset: 'Скинути калібрування', help: 'Довідка', - change: 'Зміна', + change: 'Змінити', menu: 'Меню', - clearOverrides: 'Очистити перевизначення', + clearOverrides: 'Скинути перевизначення', confirmReset: 'Так, видалити всі гекси', }, prompts: { @@ -9788,24 +9803,24 @@ const HexplorationMod = (() => { values: { on: 'Увімкнено', off: 'Вимкнено', - none: 'Жодного', + none: 'Немає', hexLayer: { - auto: 'Автоматично (на передньому плані, якщо доступно)', + auto: 'Авто (передній план, якщо доступний)', foreground: 'шар переднього плану', - objects: 'маркерний шар', + objects: 'шар маркерів', }, revealBy: { - players: 'Жетони гравців', - characters: 'Символьні маркери', - all: 'Усі жетони', + players: 'Маркери гравців', + characters: 'Маркери персонажів', + all: 'Усі маркери', }, revealMode: { - clear: 'ясно', - glimpse: 'Поблиск', + clear: 'Очищення', + glimpse: 'Проблиск', }, announce: { all: 'Всі', - gm: 'Тільки GM', + gm: 'Лише GM', off: 'Вимкнено', }, orientation: { @@ -9813,9 +9828,9 @@ const HexplorationMod = (() => { horizontal: 'Hex (H)', }, fillKind: { - fill: 'Заповнити', + fill: 'Заповнення', fillInverse: 'Зворотне заповнення', - conceal: 'Приховати', + conceal: 'Приховування', }, }, settings: { @@ -9824,77 +9839,77 @@ const HexplorationMod = (() => { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шістнадцятковий шар', - desc: 'Де намальовані нові гекси. Автоматично пробує передній рівень (над маркерами) і повертається до рівня маркерів, якщо гра його не підтримує.', + label: 'Шар шестикутників', + desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', }, strokeColor: { - label: 'Колір рамки', + label: 'Колір контуру', desc: 'Колір контуру нових гексів.', }, labelColor: { - label: 'Колір етикетки', + label: 'Колір міток', desc: 'Колір написів імен лише для GM на іменованих гексах.', }, glimpseColor: { - label: 'Glimpse Color', - desc: 'Кольори гексів змінюються, коли їх бачать (режим розкриття проблиском). Використовуйте прозорий колір rgba().', + label: 'Колір проблиску', + desc: 'Колір, якого набувають гекси в режимі «Проблиск». Використовуйте напівпрозорий колір rgba().', }, strokeWidth: { - label: 'Ширина кордону', + label: 'Товщина контуру', desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Шестигранна відстань розкриття', + label: 'Відстань розкриття шестикутників', desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { - label: 'Дистанція огляду', + label: 'Дальність огляду', desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', }, lineOfSight: { - label: 'Пряма видимість', + label: 'Лінія видимості', desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', }, revealPath: { - label: 'Показати уздовж шляху', + label: 'Розкривати вздовж шляху', desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', }, revealBy: { - label: 'Жетони, які розкривають', + label: 'Маркери, що розкривають', desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', }, revealMode: { - label: 'Режим виявлення', - desc: 'Clear видаляє прокляття в межах видимості. Натомість Glimpse робить їх прозорими; вони видаляються, коли в них входить маркер.', + label: 'Режим розкриття', + desc: '«Очищення» видаляє гекси в межах видимості. «Проблиск» натомість робить їх напівпрозорими; вони видаляються, коли на них заходить маркер.', }, announce: { - label: 'Оголосити відкриття', + label: 'Оголошувати відкриття', desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', }, pingDiscoveries: { - label: 'Ping відкриття', + label: 'Пінгувати знахідки', desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', }, hideCoveredTokens: { - label: 'Приховати закриті токени', + label: 'Ховати маркери під гексами', desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', }, }, status: { - engine: 'Ігровий двигун', + engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шестигранний шар', + layer: 'Шар шестикутників', hexes: 'Гекси', named: 'Іменовані гекси', - icons: 'Жетони розташування', - glimpsed: 'Помітені прокляття', - pending: 'Локації очікують на заповнення', - calibrated: 'Відкалібрований', - overrides: 'Перевизначення сторінок', + icons: 'Маркери локацій', + glimpsed: 'Гекси в проблиску', + pending: 'Локації, що чекають на заповнення', + calibrated: 'Відкалібровано', + overrides: 'Перевизначення сторінки', undo: 'Доступне скасування', }, messages: { @@ -9903,7 +9918,7 @@ const HexplorationMod = (() => { revealed: 'Розкрито гекси: {count}.', revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: - 'Видалити всі шістнадцяткові з "{page}" ({count})? Жетони розташування повертаються на рівень маркерів. Скасувати це не можна.', + 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', resetPage: 'Зі сторінки видалено шестигранники: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', @@ -9921,11 +9936,11 @@ const HexplorationMod = (() => { 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: - 'Ваші шістнадцяткові карти Hexploration 1.x оновлено. Якщо цю гру було скопійовано з Legacy гри, запустіть Rescan на кожній сторінці шістнадцяткової карти.', + 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', pruned: - 'Збережені гекси, які більше не існують і були забуті: {dropped}. Якщо цю гру чи сторінку було скопійовано, запустіть Повторне сканування на сторінці, щоб знову вибрати її гекси.', + 'Забуто збережені гекси, яких більше не існує: {dropped}. Якщо цю гру чи сторінку було скопійовано, виконайте «Пересканувати» на сторінці, щоб знову знайти її гекси.', readyHint: - 'Введіть !hexploration для меню або відкрийте роздатковий матеріал «Hexploration — командна колода».', + 'Введіть !hexploration, щоб відкрити меню, або відкрийте роздатковий матеріал "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: @@ -9935,7 +9950,7 @@ const HexplorationMod = (() => { }, errors: { noPage: 'Не вдалося знайти сторінку для роботи.', - notHex: 'На цій сторінці не використовується шістнадцяткова сітка.', + notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', emptyArea: 'Вибрана область не містить шестигранних центрів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', @@ -9954,8 +9969,7 @@ const HexplorationMod = (() => { }, hints: { noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', - notHex: - 'Встановіть шістнадцяткову (V) або шістнадцяткову (H) сітку сторінки в параметрах сторінки.', + notHex: 'Установіть для сітки сторінки Hex (V) або Hex (H) у налаштуваннях сторінки.', noPolygons: 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', @@ -9986,22 +10000,20 @@ const HexplorationMod = (() => { set: 'Змінити налаштування або показати всі налаштування.', pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', - rescan: - 'Перебудуйте шістнадцятковий список сторінки, наприклад, після копіювання сторінки чи гри.', + rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: - 'Вирівняйте шістнадцяткову сітку одним або двома вибраними жетонами, прикріпленими до центрів шістнадцяткової форми.', + 'Вирівняйте гексову сітку за одним або двома вибраними маркерами, прив’язаними до центрів гексів.', calibrateReset: 'Видалити калібрування поточної сторінки.', status: 'Покажіть, що Hexploration знає про поточну сторінку.', - journal: 'Перебудуйте роздаткові матеріали довідки та командної колоди.', + journal: 'Перебудуйте роздаткові матеріали «Довідка» та «Command Deck».', help: 'Покажіть цей список.', handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', }, deck: { - subtitle: 'Командна колода', drawDesc: - 'Намалюйте фігури навколо області, виділіть їх і заповніть. Скасувати зворотне останнє заповнення.', + 'Обведіть область фігурами, виділіть їх і натисніть «Заповнити». «Скасувати заповнення» скасовує останнє заповнення.', revealDesc: - 'Виберіть гексагони, фігури або жетони, щоб відкрити або закрити їх знову. Досліджуйте розкриття навколо вибраних жетонів, ніби вони перемістилися.', + 'Виділіть гекси, фігури або маркери, щоб розкрити їх або знову приховати. «Дослідити» розкриває гекси навколо вибраних маркерів, ніби вони туди перемістилися.', locationsDesc: 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', toolsDesc: @@ -10010,7 +10022,7 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Версія', - subtitle: 'Шістнадцяткове дослідження для Roll20', + subtitle: 'Дослідження гекс за гексом для Roll20', footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', @@ -10022,9 +10034,9 @@ const HexplorationMod = (() => { steps: [ 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', - 'Виберіть фігури та натисніть «Заповнити» на панелі команд (або введіть !hexploration fill). Фігури замінено шестигранниками.', - 'Додатково: перед заповненням виберіть маркери для важливих місць і натисніть «Позначити місце». Вони ховаються під прокляттями та оголошуються, коли їх виявляють.', - 'Перемістіть жетон гравця. Кожен гекс, через який він проходить, і гекси в межах його видимості розкриваються.', + 'Виберіть фігури та натисніть «Заповнити» в Command Deck (або введіть !hexploration fill). Фігури буде замінено гексами.', + 'Додатково: перед заповненням виділіть маркери важливих місць і натисніть «Позначити локацію». Вони сховаються під гексами, а коли їх виявлять, про це буде оголошено.', + 'Перемістіть маркер гравця. Кожен гекс, через який він проходить, і гекси в межах його «Дальності огляду» розкриваються.', ], }, commands: { @@ -10037,29 +10049,29 @@ const HexplorationMod = (() => { revealing: { heading: 'Як працює розкриття', points: [ - 'Лише жетони на шарі жетонів розкривають гексагони. Кількість жетонів встановлюється Tokens That Reveal: жетони гравця за замовчуванням, щоб GM міг пересувати монстрів, не відкриваючи карту.', - 'Жетони показують кожен гексагон, який він охоплює (великі жетони охоплюють декілька), а з увімкненим параметром «Показати вздовж шляху» — кожен гексагон на маршруті, по якому його перетягнули, включно з маршрутними точками.', - 'Відстань видимості показує гекси навколо кожного з цих гексів. З увімкненою лінією видимості гекс відкривається, лише якщо між ними немає закритого гексу.', - 'Hex Reveal Distance зберігається в гексах під час їх малювання. Ці гекси відкриваються лише всередині такої кількості гексів, як би далеко не бачив жетон. Використовуйте його для гір або лісів, які приховують те, що за ними.', - 'У режимі Glimpse гекси в межах видимості стають прозорими, а не зникають, і видаляються, коли в них потрапляє жетон.', - 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', - 'API не повідомляє про рухи, зроблені іншими модами. Рухи TokenMod підбираються автоматично; для інших модів виберіть маркери та натисніть «Дослідити» або викличте Hexploration.revealAround(токен) із власного моду.', + 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', + 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів. З увімкненою «Лінією видимості» гекс розкривається, лише якщо між ним і маркером немає закритого гекса.', + '«Відстань розкриття шестикутників» зберігається в гексах під час їх малювання. Такі гекси розкриваються лише з відстані, не більшої за цю кількість гексів, хоч би як далеко бачив маркер. Використовуйте її для гір або лісів, що приховують те, що за ними.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер.', + "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", + 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', ], }, locations: { heading: 'Іменовані гекси та локації', points: [ - 'Функція Mark Location перетворює вибрані маркери на приховані місця. Жетон, який вже знаходиться під гексом, відразу ховається; інакше він прихований наступною заливкою, яка його покриває.', + '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - 'Name Hex дає шістнадцятковій формі ім’я без маркера. Ім’я показується GM як мітка на шарі GM і оголошується, коли відкривається гекс.', - 'Announce Discoveries вибирає, чи всі, лише GM, чи ніхто не бачитиме оголошення. Ping Discoveries також переміщує погляд гравців на місце.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змініть налаштування за допомогою !hexploration set (або кнопки «Параметри»). Hex Layer, Tokens That Reveal і Language також можна встановити на сторінці налаштувань мода.', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', colKey: 'ключ', colName: 'Налаштування', colDesc: 'опис', @@ -10069,18 +10081,18 @@ const HexplorationMod = (() => { heading: 'Jumpgate і Legacy', points: [ 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для Hex Layer встановлено значення Auto, гекси малюються на передньому шарі над жетонами, тому гравці не можуть бачити, що знаходиться під ними. Якщо передній рівень недоступний, замість нього використовується рівень маркерів.', - 'Jumpgate малює математично правильні гекси, які мають дещо іншу форму від гексів Legacy. Якщо шестигранники не збігаються з сіткою сторінки, прив’яжіть жетон до центру шестигранника, виберіть його та натисніть «Відкалібрувати». Виберіть два жетони в сусідніх шістнадцятках одного рядка (Hex V) або стовпця (Hex H), щоб також виправити розмір шістнадцятки.', - 'Коли сторінка чи гра копіюються, її гекси отримують нові ідентифікатори. Запустіть Rescan на сторінці, щоб знову підібрати їх разом із мітками з іменами та маркерами розташування.', + 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', + 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], }, upgrading: { heading: 'Оновлення з версії 1', points: [ 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', - 'Існуючі шістнадцяткові карти, імена, маркери розташування та налаштування оновлюються автоматично під час першого запуску.', + 'Наявні гексові карти, назви, маркери локацій і налаштування оновлюються автоматично під час першого запуску.', 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', - 'Версія 1 дозволяла будь-якій жетоні, яка представляла символ, розкривати гекси. Щоб зберегти таку поведінку, встановіть маркери, які розкриваються, на маркери символів.', + 'У версії 1 гекси міг розкривати будь-який маркер, що представляв персонажа. Щоб зберегти таку поведінку, встановіть для «Маркери, що розкривають» значення «Маркери персонажів».', ], colV1: 'Команда версії 1', colV2: 'Команда версії 2', @@ -10088,18 +10100,18 @@ const HexplorationMod = (() => { troubleshooting: { heading: 'Усунення несправностей', points: [ - 'Нічого не відбувається, коли маркер рухається: перевірте, чи маркер знаходиться на рівні маркерів і відповідає маркерам, які розкривають, і чи сторінка має шестигранники (статус!hexploration).', - 'Гекси зміщені відносно сітки: скористайтеся Калібруванням, а потім перевірте жетоном на кількох гексах на карті.', - 'Гекси перестали виявлятися після копіювання сторінки або гри: запустіть Rescan на сторінці.', - 'Заливка каже, що область не має шестигранних центрів: фігура має містити центр принаймні одного шестигранника.', + 'Коли маркер рухається, нічого не відбувається: перевірте, чи маркер на шарі маркерів і відповідає параметру «Маркери, що розкривають», а на сторінці є гекси (!hexploration status).', + 'Гекси зміщені відносно сітки: натисніть «Відкалібрувати», а потім перевірте маркером кілька гексів у різних частинах карти.', + 'Гекси перестали розкриватися після копіювання сторінки або гри: виконайте «Пересканувати» на сторінці.', + '«Заповнити» повідомляє, що в області немає центрів гексів: фігура має містити центр принаймні одного гекса.', 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', ], }, languages: { heading: 'Мови', - body: 'Виберіть мову за допомогою !hexploration встановленої мови. Доступні мови:', + body: 'Виберіть мову командою !hexploration set language. Доступні мови:', colLanguage: 'Мова', - colNative: 'Рідна назва', + colNative: 'Самоназва', colCode: 'Код', }, credits: { @@ -12648,10 +12660,10 @@ const HexplorationMod = (() => { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ - escapeHtml(flag ? `${flag} ${name}` : name), - escapeHtml(nativeName || name), - code(localeCode), + const locales = LOCALE_DEFINITIONS.map((locale) => [ + escapeHtml(locale.name), + escapeHtml(locale.nativeName || locale.name), + `${buildLocaleFlag(locale)}${code(locale.code)}`, ]); const { original, maintainer } = AUTHOR_LINKS; @@ -12697,7 +12709,7 @@ const HexplorationMod = (() => { return `

    ⬢ ${SCRIPT_NAME} ⬢

    -

    ${escapeHtml(tr('deck.subtitle'))} • v${SCRIPT_VERSION}

    +

    ${DECK_TITLE} • v${SCRIPT_VERSION}

    ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} @@ -13681,7 +13693,11 @@ const HexplorationMod = (() => { const config = getConfig(); const rows = SETTING_ROWS.map((row) => { const value = config[row.key]; - const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const flag = + row.key === 'language' + ? buildLocaleFlag(LOCALE_DEFINITIONS.find(({ code }) => code === value)) + : ''; + const shown = row.color ? buildSwatch(value) : flag + escapeHtml(formatValue(row.key, value)); const button = buildSecondaryButton( tr('buttons.change'), `${COMMAND} set ${row.key} ${settingQuery(row, value)}` @@ -13703,8 +13719,12 @@ const HexplorationMod = (() => { * @returns {void} */ function showLanguages(playerId) { - const buttons = SUPPORTED_LOCALES.map((code) => - buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + const buttons = LOCALE_DEFINITIONS.map((locale) => + buildSecondaryButton( + LOCALE_LABELS[locale.code], + `${COMMAND} set language ${locale.code}`, + buildLocaleFlag(locale) + ) ); whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); } diff --git a/Hexploration/src/chat.js b/Hexploration/src/chat.js index 2100727a6c..8b23619842 100644 --- a/Hexploration/src/chat.js +++ b/Hexploration/src/chat.js @@ -198,10 +198,42 @@ export function buildButton(label, command) { * * @param {string} label Button label. * @param {string} command Chat command the button runs. + * @param {string} [prefixHtml=''] Trusted HTML shown before the label, such as a flag. * @returns {string} HTML anchor. */ -export function buildSecondaryButton(label, command) { - return `${escapeHtml(label)}`; +export function buildSecondaryButton(label, command, prefixHtml = '') { + return `${prefixHtml}${escapeHtml(label)}`; +} + +/** + * Builds a Twemoji asset URL for a locale flag. + * + * @param {string} flag Unicode regional-indicator flag. + * @returns {string} SVG asset URL or an empty string. + */ +function flagAssetUrl(flag) { + const codepoints = Array.from(String(flag || '').trim()) + .map((character) => character.codePointAt(0).toString(16)) + .join('-'); + return codepoints + ? `https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/${codepoints}.svg` + : ''; +} + +/** + * Builds a locale's flag as a Twemoji image. Roll20 on Windows shows emoji + * flags as letter pairs, so the flag is drawn from an SVG instead. + * + * @param {object} locale Locale metadata. + * @returns {string} Trusted flag HTML, or an empty string when there is no flag. + */ +export function buildLocaleFlag(locale) { + const label = escapeHtml(locale?.flagLabel || locale?.name || ''); + const url = flagAssetUrl(locale?.flag); + if (!url) { + return ''; + } + return `${label}`; } /** diff --git a/Hexploration/src/commands.js b/Hexploration/src/commands.js index 6511f04df6..80612cbceb 100644 --- a/Hexploration/src/commands.js +++ b/Hexploration/src/commands.js @@ -1,6 +1,7 @@ import { buildButton, buildDivider, + buildLocaleFlag, buildRow, buildSecondaryButton, buildSectionLabel, @@ -39,7 +40,7 @@ import { resetCalibration, undoLastFill, } from './hexes.js'; -import { LOCALE_LABELS, SUPPORTED_LOCALES, t } from './i18n.js'; +import { LOCALE_DEFINITIONS, LOCALE_LABELS, SUPPORTED_LOCALES, t } from './i18n.js'; import { installHandouts } from './journals.js'; import { markLocations, setHexName, unmarkLocations } from './locations.js'; import { getHexLayer, isPathObject } from './paths.js'; @@ -685,7 +686,11 @@ function showSettings(playerId) { const config = getConfig(); const rows = SETTING_ROWS.map((row) => { const value = config[row.key]; - const shown = row.color ? buildSwatch(value) : escapeHtml(formatValue(row.key, value)); + const flag = + row.key === 'language' + ? buildLocaleFlag(LOCALE_DEFINITIONS.find(({ code }) => code === value)) + : ''; + const shown = row.color ? buildSwatch(value) : flag + escapeHtml(formatValue(row.key, value)); const button = buildSecondaryButton( tr('buttons.change'), `${COMMAND} set ${row.key} ${settingQuery(row, value)}` @@ -707,8 +712,12 @@ function showSettings(playerId) { * @returns {void} */ function showLanguages(playerId) { - const buttons = SUPPORTED_LOCALES.map((code) => - buildSecondaryButton(LOCALE_LABELS[code], `${COMMAND} set language ${code}`) + const buttons = LOCALE_DEFINITIONS.map((locale) => + buildSecondaryButton( + LOCALE_LABELS[locale.code], + `${COMMAND} set language ${locale.code}`, + buildLocaleFlag(locale) + ) ); whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); } diff --git a/Hexploration/src/journals.js b/Hexploration/src/journals.js index b16da887cf..b1cae65986 100644 --- a/Hexploration/src/journals.js +++ b/Hexploration/src/journals.js @@ -21,6 +21,7 @@ import { SCRIPT_NAME, SCRIPT_VERSION, } from './constants.js'; +import { buildLocaleFlag } from './chat.js'; import { getDirectionStyle, getLocale, LOCALE_DEFINITIONS, t, tRaw } from './i18n.js'; import { getConfig } from './state.js'; import { escapeHtml } from './utils.js'; @@ -138,10 +139,10 @@ export function buildHelpHtml(locale) { ['!hexploration_configModifyProperty …', `${COMMAND} set …`], ].map(([v1, v2]) => [code(v1), code(v2)]); - const locales = LOCALE_DEFINITIONS.map(({ code: localeCode, name, nativeName, flag }) => [ - escapeHtml(flag ? `${flag} ${name}` : name), - escapeHtml(nativeName || name), - code(localeCode), + const locales = LOCALE_DEFINITIONS.map((locale) => [ + escapeHtml(locale.name), + escapeHtml(locale.nativeName || locale.name), + `${buildLocaleFlag(locale)}${code(locale.code)}`, ]); const { original, maintainer } = AUTHOR_LINKS; From 86bc5cfe78902d46a9010fbc13eea0dd53677ce9 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Thu, 29 Oct 2026 19:49:21 +0000 Subject: [PATCH 12/24] fix(Hexploration): Restore the language command in Italian Google Translate turned "!hexploration set language" in the Help handout's language section into Italian words, so Italian users were told to type a command that does not exist. Put the command back, and rebuild the script and the 2.0.0 snapshot. Signed-off-by: Steve Roberts --- Hexploration/2.0.0/Hexploration.js | 6 +++--- Hexploration/Hexploration.js | 6 +++--- Hexploration/src/locales/locale/it.js | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Hexploration/2.0.0/Hexploration.js b/Hexploration/2.0.0/Hexploration.js index 062b681f65..cff78e3990 100644 --- a/Hexploration/2.0.0/Hexploration.js +++ b/Hexploration/2.0.0/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T15:52:46.956Z + * Built: 2026-10-29T19:48:15.389Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T15:52:46.956Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T19:48:15.389Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -6362,7 +6362,7 @@ const HexplorationMod = (() => { }, languages: { heading: 'Lingue', - body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + body: 'Scegli una lingua con !hexploration set language. Lingue disponibili:', colLanguage: 'Lingua', colNative: 'Nome originale', colCode: 'Codice', diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index 062b681f65..cff78e3990 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.0 - * Built: 2026-10-29T15:52:46.956Z + * Built: 2026-10-29T19:48:15.389Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T15:52:46.956Z'; + const SCRIPT_LAST_UPDATED = '2026-10-29T19:48:15.389Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -6362,7 +6362,7 @@ const HexplorationMod = (() => { }, languages: { heading: 'Lingue', - body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + body: 'Scegli una lingua con !hexploration set language. Lingue disponibili:', colLanguage: 'Lingua', colNative: 'Nome originale', colCode: 'Codice', diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index e7f00a028c..b082b24bf2 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -358,7 +358,7 @@ const TRANSLATION = { }, languages: { heading: 'Lingue', - body: "Scegli una lingua con la lingua impostata per l'esplorazione. Lingue disponibili:", + body: 'Scegli una lingua con !hexploration set language. Lingue disponibili:', colLanguage: 'Lingua', colNative: 'Nome originale', colCode: 'Codice', From fb6edbc921434bda658104bc8e20217ff7b7c11f Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:30:02 +0000 Subject: [PATCH 13/24] fix(Hexploration): Convert hex colours for Jumpgate Jumpgate's pathv2 objects silently ignore rgb() and rgba() fill and stroke colours and keep the colour they already had. The default glimpse colour is rgba(34,34,34,0.5), so glimpsed hexes in Jumpgate stayed solid and glimpse appeared not to work, as a user reported. The same applied to rgba() fill colours meant to make see-through hexes. Colours written to pathv2 hexes are now converted to #rrggbb, or to #rrggbbaa when they have transparency; both are accepted and drawn see-through. Legacy paths accept rgba(), so they keep the colour as set. The conversion covers new hexes, restyled hexes, undo and glimpse. Hexes that 2.0.0 marked as glimpsed without changing their colour are repainted the next time a token sees them. The test stub now drops pathv2 colours Jumpgate would reject, so the tests catch this kind of regression. Signed-off-by: Steve Roberts --- Hexploration/src/hexes.js | 5 ++- Hexploration/src/paths.js | 35 +++++++++++++++-- Hexploration/src/reveal.js | 21 ++++++++--- Hexploration/src/utils.js | 48 ++++++++++++++++++++++++ Hexploration/tests/hexploration.test.mjs | 35 ++++++++++++++++- Hexploration/tests/roll20-stub.mjs | 22 ++++++++++- Hexploration/tests/utils.test.mjs | 32 ++++++++++++++++ 7 files changed, 184 insertions(+), 14 deletions(-) create mode 100644 Hexploration/tests/utils.test.mjs diff --git a/Hexploration/src/hexes.js b/Hexploration/src/hexes.js index 2ce07dfb16..4156210999 100644 --- a/Hexploration/src/hexes.js +++ b/Hexploration/src/hexes.js @@ -35,6 +35,7 @@ import { readPathProps, recreatePath, safeRemove, + setPathStyle, } from './paths.js'; import { boundingBox, distinctVertices, pointInShape, ringCentre } from './polygon.js'; import { @@ -204,7 +205,7 @@ export function fillCells(ctx, cells, { sources = [], kind, onDone }) { maxDistance: hex.maxDistance ?? null, glimpsed: hex.glimpsed === true, }); - existingPath.set({ + setPathStyle(existingPath, { fill: style.fill, stroke: style.stroke, stroke_width: style.strokeWidth, @@ -305,7 +306,7 @@ export function undoLastFill() { const hex = getHex(record.pageId, prev.key); const path = hex ? getPathObject(hex.id, hex.type) : null; if (path) { - path.set({ fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); + setPathStyle(path, { fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); if (Number.isInteger(prev.maxDistance)) { hex.maxDistance = prev.maxDistance; } else { diff --git a/Hexploration/src/paths.js b/Hexploration/src/paths.js index 123d5dc875..5c0f0c62a4 100644 --- a/Hexploration/src/paths.js +++ b/Hexploration/src/paths.js @@ -11,7 +11,7 @@ import { } from './constants.js'; import { pathToRings, polygonPathProps } from './polygon.js'; import { getConfig } from './state.js'; -import { isJumpgate } from './utils.js'; +import { isJumpgate, toPathV2Color } from './utils.js'; // Set when the foreground layer turns out to be unavailable, so later hexes // go straight to the token layer instead of failing one by one. @@ -49,6 +49,35 @@ export function isPathObject(obj) { return !!obj && PATH_TYPES.includes(obj.get('_type')); } +/** + * Returns a colour in a form the given path type accepts. + * + * @param {string} color Colour from the settings. + * @param {string} type Path type. + * @returns {string} Colour to write. + */ +export function pathColor(color, type) { + return type === PATH_TYPE_V2 ? toPathV2Color(color) : color; +} + +/** + * Sets a path's colours, converting them for Jumpgate pathv2 objects. + * + * @param {object} obj Roll20 path or pathv2. + * @param {object} attrs Attributes to set; `fill` and `stroke` are converted. + * @returns {void} + */ +export function setPathStyle(obj, attrs) { + const type = obj.get('_type'); + const converted = { ...attrs }; + for (const key of ['fill', 'stroke']) { + if (key in converted) { + converted[key] = pathColor(converted[key], type); + } + } + obj.set(converted); +} + /** * Copies the properties the polygon module needs from a path. * @@ -150,8 +179,8 @@ export function createHexPath(pageId, corners, style) { const attrs = { ...geometry, _pageid: pageId, - fill: style.fill, - stroke: style.stroke, + fill: pathColor(style.fill, type), + stroke: pathColor(style.stroke, type), stroke_width: style.strokeWidth, controlledby: '', }; diff --git a/Hexploration/src/reveal.js b/Hexploration/src/reveal.js index 5c7906b3de..12905b68da 100644 --- a/Hexploration/src/reveal.js +++ b/Hexploration/src/reveal.js @@ -16,7 +16,7 @@ import { import { removeHex } from './hexes.js'; import { t } from './i18n.js'; import { getDiscoveryName, getHexIcon } from './locations.js'; -import { getPathObject } from './paths.js'; +import { getPathObject, pathColor } from './paths.js'; import { getConfig, getHex, getPageHexes, getPageSettings } from './state.js'; import { escapeHtml, getTokenControllers, runInBatches, toText } from './utils.js'; @@ -114,17 +114,26 @@ export function revealHex(ctx, key, settings, { distance = 0, announce = true } */ export function glimpseHex(ctx, key, distance) { const hex = getHex(ctx.pageId, key); - if (!hex || hex.glimpsed) { - return false; - } - if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + if (!hex) { return false; } const path = getPathObject(hex.id, hex.type); if (!path) { return false; } - path.set('fill', getConfig().glimpseColor); + const fill = pathColor(getConfig().glimpseColor, path.get('_type')); + if (hex.glimpsed) { + // Versions before this fix marked Jumpgate hexes as glimpsed without + // changing their colour; repaint them when they are seen again. + if (path.get('fill') !== fill) { + path.set('fill', fill); + } + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + path.set('fill', fill); hex.glimpsed = true; return true; } diff --git a/Hexploration/src/utils.js b/Hexploration/src/utils.js index 3f8e2b97c8..0caa56d820 100644 --- a/Hexploration/src/utils.js +++ b/Hexploration/src/utils.js @@ -81,6 +81,54 @@ export function isValidColor(raw) { ); } +/** + * Parses a hex, rgb() or rgba() colour into its channels. + * + * @param {*} raw Colour text. + * @returns {{r: number, g: number, b: number, a: number}|null} Channels 0–255 and alpha 0–1, or null for other colours such as names. + */ +function parseColor(raw) { + const text = toText(raw); + + const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(text); + if (hex) { + const digits = hex[1].length <= 4 ? [...hex[1]].map((c) => c + c).join('') : hex[1]; + const [r, g, b, a = 255] = digits.match(/../g).map((pair) => parseInt(pair, 16)); + return { r, g, b, a: a / 255 }; + } + + const fn = + /^rgba?\(\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i.exec( + text + ); + if (!fn) { + return null; + } + const channel = (v) => + clamp(v.endsWith('%') ? (parseFloat(v) * 255) / 100 : parseFloat(v), 0, 255); + const alpha = + fn[4] === undefined ? 1 : fn[4].endsWith('%') ? parseFloat(fn[4]) / 100 : parseFloat(fn[4]); + return { r: channel(fn[1]), g: channel(fn[2]), b: channel(fn[3]), a: clamp(alpha, 0, 1) }; +} + +/** + * Converts a colour to the #rrggbb or #rrggbbaa form Jumpgate's pathv2 objects + * accept. Jumpgate silently ignores rgb(), rgba() and short hex colours, so a + * hex keeps its old colour. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for a pathv2 fill or stroke. + */ +export function toPathV2Color(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + const hex = (n) => Math.round(n).toString(16).padStart(2, '0'); + const rgb = `#${hex(color.r)}${hex(color.g)}${hex(color.b)}`; + return color.a >= 1 ? rgb : `${rgb}${hex(color.a * 255)}`; +} + /** * Clamps a number into a range. * diff --git a/Hexploration/tests/hexploration.test.mjs b/Hexploration/tests/hexploration.test.mjs index d68b907772..bc6a18805a 100644 --- a/Hexploration/tests/hexploration.test.mjs +++ b/Hexploration/tests/hexploration.test.mjs @@ -232,7 +232,40 @@ describe('revealing', () => { const neighbour = game.hexState().pages.page1.hexes['2,4']; assert.equal(neighbour.glimpsed, true); const path = game.objects.get(neighbour.id); - assert.equal(path.attrs.fill, 'rgba(34,34,34,0.5)'); + // Jumpgate ignores rgba(), so the default glimpse colour is converted. + assert.equal(path.attrs.fill, '#22222280'); + }); + + it('converts rgba() hex colours for Jumpgate', () => { + const game = readyGame(); + game.command('!hexploration set fillColor rgba(255,0,0,0.25)'); + game.command('!hexploration set strokeColor rgb(0,128,255)'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 300, 300)]); + const hexes = game.ofType('pathv2'); + assert.ok(hexes.length > 0); + assert.ok(hexes.every((h) => h.attrs.fill === '#ff000040' && h.attrs.stroke === '#0080ff')); + }); + + it('repaints Jumpgate hexes glimpsed before the colour fix', () => { + const game = readyGame(); + game.command('!hexploration set revealMode glimpse'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + const neighbour = game.hexState().pages.page1.hexes['2,4']; + neighbour.glimpsed = true; + const token = addToken(game, JG_V, 2, 2); + game.move(token, ...hexToPixel(JG_V, 2, 3)); + assert.equal(game.objects.get(neighbour.id).attrs.fill, '#22222280'); + }); + + it('keeps rgba() glimpse colours in Legacy games', () => { + const game = readyGame({ jumpgate: false }); + game.command('!hexploration set revealMode glimpse'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500, false)]); + const token = addToken(game, LEGACY_V, 2, 2); + game.move(token, ...hexToPixel(LEGACY_V, 2, 3)); + const neighbour = game.hexState().pages.page1.hexes['2,4']; + assert.equal(neighbour.glimpsed, true); + assert.equal(game.objects.get(neighbour.id).attrs.fill, 'rgba(34,34,34,0.5)'); }); it('reveals through the public API and the explore command', () => { diff --git a/Hexploration/tests/roll20-stub.mjs b/Hexploration/tests/roll20-stub.mjs index 126704d2e7..973cf08fe9 100644 --- a/Hexploration/tests/roll20-stub.mjs +++ b/Hexploration/tests/roll20-stub.mjs @@ -40,9 +40,24 @@ export function createSandbox({ } }; + // Jumpgate keeps a pathv2's old fill or stroke when given rgb(), rgba() or + // other forms it does not accept; #rrggbb and #rrggbbaa work. + const dropRejectedColors = (type, attrs) => { + if (type !== 'pathv2') { + return attrs; + } + const kept = { ...attrs }; + for (const key of ['fill', 'stroke']) { + if (key in kept && !/^(#[0-9a-f]{6}([0-9a-f]{2})?|transparent)$/i.test(String(kept[key]))) { + delete kept[key]; + } + } + return kept; + }; + class Obj { constructor(type, attrs) { - this.attrs = { ...attrs, _type: type }; + this.attrs = { ...dropRejectedColors(type, attrs), _type: type }; if ('pageid' in this.attrs && !('_pageid' in this.attrs)) { this.attrs._pageid = this.attrs.pageid; } @@ -63,7 +78,10 @@ export function createSandbox({ return this.attrs[`_${key}`]; } set(key, value) { - const updates = typeof key === 'object' ? key : { [key]: value }; + const updates = dropRejectedColors( + this.attrs._type, + typeof key === 'object' ? key : { [key]: value } + ); const prev = { ...this.attrs }; Object.assign(this.attrs, updates); // Roll20 does not raise change events for API changes. diff --git a/Hexploration/tests/utils.test.mjs b/Hexploration/tests/utils.test.mjs new file mode 100644 index 0000000000..efb0424aa2 --- /dev/null +++ b/Hexploration/tests/utils.test.mjs @@ -0,0 +1,32 @@ +import assert from 'node:assert/strict'; +import { describe, it } from 'node:test'; + +import { toPathV2Color } from '../src/utils.js'; + +describe('toPathV2Color', () => { + it('converts rgba() to #rrggbbaa', () => { + assert.equal(toPathV2Color('rgba(34,34,34,0.5)'), '#22222280'); + assert.equal(toPathV2Color('rgba( 255 , 0 , 0 , 0 )'), '#ff000000'); + assert.equal(toPathV2Color('RGBA(100%,50%,0%,25%)'), '#ff800040'); + }); + + it('converts rgb() with an alpha value, as a user reported', () => { + assert.equal(toPathV2Color('rgb(140,135,122,0.9)'), '#8c877ae6'); + }); + + it('drops a fully opaque alpha', () => { + assert.equal(toPathV2Color('rgba(1,2,3,1)'), '#010203'); + assert.equal(toPathV2Color('rgb(0,128,255)'), '#0080ff'); + }); + + it('expands short hex colours', () => { + assert.equal(toPathV2Color('#abc'), '#aabbcc'); + assert.equal(toPathV2Color('#abc8'), '#aabbcc88'); + }); + + it('leaves full hex colours and names alone', () => { + assert.equal(toPathV2Color('#222222'), '#222222'); + assert.equal(toPathV2Color('#22222280'), '#22222280'); + assert.equal(toPathV2Color('transparent'), 'transparent'); + }); +}); From bc874e053de22eda55690da4a09da7099b889aaa Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:30:13 +0000 Subject: [PATCH 14/24] fix(Hexploration): Show transparent colours in settings swatches Roll20 chat strips inline background colours written as #rrggbbaa or as rgb() with a fourth value, so the swatch next to such a colour on the settings card was empty. A user found the swatch did not match the colour they had set. Swatches now draw colours with transparency as rgba(), which chat keeps, and opaque colours as #rrggbb. The text beside the swatch still shows the colour exactly as it was typed. Signed-off-by: Steve Roberts --- Hexploration/src/chat.js | 4 ++-- Hexploration/src/utils.js | 20 ++++++++++++++++++++ Hexploration/tests/utils.test.mjs | 21 ++++++++++++++++++++- 3 files changed, 42 insertions(+), 3 deletions(-) diff --git a/Hexploration/src/chat.js b/Hexploration/src/chat.js index 8b23619842..ec8950e86b 100644 --- a/Hexploration/src/chat.js +++ b/Hexploration/src/chat.js @@ -17,7 +17,7 @@ import { COLOR_WARNING_TEXT, SCRIPT_NAME, } from './constants.js'; -import { escapeHtml } from './utils.js'; +import { escapeHtml, toChatColor } from './utils.js'; const CHAT_CARD_STYLE = [ 'width:100%', @@ -279,5 +279,5 @@ export function buildRow(label, valueHtml) { */ export function buildSwatch(color) { const safe = escapeHtml(color); - return ` ${safe}`; + return ` ${safe}`; } diff --git a/Hexploration/src/utils.js b/Hexploration/src/utils.js index 0caa56d820..cfe654a82f 100644 --- a/Hexploration/src/utils.js +++ b/Hexploration/src/utils.js @@ -129,6 +129,26 @@ export function toPathV2Color(raw) { return color.a >= 1 ? rgb : `${rgb}${hex(color.a * 255)}`; } +/** + * Converts a colour to a form Roll20 chat keeps in inline styles. Chat drops + * #rrggbbaa colours and rgb() with an alpha value, leaving the style empty; + * #rrggbb and rgba() survive. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for chat HTML. + */ +export function toChatColor(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + if (color.a >= 1) { + return toPathV2Color(raw); + } + const [r, g, b] = [color.r, color.g, color.b].map(Math.round); + return `rgba(${r},${g},${b},${Math.round(color.a * 100) / 100})`; +} + /** * Clamps a number into a range. * diff --git a/Hexploration/tests/utils.test.mjs b/Hexploration/tests/utils.test.mjs index efb0424aa2..4b4105aeb3 100644 --- a/Hexploration/tests/utils.test.mjs +++ b/Hexploration/tests/utils.test.mjs @@ -1,7 +1,26 @@ import assert from 'node:assert/strict'; import { describe, it } from 'node:test'; -import { toPathV2Color } from '../src/utils.js'; +import { toChatColor, toPathV2Color } from '../src/utils.js'; + +describe('toChatColor', () => { + it('turns colours with alpha into rgba()', () => { + assert.equal(toChatColor('#8c877ae6'), 'rgba(140,135,122,0.9)'); + assert.equal(toChatColor('#f9730223'), 'rgba(249,115,2,0.14)'); + assert.equal(toChatColor('rgb(140,135,122,0.9)'), 'rgba(140,135,122,0.9)'); + assert.equal(toChatColor('#abc8'), 'rgba(170,187,204,0.53)'); + }); + + it('turns opaque colours into #rrggbb', () => { + assert.equal(toChatColor('#ABC'), '#aabbcc'); + assert.equal(toChatColor('#222222ff'), '#222222'); + assert.equal(toChatColor('rgb(0,128,255)'), '#0080ff'); + }); + + it('leaves names alone', () => { + assert.equal(toChatColor('red'), 'red'); + }); +}); describe('toPathV2Color', () => { it('converts rgba() to #rrggbbaa', () => { From ad24eafccc07a8b7163e4652e98aa09e640f13c5 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:30:27 +0000 Subject: [PATCH 15/24] docs(Hexploration): Document the colour formats The colour fixes left it unclear which colour formats the settings accept and why the colour on a Jumpgate hex can differ in form from the one typed. A user had used rgb() with a fourth value and could not tell whether it was supported. The README gains a Colours section listing the hex, rgb() and rgba() forms, how transparency is written in each, how Jumpgate hexes are converted to #rrggbb or #rrggbbaa, and why colour names should be avoided in Jumpgate. The Fill and Glimpse Colour rows now speak of a colour with transparency rather than only rgba(). The testing checklist gains glimpse, fill and swatch checks with the colour forms the user reported. Signed-off-by: Steve Roberts --- Hexploration/README.md | 24 ++++++++++++++++++++++-- Hexploration/TESTING.md | 3 +++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/Hexploration/README.md b/Hexploration/README.md index a828fa341e..e39d2eb53c 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -80,10 +80,10 @@ The version 1 commands still work, including the `Hexploration_menu` macro: | Key | Setting | Default | Per page | Description | | ------------------- | -------------------- | -------------------- | -------- | ------------------------------------------------------------------------------ | | `hexLayer` | Hex Layer | `auto` | | `auto`, `foreground` or `objects`. Auto tries the foreground layer first. | -| `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. `rgba()` makes see-through hexes. | +| `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. A colour with transparency makes see-through hexes. | | `strokeColor` | Border Colour | `#444444` | | Outline colour of new hexes. | | `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. | -| `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. | +| `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. Use a colour with transparency. | | `strokeWidth` | Border Width | `1` | | Outline width in pixels (0–20). | | `maxDistance` | Hex Reveal Distance | none | | Stored on new hexes; they reveal only from within this many hexes. | | `revealDistance` | Sight Distance | `1` | ✓ | Hexes revealed around a moving token (0–20). | @@ -100,6 +100,26 @@ The version 1 commands still work, including the `Hexploration_menu` macro: Games upgraded from version 1 keep their colours, border width and sight distance. +### Colours + +The colour settings accept: + +| Format | Example | Transparency | +| ------------------- | ---------------------- | ------------------------------------ | +| `#rrggbb` or `#rgb` | `#222222` | None | +| `#rrggbbaa` | `#22222280` | The last pair, from `00` to `ff` | +| `rgb(r,g,b)` | `rgb(34,34,34)` | None | +| `rgba(r,g,b,a)` | `rgba(34,34,34,0.5)` | `a`, from `0` (clear) to `1` (solid) | +| Colour names | `black`, `transparent` | `transparent` only | + +The red, green and blue values run from 0 to 255 or 0% to 100%. An `rgb()` with a fourth value is read as `rgba()`. + +Use a colour with transparency for **Glimpse Colour**, and for **Fill Colour** if you want see-through hexes. For example, `rgba(0,0,0,0.8)` and `#000000cc` are the same dark, mostly solid colour. + +Jumpgate ignores `rgb()` and `rgba()` colours on drawn shapes, so Hexploration converts the fill, border and glimpse colours of Jumpgate hexes to `#rrggbb` or `#rrggbbaa`. For example, `rgba(34,34,34,0.5)` is drawn as `#22222280`. The setting keeps the colour as you typed it, and Legacy games use it unchanged. Colour names cannot be converted, so in Jumpgate use a hex, `rgb()` or `rgba()` colour instead of a name. + +The swatch next to each colour on the settings card shows the colour with its transparency. + ## Jumpgate and Legacy - Hexploration detects the engine and draws `pathv2` shapes in Jumpgate and `path` shapes in Legacy games. Shapes drawn in either editor can be filled. diff --git a/Hexploration/TESTING.md b/Hexploration/TESTING.md index 5557eed661..87c0828f47 100644 --- a/Hexploration/TESTING.md +++ b/Hexploration/TESTING.md @@ -70,6 +70,9 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa - [ ] A 2 × 2 or 3 × 3 token reveals every hex it covers. - [ ] With Line of Sight on, hexes behind a hex drawn with Hex Reveal Distance 0 stay hidden until it is entered. - [ ] Glimpse mode: hexes within sight turn see-through; entering them removes them. +- [ ] Repeat glimpse with Glimpse Colour set to `rgba(140,135,122,0.9)`, `rgb(140,135,122,0.9)` and `#8c877ae6`. In Jumpgate all three give the same see-through colour, drawn as `#8c877ae6`. +- [ ] Fill with Fill Colour set to `rgba(255,0,0,0.25)`. The hexes are see-through red in both engines. +- [ ] `!hexploration set` shows a swatch for every colour, including `#rrggbbaa` and `rgba()` colours. - [ ] `!hexploration explore` with tokens selected reveals around them. - [ ] An NPC with player-visible name and bars moved under a hex shows neither to players; revealing its hex restores them. `set hideCoveredTokens off` restores every hidden token. - [ ] A TokenMod move (`!token-mod --set left|+70`) reveals hexes. From c21a7520804bcade8fc1747c9a2f888de70466f7 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:30:41 +0000 Subject: [PATCH 16/24] docs(Hexploration): Explain Hex Reveal Distance and Line of Sight A user changed Hex Reveal Distance and Line of Sight, saw no difference, and could not work out what either did from the help. Both behave as designed, but the help did not say when they matter: - Hex Reveal Distance is stored on each hex when it is filled, so changing it does nothing to hexes already on the map. - Hexes are revealed nearest first, so Line of Sight only blocks behind hexes that stay covered, and needs a Sight Distance of 2 or more. The help handout, the settings descriptions and the README now say so, with a mountain range example: fill the mountains with Hex Reveal Distance 0, then the land beyond with no limit. The README gives the example as commands in a new Terrain That Blocks Sight section, and notes that glimpsed hexes do not block Line of Sight. The five changed strings are translated into all 23 other languages, using each language's existing setting names so the help matches the buttons. Signed-off-by: Steve Roberts --- Hexploration/README.md | 58 ++++++++++++++++-------- Hexploration/src/locales/locale/af.js | 10 ++-- Hexploration/src/locales/locale/ca.js | 10 ++-- Hexploration/src/locales/locale/cs.js | 10 ++-- Hexploration/src/locales/locale/da.js | 10 ++-- Hexploration/src/locales/locale/de.js | 10 ++-- Hexploration/src/locales/locale/el.js | 10 ++-- Hexploration/src/locales/locale/en-US.js | 10 ++-- Hexploration/src/locales/locale/es.js | 10 ++-- Hexploration/src/locales/locale/fi.js | 10 ++-- Hexploration/src/locales/locale/fr.js | 10 ++-- Hexploration/src/locales/locale/he.js | 10 ++-- Hexploration/src/locales/locale/hu.js | 10 ++-- Hexploration/src/locales/locale/it.js | 10 ++-- Hexploration/src/locales/locale/ja.js | 10 ++-- Hexploration/src/locales/locale/ko.js | 10 ++-- Hexploration/src/locales/locale/nl.js | 10 ++-- Hexploration/src/locales/locale/pl.js | 10 ++-- Hexploration/src/locales/locale/pt-BR.js | 10 ++-- Hexploration/src/locales/locale/pt-PT.js | 10 ++-- Hexploration/src/locales/locale/ru.js | 10 ++-- Hexploration/src/locales/locale/sv.js | 10 ++-- Hexploration/src/locales/locale/tr.js | 10 ++-- Hexploration/src/locales/locale/uk.js | 10 ++-- Hexploration/src/locales/locale/zh-TW.js | 10 ++-- 25 files changed, 158 insertions(+), 140 deletions(-) diff --git a/Hexploration/README.md b/Hexploration/README.md index e39d2eb53c..01c19bdc59 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -69,32 +69,50 @@ The version 1 commands still work, including the `Hexploration_menu` macro: - Only tokens on the token layer reveal hexes. **Tokens That Reveal** chooses which: tokens controlled by a player (the default, so the GM can move monsters freely), tokens that represent any character (the version 1 behaviour), or all tokens. - A token reveals every hex it covers, so large tokens reveal several. With **Reveal Along Path** on, it also reveals every hex on the route it was dragged along, waypoints included. -- **Sight Distance** reveals the hexes around each of those hexes. With **Line of Sight** on, a hex is only revealed if no covered hex lies in between. -- **Hex Reveal Distance** is stored on hexes as they are drawn: those hexes can only be revealed from within that many hexes. Use it for terrain that hides what lies behind it. +- **Sight Distance** reveals the hexes around each of those hexes, nearest first. - **Reveal Mode: Glimpse** turns hexes within sight see-through instead of removing them; they are removed when a token enters them. - Roll20 draws token names, bars and auras above hexes. With **Hide Covered Tokens** on (the default), tokens under a covered hex have their player-visible name, bars and auras switched off until they are uncovered, so hidden monsters do not give themselves away. - The Roll20 API does not report token moves made by other Mods. Moves made by TokenMod are picked up automatically. For other Mods, select the tokens and use `!hexploration explore`, or call the API below. +### Terrain That Blocks Sight + +**Hex Reveal Distance** and **Line of Sight** work together to make terrain, such as mountains or dense forest, that the party cannot see into or past. + +- **Hex Reveal Distance** is stored on each hex when it is filled. A token must be within that many hexes to reveal the hex, however far it can see; with `0`, the hex is only revealed by entering it. Set it _before_ filling: changing it does not affect hexes already on the map. +- **Line of Sight** stops a hex being revealed while a covered hex lies between it and the token. Nearer hexes are revealed first, so in open country nothing is in the way and Line of Sight changes nothing. It only blocks behind hexes that stay covered, such as terrain filled with a Hex Reveal Distance. + +Neither makes a difference with the default **Sight Distance** of 1, apart from a Hex Reveal Distance of 0: a token only looks at the six hexes next to it, with nothing in between. + +For example, to add a mountain range: + +1. `!hexploration set revealDistance 3` +2. `!hexploration set maxDistance 0`, then select the shapes over the mountains and fill them. +3. `!hexploration set maxDistance none`, then fill the land beyond the mountains. + +A token walking up to the mountains reveals the open ground within 3 hexes, but the mountain hexes stay covered and so does everything behind them. Each mountain hex is revealed when a token walks into it. With Line of Sight off, the land behind the mountains is revealed from a distance, but the mountains still are not. + +Glimpsed hexes do not block Line of Sight. + ## Settings -| Key | Setting | Default | Per page | Description | -| ------------------- | -------------------- | -------------------- | -------- | ------------------------------------------------------------------------------ | -| `hexLayer` | Hex Layer | `auto` | | `auto`, `foreground` or `objects`. Auto tries the foreground layer first. | -| `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. A colour with transparency makes see-through hexes. | -| `strokeColor` | Border Colour | `#444444` | | Outline colour of new hexes. | -| `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. | -| `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. Use a colour with transparency. | -| `strokeWidth` | Border Width | `1` | | Outline width in pixels (0–20). | -| `maxDistance` | Hex Reveal Distance | none | | Stored on new hexes; they reveal only from within this many hexes. | -| `revealDistance` | Sight Distance | `1` | ✓ | Hexes revealed around a moving token (0–20). | -| `lineOfSight` | Line of Sight | `on` | ✓ | Covered hexes block sight. | -| `revealPath` | Reveal Along Path | `on` | ✓ | Reveal the whole route a token is dragged along. | -| `revealBy` | Tokens That Reveal | `players` | ✓ | `players`, `characters` or `all`. | -| `revealMode` | Reveal Mode | `clear` | ✓ | `clear` or `glimpse`. | -| `announce` | Announce Discoveries | `all` | ✓ | `all`, `gm` or `off`. | -| `pingDiscoveries` | Ping Discoveries | `off` | ✓ | Ping players to discovered locations. | -| `hideCoveredTokens` | Hide Covered Tokens | `on` | | Switch off player-visible names, bars and auras of tokens under covered hexes. | -| `language` | Language | `en-US` | | One of 24 languages. `!hexploration set language` lists them. | +| Key | Setting | Default | Per page | Description | +| ------------------- | -------------------- | -------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `hexLayer` | Hex Layer | `auto` | | `auto`, `foreground` or `objects`. Auto tries the foreground layer first. | +| `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. A colour with transparency makes see-through hexes. | +| `strokeColor` | Border Colour | `#444444` | | Outline colour of new hexes. | +| `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. | +| `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. Use a colour with transparency. | +| `strokeWidth` | Border Width | `1` | | Outline width in pixels (0–20). | +| `maxDistance` | Hex Reveal Distance | none | | Stored on hexes as they are filled; they reveal only from within this many hexes. Set it before filling. See [Terrain That Blocks Sight](#terrain-that-blocks-sight). | +| `revealDistance` | Sight Distance | `1` | ✓ | Hexes revealed around a moving token (0–20). | +| `lineOfSight` | Line of Sight | `on` | ✓ | Hexes that stay covered hide the hexes behind them. Needs a Sight Distance of 2 or more. | +| `revealPath` | Reveal Along Path | `on` | ✓ | Reveal the whole route a token is dragged along. | +| `revealBy` | Tokens That Reveal | `players` | ✓ | `players`, `characters` or `all`. | +| `revealMode` | Reveal Mode | `clear` | ✓ | `clear` or `glimpse`. | +| `announce` | Announce Discoveries | `all` | ✓ | `all`, `gm` or `off`. | +| `pingDiscoveries` | Ping Discoveries | `off` | ✓ | Ping players to discovered locations. | +| `hideCoveredTokens` | Hide Covered Tokens | `on` | | Switch off player-visible names, bars and auras of tokens under covered hexes. | +| `language` | Language | `en-US` | | One of 24 languages. `!hexploration set language` lists them. | **Hex Layer**, **Tokens That Reveal** and **Language** can also be set on the Mod's settings page in the API Scripts screen. diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index a60d44c6c5..b256c2f1f6 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Seshoek-onthullingsafstand', - desc: "Word op seshoeke toegepas wanneer hulle geteken word: 'n token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + desc: "Word op seshoeke gestoor wanneer hulle gevul word, so stel dit in voordat jy vul: om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien; met 0 word hulle slegs onthul deur hulle binne te gaan. Gebruik dit vir berge of woude. Laat leeg vir geen beperking nie.", }, revealDistance: { label: 'Sigafstand', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Siglyn', - desc: "Wanneer dit aan is, word 'n seshoek slegs onthul as geen bedekte seshoek tussen dit en die token lê nie.", + desc: "Wanneer dit aan is, versteek seshoeke wat bedek bly, soos berge wat met 'n Seshoek-onthullingsafstand gevul is, die seshoeke agter hulle. Dit maak slegs 'n verskil met 'n Sigafstand van 2 of meer.", }, revealPath: { label: 'Onthul langs pad', @@ -299,9 +299,9 @@ const TRANSLATION = { points: [ 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", - "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke. Met Siglyn aan, word 'n seshoek slegs onthul as geen bedekte seshoek tussenin lê nie.", - "Seshoek-onthullingsafstand word op seshoeke gestoor wanneer hulle geteken word. Daardie seshoeke word slegs van binne soveel seshoeke onthul, hoe ver 'n token ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle lê.", - "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke, die naaste eerste. Met Siglyn aan word 'n seshoek nie onthul solank 'n bedekte seshoek tussen dit en die token lê nie. Nader seshoeke word gewoonlik eerste onthul, so in oop terrein verander Siglyn niks nie: dit maak slegs saak met 'n Sigafstand van 2 of meer en seshoeke wat bedek bly, soos terrein wat met 'n Seshoek-onthullingsafstand gevul is.", + "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index bb2ae00ceb..72056ed65d 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distància de revelació dels hexàgons', - desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", + desc: "Es desa als hexàgons quan s'omplen, així que configureu-la abans d'omplir: canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure; amb 0, només es revelen quan s'hi entra. Utilitzeu-la per a muntanyes o boscos. Deixeu-ho buit perquè no hi hagi límit.", }, revealDistance: { label: 'Distància de visió', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Línia de visió', - desc: 'Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.', + desc: 'Quan està activat, els hexàgons que continuen coberts, com ara muntanyes omplertes amb una Distància de revelació dels hexàgons, amaguen els hexàgons que hi ha darrere. Només té efecte amb una Distància de visió de 2 o més.', }, revealPath: { label: 'Revela al llarg del camí', @@ -302,9 +302,9 @@ const TRANSLATION = { points: [ 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", - "La distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons. Amb Línia de visió activada, un hexàgon només es revela si no hi ha cap hexàgon cobert entremig.", - "La distància de revelació dels hexàgons s'emmagatzema als hexàgons quan es dibuixen. Aquests hexàgons només es revelen des d'un màxim d'aquest nombre d'hexàgons, per lluny que pugui veure una fitxa. Utilitzeu-la per a muntanyes o boscos que amaguen el que hi ha darrere.", - "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "La Distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons, començant pels més propers. Amb la Línia de visió activada, un hexàgon no es revela mentre hi hagi un hexàgon cobert entre ell i la fitxa. Normalment els hexàgons més propers es revelen primer, de manera que en terreny obert la Línia de visió no canvia res: només importa amb una Distància de visió de 2 o més i hexàgons que continuen coberts, com ara terreny omplert amb una Distància de revelació dels hexàgons.", + "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index 5f2fcdfd51..9a80ed92d4 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Vzdálenost odhalení šestiúhelníků', - desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', + desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', }, revealDistance: { label: 'Vzdálenost dohledu', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Přímá viditelnost', - desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', }, revealPath: { label: 'Odhalovat po cestě', @@ -297,9 +297,9 @@ const TRANSLATION = { points: [ 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', - 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů. Se zapnutou Přímou viditelností je hex odhalen pouze tehdy, když mezi ním a žetonem neleží žádný zakrytý hex.', - 'Vzdálenost odhalení šestiúhelníků se ukládá do hexů při jejich kreslení. Tyto hexy lze odhalit jen ze vzdálenosti nejvýše tolika hexů, ať žeton vidí jakkoli daleko. Použijte ji pro hory nebo lesy, které zakrývají, co je za nimi.', - 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', ], diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index 860684d2c5..40ebc097dc 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Afsløringsafstand for hexfelter', - desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', + desc: 'Gemmes på hexfelterne, når de udfyldes, så indstil den før udfyldning: Ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se; med 0 afsløres de kun ved at gå ind i dem. Brug den til bjerge eller skove. Lad feltet stå tomt for ingen grænse.', }, revealDistance: { label: 'Synsafstand', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Synslinje', - desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', + desc: 'Når den er slået til, skjuler hexfelter, der forbliver dækket, såsom bjerge udfyldt med en Afsløringsafstand for hexfelter, hexfelterne bag dem. Den gør kun en forskel med en Synsafstand på 2 eller mere.', }, revealPath: { label: 'Afslør langs ruten', @@ -295,9 +295,9 @@ const TRANSLATION = { points: [ 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', - 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter. Med Synslinje slået til afsløres et hexfelt kun, hvis der ikke ligger noget dækket hexfelt imellem.', - 'Afsløringsafstand for hexfelter gemmes på hexfelterne, når de tegnes. Disse hexfelter afsløres kun inden for så mange hexfelters afstand, uanset hvor langt et token kan se. Brug det til bjerge eller skove, der skjuler, hvad der ligger bag dem.', - 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter, de nærmeste først. Med Synslinje slået til afsløres et hexfelt ikke, så længe der ligger et dækket hexfelt mellem det og tokenet. Nærmere hexfelter afsløres som regel først, så i åbent terræn ændrer Synslinje intet: Den har kun betydning med en Synsafstand på 2 eller mere og hexfelter, der forbliver dækket, såsom terræn udfyldt med en Afsløringsafstand for hexfelter.', + 'Afsløringsafstand for hexfelter gemmes på hvert hexfelt, når det udfyldes, så indstil den før udfyldning; ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se, og med 0 afsløres de kun ved at gå ind i dem. Til en bjergkæde: Sæt Afsløringsafstand for hexfelter til 0, udfyld bjergene, sæt den tilbage til ingen, og udfyld derefter landet bagved. Med Synsafstand 3 og Synslinje slået til ser gruppen det åbne terræn omkring sig, men ikke bjergene eller det, der ligger bag dem. Hvert bjerghexfelt afsløres, når et token går ind i det.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem. Gennemsigtige Glimt-hexfelter blokerer ikke Synslinje.', 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', ], diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index 90d7ba905d..3889c53586 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Aufdeckungsdistanz für Hexfelder', - desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', + desc: 'Wird beim Füllen in den Hexfeldern gespeichert, also vor dem Füllen festlegen: Spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann; bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für Berge oder Wälder verwenden. Für keine Begrenzung leer lassen.', }, revealDistance: { label: 'Sichtweite', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Sichtlinie', - desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', + desc: 'Wenn diese Option aktiviert ist, verbergen Hexfelder, die verdeckt bleiben, etwa Berge, die mit einer Aufdeckungsdistanz für Hexfelder gefüllt wurden, die Hexfelder dahinter. Das macht nur bei einer Sichtweite von 2 oder mehr einen Unterschied.', }, revealPath: { label: 'Entlang des Wegs aufdecken', @@ -307,9 +307,9 @@ const TRANSLATION = { points: [ 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', - '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nur aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', - '„Aufdeckungsdistanz für Hexfelder“ wird beim Zeichnen in den Hexfeldern gespeichert. Diese Hexfelder werden nur aus höchstens so vielen Hexfeldern Entfernung aufgedeckt, egal wie weit ein Token sehen kann. Nutzen Sie dies für Berge oder Wälder, die verbergen, was dahinter liegt.', - 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf, die nächstgelegenen zuerst. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nicht aufgedeckt, solange ein verdecktes Hexfeld zwischen ihm und dem Token liegt. Nähere Hexfelder werden meist zuerst aufgedeckt, daher ändert „Sichtlinie“ in offenem Gelände nichts: Sie spielt nur bei einer „Sichtweite“ von 2 oder mehr und bei Hexfeldern eine Rolle, die verdeckt bleiben, etwa Gelände, das mit einer „Aufdeckungsdistanz für Hexfelder“ gefüllt wurde.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Füllen in jedem Hexfeld gespeichert, legen Sie sie also vor dem Füllen fest; spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Token muss sich innerhalb so vieler Hexfelder befinden, um sie aufzudecken, egal wie weit es sehen kann, und bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für eine Bergkette: Setzen Sie „Aufdeckungsdistanz für Hexfelder“ auf 0, füllen Sie die Berge, setzen Sie den Wert wieder auf „keine“ zurück und füllen Sie dann das Land dahinter. Mit „Sichtweite“ 3 und aktivierter „Sichtlinie“ sieht die Gruppe das offene Gelände um sich herum, aber weder die Berge noch das, was dahinter liegt. Jedes Berg-Hexfeld wird aufgedeckt, wenn ein Token es betritt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt. Durchsichtige Hexfelder blockieren die „Sichtlinie“ nicht.', 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', ], diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index f6532567af..7f9d602181 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Απόσταση αποκάλυψης εξαγώνων', - desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', + desc: 'Αποθηκεύεται στα εξάγωνα όταν γεμίζονται, οπότε ορίστε το πριν από το γέμισμα: αν το αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει· με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Χρησιμοποιήστε το για βουνά ή δάση. Αφήστε το κενό για να μην υπάρχει όριο.', }, revealDistance: { label: 'Απόσταση όρασης', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Γραμμή όρασης', - desc: 'Όταν είναι ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο μεταξύ αυτού και του διακριτικού.', + desc: 'Όταν είναι ενεργοποιημένο, τα εξάγωνα που παραμένουν καλυμμένα, όπως βουνά που γεμίστηκαν με «Απόσταση αποκάλυψης εξαγώνων», κρύβουν τα εξάγωνα πίσω τους. Κάνει διαφορά μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη.', }, revealPath: { label: 'Αποκάλυψη κατά μήκος της διαδρομής', @@ -300,9 +300,9 @@ const TRANSLATION = { points: [ 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', - 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο αποκαλύπτεται μόνο αν δεν παρεμβάλλεται καλυμμένο εξάγωνο.', - 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται στα εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται μόνο από απόσταση έως τόσα εξάγωνα, όσο μακριά κι αν βλέπει ένα διακριτικό. Χρησιμοποιήστε την για βουνά ή δάση που κρύβουν ό,τι βρίσκεται πίσω τους.', - 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα, ξεκινώντας από τα πλησιέστερα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο δεν αποκαλύπτεται όσο παρεμβάλλεται καλυμμένο εξάγωνο ανάμεσα σε αυτό και στο διακριτικό. Τα πλησιέστερα εξάγωνα συνήθως αποκαλύπτονται πρώτα, οπότε σε ανοιχτό έδαφος η «Γραμμή όρασης» δεν αλλάζει τίποτα: έχει σημασία μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη και εξάγωνα που παραμένουν καλυμμένα, όπως έδαφος που γεμίστηκε με «Απόσταση αποκάλυψης εξαγώνων».', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται σε κάθε εξάγωνο όταν γεμίζεται, οπότε ορίστε την πριν από το γέμισμα· αν την αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει, και με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Για μια οροσειρά: ορίστε την «Απόσταση αποκάλυψης εξαγώνων» σε 0, γεμίστε τα βουνά, επαναφέρετέ την σε καμία τιμή και μετά γεμίστε τη γη πέρα από αυτά. Με «Απόσταση όρασης» 3 και ενεργή τη «Γραμμή όρασης», η ομάδα βλέπει το ανοιχτό έδαφος γύρω της, αλλά όχι τα βουνά ή ό,τι βρίσκεται πίσω τους. Κάθε ορεινό εξάγωνο αποκαλύπτεται όταν ένα διακριτικό μπει σε αυτό.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό. Τα εξάγωνα σε κατάσταση «Ματιά» δεν εμποδίζουν τη «Γραμμή όρασης».', 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', ], diff --git a/Hexploration/src/locales/locale/en-US.js b/Hexploration/src/locales/locale/en-US.js index 68f359922a..1b88070fa6 100644 --- a/Hexploration/src/locales/locale/en-US.js +++ b/Hexploration/src/locales/locale/en-US.js @@ -111,7 +111,7 @@ export default { }, maxDistance: { label: 'Hex Reveal Distance', - desc: 'Applied to hexes as they are drawn: a token must be within this many hexes to reveal them, however far it can see. Leave empty for no limit.', + desc: 'Stored on hexes when they are filled, so set it before filling: changing it later does not affect hexes already on the map. A token must be within this many hexes to reveal them, however far it can see; with 0 they are only revealed by entering them. Use it for mountains or forests. Leave empty for no limit.', }, revealDistance: { label: 'Sight Distance', @@ -119,7 +119,7 @@ export default { }, lineOfSight: { label: 'Line of Sight', - desc: 'When on, a hex is only revealed if no covered hex lies between it and the token.', + desc: 'When on, hexes that stay covered, such as mountains filled with a Hex Reveal Distance, hide the hexes behind them. It only makes a difference with a Sight Distance of 2 or more.', }, revealPath: { label: 'Reveal Along Path', @@ -293,9 +293,9 @@ export default { points: [ 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', - 'Sight Distance reveals the hexes around each of those hexes. With Line of Sight on, a hex is only revealed if no covered hex lies in between.', - 'Hex Reveal Distance is stored on hexes as they are drawn. Those hexes are only revealed from within that many hexes, however far a token can see. Use it for mountains or forests that hide what is behind them.', - 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them.', + 'Sight Distance reveals the hexes around each of those hexes, nearest first. With Line of Sight on, a hex is not revealed while a covered hex lies between it and the token. Nearer hexes are usually revealed first, so in open country Line of Sight changes nothing: it only matters with a Sight Distance of 2 or more and hexes that stay covered, such as terrain filled with a Hex Reveal Distance.', + 'Hex Reveal Distance is stored on each hex when it is filled, so set it before filling; changing it later does not affect hexes already on the map. A token must be within that many hexes to reveal them, however far it can see, and with 0 they are only revealed by entering them. For a mountain range: set Hex Reveal Distance to 0, fill the mountains, set it back to none, then fill the land beyond. With Sight Distance 3 and Line of Sight on, the party sees the open ground around them, but not the mountains or what lies behind them. Each mountain hex is revealed when a token walks into it.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them. Glimpsed hexes do not block Line of Sight.', 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', ], diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index 5865c1f41e..51d0770fcc 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distancia de revelación de hexágonos', - desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', + desc: 'Se guarda en los hexágonos cuando se rellenan, así que configúrelo antes de rellenar: cambiarlo después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esta cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver; con 0, sólo se revelan al entrar en ellos. Úselo para montañas o bosques. Déjelo vacío para no tener límite.', }, revealDistance: { label: 'Distancia de visión', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Línea de visión', - desc: 'Cuando está activado, un hexágono sólo se revela si no hay ningún hexágono cubierto entre él y la ficha.', + desc: 'Cuando está activado, los hexágonos que siguen cubiertos, como las montañas rellenadas con una Distancia de revelación de hexágonos, ocultan los hexágonos que hay detrás de ellos. Sólo tiene efecto con una Distancia de visión de 2 o más.', }, revealPath: { label: 'Revelar a lo largo del camino', @@ -302,9 +302,9 @@ const TRANSLATION = { points: [ 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', - 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', - 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', - 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', + 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', + 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', ], diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index a9dfed35f2..046e8d7613 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Heksojen paljastusetäisyys', - desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', + desc: 'Tallennetaan heksoihin, kun ne täytetään, joten aseta se ennen täyttämistä: myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee; arvolla 0 ne paljastuvat vain, kun niihin astutaan. Käytä sitä vuorille tai metsille. Jätä tyhjäksi, jos rajaa ei haluta.', }, revealDistance: { label: 'Näköetäisyys', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Näköyhteys', - desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', + desc: 'Kun asetus on päällä, peitettyinä pysyvät heksat, kuten Heksojen paljastusetäisyys -asetuksella täytetyt vuoret, kätkevät takanaan olevat heksat. Sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän.', }, revealPath: { label: 'Paljasta reitin varrelta', @@ -299,9 +299,9 @@ const TRANSLATION = { points: [ 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', - 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat. Kun Näköyhteys on päällä, heksa paljastetaan vain, jos välissä ei ole peitettyä heksaa.', - 'Heksojen paljastusetäisyys tallennetaan heksoihin niitä piirrettäessä. Nämä heksat paljastuvat vain enintään näin monen heksan päästä, vaikka merkki näkisi kauemmas. Käytä sitä vuorille tai metsille, jotka kätkevät taakseen jäävän.', - 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat, lähimmät ensin. Kun Näköyhteys on päällä, heksaa ei paljasteta niin kauan kuin sen ja merkin välissä on peitetty heksa. Lähemmät heksat paljastuvat yleensä ensin, joten avoimessa maastossa Näköyhteys ei muuta mitään: sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän ja jotkin heksat pysyvät peitettyinä, kuten Heksojen paljastusetäisyys -asetuksella täytetty maasto.', + 'Heksojen paljastusetäisyys tallennetaan jokaiseen heksaan, kun se täytetään, joten aseta se ennen täyttämistä; myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, vaikka se näkisi kauemmas, ja arvolla 0 ne paljastuvat vain, kun niihin astutaan. Vuorijonoa varten: aseta Heksojen paljastusetäisyys arvoon 0, täytä vuoret, palauta asetus tyhjäksi ja täytä sitten takana oleva maa. Kun Näköetäisyys on 3 ja Näköyhteys on päällä, seurue näkee ympärillään olevan avoimen maaston mutta ei vuoria eikä sitä, mitä niiden takana on. Kukin vuoriheksa paljastuu, kun merkki astuu siihen.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin. Vilkaisun läpikuultavat heksat eivät estä näkyvyyttä Näköyhteys-asetuksessa.', 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', ], diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index 664ee7cf85..259e7801b9 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distance de révélation des hexagones', - desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", + desc: "Enregistrée sur les hexagones au moment où ils sont remplis, donc réglez-la avant de remplir : la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir ; avec 0, ils ne sont révélés qu'en y entrant. Utilisez-la pour des montagnes ou des forêts. Laissez vide pour ne fixer aucune limite.", }, revealDistance: { label: 'Distance de vue', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Ligne de vue', - desc: "Lorsque cette option est activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre lui et le jeton.", + desc: "Lorsque cette option est activée, les hexagones qui restent couverts, comme des montagnes remplies avec une Distance de révélation des hexagones, cachent les hexagones situés derrière eux. Elle n'a d'effet qu'avec une Distance de vue de 2 ou plus.", }, revealPath: { label: 'Révéler le long du chemin', @@ -303,9 +303,9 @@ const TRANSLATION = { points: [ 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", - "La distance de vue révèle les hexagones autour de chacun de ces hexagones. Avec Ligne de vue activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre les deux.", - "La distance de révélation des hexagones est enregistrée sur les hexagones au moment où ils sont dessinés. Ces hexagones ne sont révélés que depuis ce nombre d'hexagones au plus, quelle que soit la distance à laquelle un jeton peut voir. Utilisez-la pour des montagnes ou des forêts qui cachent ce qui se trouve derrière elles.", - "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", + "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", + "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", ], diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index bd79375d77..13cebb41c0 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'מרחק חשיפת משושים', - desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', + desc: 'נשמר על המשושים בעת מילוים, לכן הגדר אותו לפני המילוי: שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות; עם 0 הם נחשפים רק כשנכנסים אליהם. השתמש בו להרים או ליערות. השאר ריק ללא הגבלה.', }, revealDistance: { label: 'מרחק ראייה', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'קו ראייה', - desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', + desc: 'כאשר מופעל, משושים שנשארים מכוסים, כמו הרים שמולאו עם מרחק חשיפת משושים, מסתירים את המשושים שמאחוריהם. יש לכך השפעה רק עם מרחק ראייה של 2 ומעלה.', }, revealPath: { label: 'חשיפה לאורך המסלול', @@ -291,9 +291,9 @@ const TRANSLATION = { points: [ 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', - 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', - 'מרחק חשיפת משושים נשמר על המשושים בזמן שהם מצוירים. משושים אלה נחשפים רק מטווח של מספר המשושים הזה, לא משנה כמה רחוק אסימון יכול לראות. השתמש בו להרים או ליערות שמסתירים את מה שמאחוריהם.', - 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושים, מהקרוב ביותר תחילה. כשקו ראייה מופעל, משושה אינו נחשף כל עוד יש משושה מכוסה בינו לבין האסימון. משושים קרובים יותר נחשפים בדרך כלל ראשונים, ולכן בשטח פתוח קו ראייה אינו משנה דבר: יש לו השפעה רק עם מרחק ראייה של 2 ומעלה ומשושים שנשארים מכוסים, כמו שטח שמולא עם מרחק חשיפת משושים.', + 'מרחק חשיפת משושים נשמר על כל משושה בעת מילויו, לכן הגדר אותו לפני המילוי; שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות, ועם 0 הם נחשפים רק כשנכנסים אליהם. לרכס הרים: הגדר את מרחק חשיפת משושים ל-0, מלא את ההרים, החזר אותו ל"ללא", ואז מלא את השטח שמעבר להם. עם מרחק ראייה 3 וקו ראייה מופעל, החבורה רואה את השטח הפתוח סביבה, אך לא את ההרים או את מה שמאחוריהם. כל משושה הר נחשף כאשר אסימון נכנס אליו.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם. משושים במצב הצצה אינם חוסמים קו ראייה.', 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', ], diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index 93060bf6c5..94d9b53303 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Hatszögek felfedési távolsága', - desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', + desc: 'A hatszögek kitöltésekor kerül tárolásra rajtuk, ezért a kitöltés előtt állítsa be: a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is; 0 esetén csak akkor fedődnek fel, ha belépnek beléjük. Hegyekhez vagy erdőkhöz használja. Hagyja üresen, ha nem kíván korlátozást.', }, revealDistance: { label: 'Látótávolság', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Látóvonal', - desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', + desc: 'Ha be van kapcsolva, a fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött hegyek, eltakarják a mögöttük lévő hatszögeket. Csak akkor számít, ha a Látótávolság legalább 2.', }, revealPath: { label: 'Felfedés az útvonal mentén', @@ -300,9 +300,9 @@ const TRANSLATION = { points: [ 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', - 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel. Ha a Látóvonal be van kapcsolva, egy hatszög csak akkor fedődik fel, ha nincs közte és a token között lefedett hatszög.', - 'A Hatszögek felfedési távolsága a hatszögek megrajzolásakor kerül tárolásra rajtuk. Ezek a hatszögek csak ennyi hatszögnyi távolságon belülről fedhetők fel, bármilyen messzire lát is egy token. Hegyekhez vagy erdőkhöz használja, amelyek eltakarják, ami mögöttük van.', - 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és akkor tűnnek el, amikor egy token belép beléjük.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel, a legközelebbiekkel kezdve. Ha a Látóvonal be van kapcsolva, egy hatszög nem fedődik fel, amíg közte és a token között lefedett hatszög van. A közelebbi hatszögek általában előbb fedődnek fel, így nyílt terepen a Látóvonal semmin sem változtat: csak akkor számít, ha a Látótávolság legalább 2, és vannak fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött terep.', + 'A Hatszögek felfedési távolsága minden hatszögön a kitöltésekor kerül tárolásra, ezért a kitöltés előtt állítsa be; a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is, 0 esetén pedig csak akkor fedődnek fel, ha belépnek beléjük. Hegyvonulathoz: állítsa a Hatszögek felfedési távolsága értékét 0-ra, töltse ki a hegyeket, állítsa vissza üresre (korlátozás nélkül), majd töltse ki a mögöttük lévő vidéket. Ha a Látótávolság 3 és a Látóvonal be van kapcsolva, a csapat látja a körülötte lévő nyílt terepet, de a hegyeket és azt, ami mögöttük van, nem. Minden hegyi hatszög akkor fedődik fel, amikor egy token belép bele.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és eltávolításra kerülnek, amikor egy token belép beléjük. A Bepillantás módban látott hatszögek a Látóvonal szempontjából nem számítanak takarásnak.', 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', ], diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index b082b24bf2..40a9cb7c40 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distanza di rivelazione degli esagoni', - desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', + desc: 'Memorizzata sugli esagoni quando vengono riempiti, quindi impostala prima di riempire: modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere; con 0 vengono rivelati solo entrandoci. Usala per montagne o foreste. Lascia vuoto per nessun limite.', }, revealDistance: { label: 'Distanza di vista', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Linea di vista', - desc: 'Quando è attivo, un esagono viene rivelato solo se non si trova alcun esagono coperto tra esso e il segnalino.', + desc: 'Quando è attivo, gli esagoni che restano coperti, come le montagne riempite con una Distanza di rivelazione degli esagoni, nascondono gli esagoni dietro di essi. Fa differenza solo con una Distanza di vista di 2 o più.', }, revealPath: { label: 'Rivela lungo il percorso', @@ -300,9 +300,9 @@ const TRANSLATION = { points: [ 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', - "La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con Linea di vista attiva, un esagono viene rivelato solo se in mezzo non c'è alcun esagono coperto.", - "La Distanza di rivelazione degli esagoni viene memorizzata sugli esagoni nel momento in cui vengono disegnati. Quegli esagoni vengono rivelati solo da non più di quel numero di esagoni di distanza, per quanto lontano possa vedere un segnalino. Usala per montagne o foreste che nascondono ciò che c'è dietro.", - 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra.', + 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', + "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", ], diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index a48ea906bc..d0034084d9 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'ヘクスの公開距離', - desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', + desc: 'ヘクスを塗りつぶすときにヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス以内にいる必要があります。0の場合、ヘクスに入ったときにのみ公開されます。山や森に使用します。制限を設けない場合は空のままにします。', }, revealDistance: { label: '視界距離', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: '視線', - desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', + desc: 'オンの場合、「ヘクスの公開距離」を設定して塗りつぶした山など、覆われたままのヘクスが、その背後のヘクスを隠します。「視界距離」が2以上の場合にのみ違いが出ます。', }, revealPath: { label: '経路に沿って表示', @@ -296,9 +296,9 @@ const TRANSLATION = { points: [ 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', - '「視界距離」は、それらの各ヘクスの周囲のヘクスを表示します。「視線」がオンの場合、間に覆われたヘクスがないときだけヘクスが表示されます。', - '「ヘクスの公開距離」は、ヘクスを描画するときにそのヘクスに保存されます。それらのヘクスは、トークンがどれだけ遠くまで見えても、その数のヘクス以内からしか表示されません。背後を隠す山や森に使用します。', - '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを近い順に公開します。「視線」がオンの場合、ヘクスとトークンの間に覆われたヘクスがある間は、そのヘクスは公開されません。通常は近いヘクスから先に公開されるため、開けた土地では「視線」は何も変えません。意味を持つのは、「視界距離」が2以上で、「ヘクスの公開距離」を設定して塗りつぶした地形など、覆われたままのヘクスがある場合だけです。', + '「ヘクスの公開距離」は、ヘクスを塗りつぶすときに各ヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはその数のヘクス以内にいる必要があり、0の場合はヘクスに入ったときにのみ公開されます。山脈の場合：「ヘクスの公開距離」を0に設定して山を塗りつぶし、設定をなしに戻してから、その先の土地を塗りつぶします。「視界距離」を3にして「視線」をオンにすると、パーティーは周囲の開けた土地は見えますが、山やその背後にあるものは見えません。各山岳ヘクスは、トークンがその中に入ったときに公開されます。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。透過状態のヘクスは「視線」を遮りません。', 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', ], diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index 10cfcc3047..0ce59a5446 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: '헥스 공개 거리', - desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', + desc: '헥스를 채울 때 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 이 헥스 수 이내에 있어야 합니다. 0이면 헥스에 들어가야만 공개됩니다. 산이나 숲에 사용하세요. 제한이 없으면 비워 두세요.', }, revealDistance: { label: '시야 거리', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: '시선', - desc: '켜져 있으면 헥스와 토큰 사이에 가려진 헥스가 없는 경우에만 헥스가 드러납니다.', + desc: '켜져 있으면, 헥스 공개 거리로 채운 산처럼 계속 덮여 있는 헥스가 그 뒤의 헥스를 가립니다. 시야 거리가 2 이상일 때만 차이가 있습니다.', }, revealPath: { label: '경로를 따라 표시', @@ -294,9 +294,9 @@ const TRANSLATION = { points: [ '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', - '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', - '헥스 공개 거리는 헥스를 그릴 때 그 헥스에 저장됩니다. 그런 헥스는 토큰이 얼마나 멀리 볼 수 있든 그 헥스 수 이내에서만 공개됩니다. 뒤에 있는 것을 가리는 산이나 숲에 사용하세요.', - '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다.', + '시야 거리는 그 각 헥스 주변의 헥스를 가까운 것부터 공개합니다. 시선이 켜져 있으면, 헥스와 토큰 사이에 덮인 헥스가 있는 동안에는 그 헥스가 공개되지 않습니다. 보통 가까운 헥스가 먼저 공개되므로 탁 트인 지형에서는 시선이 아무것도 바꾸지 않습니다. 시야 거리가 2 이상이고, 헥스 공개 거리로 채운 지형처럼 계속 덮여 있는 헥스가 있을 때만 의미가 있습니다.', + '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index ec2302f68c..d50d1020ab 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Onthullingsafstand van zeshoeken', - desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', + desc: 'Wordt bij het vullen in de zeshoeken opgeslagen, dus stel dit in vóór het vullen: later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken; bij 0 worden ze alleen onthuld door ze te betreden. Gebruik dit voor bergen of bossen. Laat leeg voor geen limiet.', }, revealDistance: { label: 'Zichtafstand', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Zichtlijn', - desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', + desc: 'Wanneer deze optie aan staat, verbergen zeshoeken die bedekt blijven, zoals bergen die zijn gevuld met een Onthullingsafstand van zeshoeken, de zeshoeken erachter. Het maakt alleen verschil bij een Zichtafstand van 2 of meer.', }, revealPath: { label: 'Onthullen langs pad', @@ -300,9 +300,9 @@ const TRANSLATION = { points: [ 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', - 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken. Als Zichtlijn aan staat, wordt een zeshoek alleen onthuld als er geen bedekte zeshoek tussen ligt.', - 'Onthullingsafstand van zeshoeken wordt bij het tekenen in de zeshoeken opgeslagen. Die zeshoeken worden alleen onthuld vanaf hooguit zoveel zeshoeken afstand, hoe ver een token ook kan kijken. Gebruik dit voor bergen of bossen die verbergen wat erachter ligt.', - 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken, de dichtstbijzijnde eerst. Als Zichtlijn aan staat, wordt een zeshoek niet onthuld zolang er een bedekte zeshoek tussen die zeshoek en het token ligt. Dichterbij gelegen zeshoeken worden meestal eerst onthuld, dus in open terrein verandert Zichtlijn niets: het telt alleen bij een Zichtafstand van 2 of meer en zeshoeken die bedekt blijven, zoals terrein dat is gevuld met een Onthullingsafstand van zeshoeken.', + 'Onthullingsafstand van zeshoeken wordt bij het vullen in elke zeshoek opgeslagen, dus stel dit in vóór het vullen; later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken, en bij 0 worden ze alleen onthuld door ze te betreden. Voor een bergketen: stel Onthullingsafstand van zeshoeken in op 0, vul de bergen, zet de waarde terug op geen en vul daarna het land erachter. Met Zichtafstand 3 en Zichtlijn aan ziet de groep het open terrein om zich heen, maar niet de bergen of wat erachter ligt. Elke bergzeshoek wordt onthuld wanneer een token erin stapt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt. Doorzichtige Glimp-zeshoeken blokkeren de Zichtlijn niet.', 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', ], diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index 0584777824..fa9e2f569b 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Odległość odkrywania heksagonów', - desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', + desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', }, revealDistance: { label: 'Zasięg wzroku', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Linia wzroku', - desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', }, revealPath: { label: 'Odkrywaj wzdłuż ścieżki', @@ -299,9 +299,9 @@ const TRANSLATION = { points: [ 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', - '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów. Gdy „Linia wzroku” jest włączona, heks zostaje odkryty tylko wtedy, gdy między nim a żetonem nie leży żaden zakryty heks.', - '„Odległość odkrywania heksagonów” jest zapisywana na heksach w chwili ich rysowania. Takie heksy można odkryć tylko z odległości najwyżej tylu heksów, niezależnie od tego, jak daleko widzi żeton. Używaj jej dla gór lub lasów, które zasłaniają to, co jest za nimi.', - 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', + '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', ], diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index 389f62421a..ec7e23f7f7 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', }, revealDistance: { label: 'Distância de visão', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Linha de visão', - desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + desc: 'Quando ativado, os hexágonos que permanecem cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos atrás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', }, revealPath: { label: 'Revelar ao longo do caminho', @@ -300,9 +300,9 @@ const TRANSLATION = { points: [ 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', - 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', - 'A Distância de revelação dos hexágonos é gravada nos hexágonos quando eles são desenhados. Esses hexágonos só são revelados a no máximo essa quantidade de hexágonos de distância, por mais longe que um token consiga ver. Use-a para montanhas ou florestas que escondem o que há atrás delas.', - 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles.', + 'A Distância de visão revela os hexágonos em torno de cada um desses hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto houver um hexágono coberto entre ele e o token. Os hexágonos mais próximos costumam ser revelados primeiro, então em terreno aberto a Linha de visão não muda nada: ela só importa com uma Distância de visão de 2 ou mais e hexágonos que permanecem cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é gravada em cada hexágono quando ele é preenchido, então defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo essa quantidade de hexágonos para revelá-los, por mais longe que consiga ver, e com 0 eles só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e então preencha as terras mais adiante. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto ao seu redor, mas não as montanhas nem o que há atrás delas. Cada hexágono de montanha é revelado quando um token entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', ], diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index d32340bf88..1e70f34808 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', + desc: 'Guardada nos hexágonos quando são preenchidos, por isso defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, este número de hexágonos para os revelar, por mais longe que consiga ver; com 0, só são revelados quando se entra neles. Utilize-a para montanhas ou florestas. Deixe em branco para não haver limite.', }, revealDistance: { label: 'Distância de visão', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Linha de visão', - desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + desc: 'Quando ativado, os hexágonos que continuam cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos que estão por trás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', }, revealPath: { label: 'Revelar ao longo do percurso', @@ -299,9 +299,9 @@ const TRANSLATION = { points: [ 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', - 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', - 'A Distância de revelação dos hexágonos é guardada nos hexágonos quando são desenhados. Esses hexágonos só são revelados a, no máximo, esse número de hexágonos de distância, por mais longe que uma ficha consiga ver. Utilize-a para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'A Distância de visão revela os hexágonos em torno de cada um destes hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto existir um hexágono coberto entre ele e a ficha. Os hexágonos mais próximos são normalmente revelados primeiro, por isso em terreno aberto a Linha de visão não altera nada: só tem importância com uma Distância de visão de 2 ou mais e hexágonos que continuam cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é guardada em cada hexágono quando este é preenchido, por isso defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, esse número de hexágonos para os revelar, por mais longe que consiga ver, e com 0 só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e depois preencha as terras mais além. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto à sua volta, mas não as montanhas nem o que está por trás delas. Cada hexágono de montanha é revelado quando uma ficha entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', ], diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index 9a2fd2b982..e24d5a1155 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Дальность раскрытия шестиугольников', - desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', + desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { label: 'Расстояние обзора', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Линия видимости', - desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', }, revealPath: { label: 'Раскрывать вдоль пути', @@ -298,9 +298,9 @@ const TRANSLATION = { points: [ 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', - '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов. При включённой «Линии видимости» гекс раскрывается, только если между ним и токеном нет закрытого гекса.', - '«Дальность раскрытия шестиугольников» сохраняется в гексах при их рисовании. Такие гексы раскрываются только с расстояния не больше этого числа гексов, как бы далеко ни видел токен. Используйте её для гор или лесов, скрывающих то, что за ними.', - 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', + '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', ], diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index 780ac9c615..480c859b76 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Avslöjandeavstånd för hexar', - desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', + desc: 'Lagras på hexarna när de fylls, så ställ in det innan du fyller: att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se; med 0 avslöjas de bara när man går in i dem. Använd det för berg eller skogar. Lämna tomt för ingen gräns.', }, revealDistance: { label: 'Siktavstånd', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Siktlinje', - desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', + desc: 'När den är på döljer hexar som förblir täckta, till exempel berg som fyllts med ett Avslöjandeavstånd för hexar, hexarna bakom dem. Det gör bara skillnad med ett Siktavstånd på 2 eller mer.', }, revealPath: { label: 'Avslöja längs vägen', @@ -294,9 +294,9 @@ const TRANSLATION = { points: [ 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', - 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar. Med Siktlinje på avslöjas en hex bara om ingen täckt hex ligger emellan.', - 'Avslöjandeavstånd för hexar lagras på hexarna när de ritas. Dessa hexar avslöjas bara inom så många hexars avstånd, hur långt en token än kan se. Använd det för berg eller skogar som döljer vad som finns bakom dem.', - 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar, de närmaste först. Med Siktlinje på avslöjas en hex inte så länge en täckt hex ligger mellan den och token. Närmare hexar avslöjas oftast först, så i öppen terräng ändrar Siktlinje ingenting: den spelar bara roll med ett Siktavstånd på 2 eller mer och hexar som förblir täckta, till exempel terräng som fyllts med ett Avslöjandeavstånd för hexar.', + 'Avslöjandeavstånd för hexar lagras på varje hex när den fylls, så ställ in det innan du fyller; att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se, och med 0 avslöjas de bara när man går in i dem. För en bergskedja: ställ in Avslöjandeavstånd för hexar på 0, fyll bergen, återställ det till inget och fyll sedan landet bortom. Med Siktavstånd 3 och Siktlinje på ser gruppen den öppna marken runt sig, men inte bergen eller det som ligger bakom dem. Varje berghex avslöjas när en token går in i den.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem. Genomskinliga Glimt-hexar blockerar inte Siktlinje.', 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', ], diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index d15f5654db..02c37a0d62 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Altıgen Açığa Çıkarma Mesafesi', - desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', + desc: 'Altıgenler doldurulurken onlara kaydedilir, bu yüzden doldurmadan önce ayarlayın: sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için bu kadar altıgen mesafede olmalıdır; 0 ile yalnızca içlerine girilerek açığa çıkarlar. Dağlar veya ormanlar için kullanın. Sınır olmaması için boş bırakın.', }, revealDistance: { label: 'Görüş Mesafesi', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Görüş Hattı', - desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', + desc: 'Açıkken, Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş dağlar gibi örtülü kalan altıgenler, arkalarındaki altıgenleri gizler. Yalnızca 2 veya daha fazla Görüş Mesafesi ile fark yaratır.', }, revealPath: { label: 'Yol Boyunca Açığa Çıkar', @@ -297,9 +297,9 @@ const TRANSLATION = { points: [ 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', - 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri açığa çıkarır. Görüş Hattı açıkken bir altıgen yalnızca arada örtülü bir altıgen yoksa açığa çıkar.', - 'Altıgen Açığa Çıkarma Mesafesi, altıgenler çizilirken onlara kaydedilir. Bu altıgenler, bir jeton ne kadar uzağı görürse görsün, yalnızca o kadar altıgen mesafeden açığa çıkar. Arkasındakini gizleyen dağlar veya ormanlar için kullanın.', - 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri en yakından başlayarak açığa çıkarır. Görüş Hattı açıkken, bir altıgen ile jeton arasında örtülü bir altıgen bulunduğu sürece o altıgen açığa çıkmaz. Yakın altıgenler genellikle önce açığa çıktığından, açık arazide Görüş Hattı hiçbir şeyi değiştirmez: yalnızca 2 veya daha fazla Görüş Mesafesi ve Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş arazi gibi örtülü kalan altıgenler olduğunda önem taşır.', + 'Altıgen Açığa Çıkarma Mesafesi, her altıgen doldurulurken ona kaydedilir, bu yüzden doldurmadan önce ayarlayın; sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için o kadar altıgen mesafede olmalıdır ve 0 ile yalnızca içlerine girilerek açığa çıkarlar. Bir sıradağ için: Altıgen Açığa Çıkarma Mesafesi ayarını 0 yapın, dağları doldurun, ayarı yeniden boşaltın, ardından ötedeki araziyi doldurun. Görüş Mesafesi 3 ve Görüş Hattı açıkken grup çevresindeki açık araziyi görür, ancak dağları ya da arkalarında olanları göremez. Her dağ altıgeni, bir jeton içine girdiğinde açığa çıkar.', + "Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır. Bakış durumundaki altıgenler Görüş Hattı'nı engellemez.", 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", ], diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index 4ffc419135..a6f7d39e57 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -111,7 +111,7 @@ const TRANSLATION = { }, maxDistance: { label: 'Відстань розкриття шестикутників', - desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', + desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { label: 'Дальність огляду', @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Лінія видимості', - desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', }, revealPath: { label: 'Розкривати вздовж шляху', @@ -298,9 +298,9 @@ const TRANSLATION = { points: [ 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', - '«Дальність огляду» розкриває гекси навколо кожного з цих гексів. З увімкненою «Лінією видимості» гекс розкривається, лише якщо між ним і маркером немає закритого гекса.', - '«Відстань розкриття шестикутників» зберігається в гексах під час їх малювання. Такі гекси розкриваються лише з відстані, не більшої за цю кількість гексів, хоч би як далеко бачив маркер. Використовуйте її для гір або лісів, що приховують те, що за ними.', - 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', + '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', ], diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index e29801b0d2..49e228d3a0 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -110,7 +110,7 @@ const TRANSLATION = { }, maxDistance: { label: '六角格揭示距離', - desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', + desc: '六角格在填充時會儲存此值，因此請在填充前設定：之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於這麼多格以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。可用於山脈或森林。留空則無限制。', }, revealDistance: { label: '視距', @@ -118,7 +118,7 @@ const TRANSLATION = { }, lineOfSight: { label: '視線', - desc: '啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。', + desc: '啟用後，持續被覆蓋的六角格（例如以「六角格揭示距離」填充的山脈）會遮住其後方的六角格。只有在「視距」為 2 或以上時才會有差別。', }, revealPath: { label: '沿路徑顯示', @@ -283,9 +283,9 @@ const TRANSLATION = { points: [ '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', - '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', - '「六角格揭示距離」會在六角格繪製時儲存在六角格上。無論令牌能看多遠，這些六角格都只會在該格數範圍內被揭示。可用於遮擋後方景物的山脈或森林。', - '在「瞥見」模式中，視線內的六角格會變為半透明而非消失，並在令牌進入時被移除。', + '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', + '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', + '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', ], From 5daa2a884b438022c855b0edf98627564203082d Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:30:56 +0000 Subject: [PATCH 17/24] chore(Hexploration): Release 2.0.1 Bumps the version to 2.0.1 for the Jumpgate glimpse and colour fixes, the swatch fix and the clearer sight help. It is released alongside 2.0.0 in the same pull request, so 2.0.0 is added to the previous versions and its snapshot folder is left as it was. The rebuilt script is copied to the new 2.0.1 folder, and the changelog, testing checklist, developer notes and README API example carry the new version. The README introduction now says "Version 2" so it does not need changing for each release. Signed-off-by: Steve Roberts --- Hexploration/2.0.1/Hexploration.js | 14306 +++++++++++++++++++++++++++ Hexploration/CHANGELOG.md | 12 + Hexploration/DEVELOPERS.md | 2 +- Hexploration/Hexploration.js | 378 +- Hexploration/README.md | 4 +- Hexploration/TESTING.md | 4 +- Hexploration/package-lock.json | 4 +- Hexploration/package.json | 2 +- Hexploration/script.json | 5 +- 9 files changed, 14573 insertions(+), 144 deletions(-) create mode 100644 Hexploration/2.0.1/Hexploration.js diff --git a/Hexploration/2.0.1/Hexploration.js b/Hexploration/2.0.1/Hexploration.js new file mode 100644 index 0000000000..d5c6ee8fcb --- /dev/null +++ b/Hexploration/2.0.1/Hexploration.js @@ -0,0 +1,14306 @@ +/** + * NOTE: GENERATED FILE - DO NOT EDIT DIRECTLY. + * NOTE: Source files live under src/ and are bundled with `npm run build`. + * ------------------------------------------------ + * Name: Hexploration + * Script: Hexploration.js + * Version: 2.0.1 + * Built: 2026-10-30T15:35:23.371Z + */ +const HexplorationMod = (() => { + 'use strict'; + + // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. + const SCRIPT_NAME = 'Hexploration'; + const SCRIPT_VERSION = '2.0.1'; + const SCRIPT_LAST_UPDATED = '2026-10-30T15:35:23.371Z'; + + const DEFAULT_LOCALE$1 = 'en-US'; + + const STATE_KEY = 'Hexploration'; + const SCHEMA_VERSION = 2; + const COMMAND = '!hexploration'; + + // v1 commands, kept so existing macros and the Hexploration_menu macro still work. + const LEGACY_COMMANDS = { + '!hexploration_fillPoly': 'fill', + '!hexploration_fillInversePoly': 'fillInverse', + '!hexploration_showMenuMain': 'menu', + '!hexploration_configModifyProperty': 'legacyConfig', + '!hexploration_hexModifyProperty': 'legacyHex', + }; + + // Separator v1 used between the arguments of its config and hex commands. + const LEGACY_ARG_SEPARATOR = '&&'; + + const HANDOUT_HELP_NAME = 'Hexploration - Help'; + // The deck's name is not translated, so it always matches the handout's name. + const DECK_TITLE = 'Command Deck'; + const HANDOUT_DECK_NAME = `Hexploration - ${DECK_TITLE}`; + + const AUTHOR_LINKS = { + original: { + name: 'Ada Lindberg', + profile: 'https://app.roll20.net/users/46544/ada-l', + marketplace: 'https://marketplace.roll20.net/browse/publisher/165/ada-lindberg', + }, + maintainer: { + name: 'MidNiteShadow7', + profile: 'https://app.roll20.net/users/16506286/midniteshadow7', + github: 'https://github.com/steverobertsuk', + }, + }; + + const DEMO_GIF_URL = + 'https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif'; + + // Roll20 layer identifiers. + const LAYER_TOKEN = 'objects'; + const LAYER_GM = 'gmlayer'; + const LAYER_FOREGROUND = 'foreground'; + + // Roll20 object types for drawn shapes. Jumpgate draws pathv2; Legacy draws path. + const PATH_TYPE_LEGACY = 'path'; + const PATH_TYPE_V2 = 'pathv2'; + const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + + // Status marker v1 used to flag location tokens. Still honoured as a fallback. + const LOCATION_MARKER = 'white-tower'; + + // Option lists for settings. + const HEX_LAYER_OPTIONS = ['auto', 'foreground', 'objects']; + const REVEAL_BY_OPTIONS = ['players', 'characters', 'all']; + const REVEAL_MODE_OPTIONS = ['clear', 'glimpse']; + const ANNOUNCE_OPTIONS = ['all', 'gm', 'off']; + + // Default configuration for new installs. Migrated v1 games keep their own values. + const DEFAULT_CONFIG = { + language: DEFAULT_LOCALE$1, + hexLayer: 'auto', + fillColor: '#222222', + strokeColor: '#444444', + labelColor: '#FFFFFF', + glimpseColor: 'rgba(34,34,34,0.5)', + strokeWidth: 1, + revealDistance: 1, + maxDistance: null, + lineOfSight: true, + revealPath: true, + revealBy: 'players', + revealMode: 'clear', + announce: 'all', + pingDiscoveries: false, + hideCoveredTokens: true, + }; + + // Player-visible token properties switched off while a token is under a + // covered hex, because Roll20 draws nameplates, bars and auras above the + // foreground layer. Saved values are restored when the token is uncovered. + const COVERED_TOKEN_PROPS = [ + 'showplayers_name', + 'showplayers_bar1', + 'showplayers_bar2', + 'showplayers_bar3', + 'showplayers_aura1', + 'showplayers_aura2', + ]; + + // Settings that can be overridden for a single page. + const PAGE_SETTING_KEYS = [ + 'revealDistance', + 'lineOfSight', + 'revealPath', + 'revealBy', + 'revealMode', + 'announce', + 'pingDiscoveries', + ]; + + // Limits that keep a single command from creating an unreasonable number of objects. + const MAX_REVEAL_DISTANCE = 20; + const MAX_STROKE_WIDTH = 20; + const MAX_FILL_HEXES = 20000; + const MAX_NAME_LENGTH = 100; + + // Hexes are created and removed in batches so large fills do not trip the + // API's long-running script watchdog. + const BATCH_SIZE = 100; + + // How close (as a fraction of the column step) a path's centre must be to a + // hex centre for Rescan to adopt it as a hex. + const RESCAN_CENTRE_TOLERANCE = 0.2; + + // How close (in pixels) a text label must be to a hex centre to be adopted as its name. + const RESCAN_LABEL_TOLERANCE = 6; + + // Colour palette for chat cards and handouts. + const COLOR_HEADER_BG = '#1b2a1f'; + const COLOR_HEADER_TEXT = '#e8dcb5'; + const COLOR_CARD_BG_TOP = '#22352a'; + const COLOR_CARD_BG_BOTTOM = '#14211a'; + const COLOR_BORDER = '#3c5a45'; + const COLOR_TEXT = '#e4e0d0'; + const COLOR_MUTED = '#9aa89c'; + const COLOR_ACCENT = '#d9a441'; + const COLOR_BUTTON_BG = '#b5832a'; + const COLOR_BUTTON_TEXT = '#ffffff'; + const COLOR_WARNING_BG = '#fef3c7'; + const COLOR_WARNING_BORDER = '#92400e'; + const COLOR_WARNING_TEXT = '#92400e'; + const COLOR_ERROR_BG = '#fee2e2'; + const COLOR_ERROR_BORDER = '#991b1b'; + const COLOR_ERROR_TEXT = '#991b1b'; + + /** + * Returns true when a value is a plain non-null, non-array object. + * + * @param {*} value Value to test. + * @returns {boolean} True when the value is a record. + */ + function isRecord(value) { + return value !== null && typeof value === 'object' && !Array.isArray(value); + } + + /** + * Converts a value to trimmed text, treating null and undefined as empty. + * + * @param {*} value Value to convert. + * @returns {string} Trimmed string. + */ + function toText(value) { + return value === null || value === undefined ? '' : String(value).trim(); + } + + /** + * Escapes HTML special characters. + * + * @param {*} text Text to escape. + * @returns {string} Escaped text. + */ + function escapeHtml(text) { + return String(text) + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); + } + + /** + * Parses a whole number, rejecting anything that is not entirely digits + * (with an optional leading minus sign). + * + * @param {*} raw Raw input. + * @returns {number|null} Parsed integer, or null when invalid. + */ + function parseStrictInt(raw) { + const text = toText(raw); + return /^-?\d+$/.test(text) ? Number(text) : null; + } + + /** + * Parses a yes/no style value. + * + * @param {*} raw Raw input. + * @returns {boolean|null} Parsed boolean, or null when not recognised. + */ + function parseBoolean(raw) { + if (typeof raw === 'boolean') { + return raw; + } + const text = toText(raw).toLowerCase(); + if (['on', 'true', 'yes', '1'].includes(text)) { + return true; + } + if (['off', 'false', 'no', '0'].includes(text)) { + return false; + } + return null; + } + + /** + * Returns true when a value is a colour Roll20 accepts for path fill and stroke: + * #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(), rgba(), transparent, or a CSS colour name. + * + * @param {*} raw Colour text. + * @returns {boolean} True when valid. + */ + function isValidColor(raw) { + const text = toText(raw); + return ( + /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text) || + /^rgba?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+%?\s*)?\)$/i.test(text) || + /^[a-z]{3,20}$/i.test(text) + ); + } + + /** + * Parses a hex, rgb() or rgba() colour into its channels. + * + * @param {*} raw Colour text. + * @returns {{r: number, g: number, b: number, a: number}|null} Channels 0–255 and alpha 0–1, or null for other colours such as names. + */ + function parseColor(raw) { + const text = toText(raw); + + const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(text); + if (hex) { + const digits = hex[1].length <= 4 ? [...hex[1]].map((c) => c + c).join('') : hex[1]; + const [r, g, b, a = 255] = digits.match(/../g).map((pair) => parseInt(pair, 16)); + return { r, g, b, a: a / 255 }; + } + + const fn = + /^rgba?\(\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i.exec( + text + ); + if (!fn) { + return null; + } + const channel = (v) => + clamp(v.endsWith('%') ? (parseFloat(v) * 255) / 100 : parseFloat(v), 0, 255); + const alpha = + fn[4] === undefined ? 1 : fn[4].endsWith('%') ? parseFloat(fn[4]) / 100 : parseFloat(fn[4]); + return { r: channel(fn[1]), g: channel(fn[2]), b: channel(fn[3]), a: clamp(alpha, 0, 1) }; + } + + /** + * Converts a colour to the #rrggbb or #rrggbbaa form Jumpgate's pathv2 objects + * accept. Jumpgate silently ignores rgb(), rgba() and short hex colours, so a + * hex keeps its old colour. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for a pathv2 fill or stroke. + */ + function toPathV2Color(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + const hex = (n) => Math.round(n).toString(16).padStart(2, '0'); + const rgb = `#${hex(color.r)}${hex(color.g)}${hex(color.b)}`; + return color.a >= 1 ? rgb : `${rgb}${hex(color.a * 255)}`; + } + + /** + * Converts a colour to a form Roll20 chat keeps in inline styles. Chat drops + * #rrggbbaa colours and rgb() with an alpha value, leaving the style empty; + * #rrggbb and rgba() survive. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for chat HTML. + */ + function toChatColor(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + if (color.a >= 1) { + return toPathV2Color(raw); + } + const [r, g, b] = [color.r, color.g, color.b].map(Math.round); + return `rgba(${r},${g},${b},${Math.round(color.a * 100) / 100})`; + } + + /** + * Clamps a number into a range. + * + * @param {number} value Value. + * @param {number} min Minimum. + * @param {number} max Maximum. + * @returns {number} Clamped value. + */ + function clamp(value, min, max) { + return Math.min(max, Math.max(min, value)); + } + + let jumpgateCache = null; + + /** + * Returns true when the game runs on Jumpgate. Roll20 has exposed this as + * both `_release` and `release`, so both are checked. + * + * @returns {boolean} True for Jumpgate games. + */ + function isJumpgate() { + if (jumpgateCache === null) { + const campaign = Campaign(); + const release = toText(campaign.get('_release') || campaign.get('release')).toLowerCase(); + jumpgateCache = release === 'jumpgate'; + } + return jumpgateCache; + } + + /** + * Returns the page a player is viewing: their own page when split from the + * party, otherwise the player ribbon page. + * + * @param {string} playerId Roll20 player ID. + * @returns {string} Page ID. + */ + function getPlayerPageId(playerId) { + const campaign = Campaign(); + if (playerIsGM(playerId)) { + const player = getObj('player', playerId); + const lastPage = player?.get('_lastpage'); + if (lastPage) { + return lastPage; + } + } + const specific = campaign.get('playerspecificpages'); + if (isRecord(specific) && specific[playerId]) { + return specific[playerId]; + } + return campaign.get('playerpageid'); + } + + /** + * Returns the player IDs who control a token, directly or through the + * character it represents. + * + * @param {Graphic} token Roll20 token. + * @returns {string[]} Controller IDs (may include 'all'). + */ + function getTokenControllers(token) { + const ids = new Set(); + const add = (list) => { + for (const id of toText(list).split(',')) { + if (id.trim()) { + ids.add(id.trim()); + } + } + }; + add(token.get('controlledby')); + const characterId = token.get('represents'); + if (characterId) { + add(getObj('character', characterId)?.get('controlledby')); + } + return [...ids]; + } + + /** + * Returns true when a token carries a status marker, matching both plain + * markers ("white-tower") and numbered ones ("white-tower@2"). + * + * @param {Graphic} token Roll20 token. + * @param {string} marker Marker tag. + * @returns {boolean} True when the marker is present. + */ + function tokenHasMarker(token, marker) { + return toText(token.get('statusmarkers')) + .split(',') + .some((tag) => tag.split('@')[0] === marker); + } + + /** + * Splits work into batches run on successive event-loop turns, so large jobs + * do not trip the API sandbox's long-running script watchdog. + * + * @param {Array} items Items to process. + * @param {number} size Batch size. + * @param {(item: *, index: number) => void} work Called for each item. + * @param {(errors: number) => void} [done] Called once every item has been + * processed, with the number of items whose work threw. + * @returns {void} + */ + function runInBatches(items, size, work, done) { + let index = 0; + let errors = 0; + // Errors are caught per item: an exception thrown from a timer callback + // would otherwise stop the whole API sandbox. + const step = () => { + const end = Math.min(items.length, index + size); + for (; index < end; index++) { + try { + work(items[index], index); + } catch (err) { + errors++; + log(`Hexploration: batch item failed: ${err?.message || err}`); + } + } + if (index < items.length) { + setTimeout(step, 0); + } else if (done) { + try { + done(errors); + } catch (err) { + log(`Hexploration: batch completion failed: ${err?.message || err}`); + } + } + }; + step(); + } + + const CHAT_CARD_STYLE = [ + 'width:100%', + 'border-radius:4px', + 'box-shadow:1px 1px 3px rgba(0,0,0,0.4)', + 'text-align:left', + 'margin:2px auto', + `border:1px solid ${COLOR_BORDER}`, + `color:${COLOR_TEXT}`, + `background-image:-webkit-linear-gradient(135deg,${COLOR_CARD_BG_TOP} 0%,${COLOR_CARD_BG_BOTTOM} 100%)`, + `background-color:${COLOR_CARD_BG_BOTTOM}`, + 'overflow:hidden', + ].join(';'); + + const CHAT_HEADER_STYLE = [ + `background:${COLOR_HEADER_BG}`, + `color:${COLOR_HEADER_TEXT}`, + 'padding:4px 8px', + `border-bottom:2px solid ${COLOR_ACCENT}`, + 'font-variant:small-caps', + 'font-weight:bold', + 'font-size:1.05em', + 'text-align:center', + 'letter-spacing:0.05em', + ].join(';'); + + const CHAT_CONTENT_STYLE = 'padding:5px 8px;line-height:1.5'; + + const BUTTON_STYLE = [ + `background:${COLOR_BUTTON_BG}`, + `color:${COLOR_BUTTON_TEXT}`, + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const BUTTON_SECONDARY_STYLE = [ + 'background:#2c4034', + `color:${COLOR_TEXT}`, + 'border:1px solid #4d6b56', + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const SECTION_LABEL_STYLE = [ + `color:${COLOR_MUTED}`, + 'font-size:0.8em', + 'text-transform:uppercase', + 'letter-spacing:0.08em', + 'margin-top:4px', + 'margin-bottom:2px', + ].join(';'); + + const DIVIDER_STYLE = `border:none;border-top:1px solid ${COLOR_BORDER};margin:4px 0`; + + /** + * Returns the whisper target for a player, falling back to all GMs. + * + * Double quotes are stripped so the name is safe inside /w "name". + * + * @param {string} [playerId] Roll20 player ID. + * @returns {string} Whisper target text. + */ + function whisperTarget(playerId) { + const player = playerId ? getObj('player', playerId) : null; + if (!player) { + return 'gm'; + } + return `"${String(player.get('displayname') || playerId).replaceAll('"', '')}"`; + } + + /** + * Sends a styled card whispered to a player, or to every GM when no player is given. + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} title Card header text. + * @param {string|string[]} content HTML body content. + * @returns {void} + */ + function whisper(playerId, title, content) { + const body = Array.isArray(content) ? content.join('') : content; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${buildCard(title, body)}`, null, { + noarchive: true, + }); + } + + /** + * Sends a warning whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message Warning text. + * @returns {void} + */ + function whisperWarning(playerId, message) { + const style = [ + `background:${COLOR_WARNING_BG}`, + `color:${COLOR_WARNING_TEXT}`, + `border:1px solid ${COLOR_WARNING_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const html = `
    ${escapeHtml(message)}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Sends an error whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message What went wrong. + * @param {string} [hint] How to fix it. + * @returns {void} + */ + function whisperError(playerId, message, hint) { + const style = [ + `background:${COLOR_ERROR_BG}`, + `color:${COLOR_ERROR_TEXT}`, + `border:1px solid ${COLOR_ERROR_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const hintHtml = hint + ? `
    ${escapeHtml(hint)}
    ` + : ''; + const html = `
    ${escapeHtml(message)}${hintHtml}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Builds a styled chat card. + * + * @param {string} title Header text (escaped). + * @param {string} body Body HTML (trusted). + * @returns {string} HTML string. + */ + function buildCard(title, body) { + return [ + `
    `, + `
    ${escapeHtml(title)}
    `, + `
    ${body}
    `, + '
    ', + ].join(''); + } + + /** + * Builds a primary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a secondary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @param {string} [prefixHtml=''] Trusted HTML shown before the label, such as a flag. + * @returns {string} HTML anchor. + */ + function buildSecondaryButton(label, command, prefixHtml = '') { + return `${prefixHtml}${escapeHtml(label)}`; + } + + /** + * Builds a Twemoji asset URL for a locale flag. + * + * @param {string} flag Unicode regional-indicator flag. + * @returns {string} SVG asset URL or an empty string. + */ + function flagAssetUrl(flag) { + const codepoints = Array.from(String(flag || '').trim()) + .map((character) => character.codePointAt(0).toString(16)) + .join('-'); + return codepoints + ? `https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/${codepoints}.svg` + : ''; + } + + /** + * Builds a locale's flag as a Twemoji image. Roll20 on Windows shows emoji + * flags as letter pairs, so the flag is drawn from an SVG instead. + * + * @param {object} locale Locale metadata. + * @returns {string} Trusted flag HTML, or an empty string when there is no flag. + */ + function buildLocaleFlag(locale) { + const label = escapeHtml(locale?.flagLabel || locale?.name || ''); + const url = flagAssetUrl(locale?.flag); + if (!url) { + return ''; + } + return `${label}`; + } + + /** + * Builds a section label. + * + * @param {string} text Label text. + * @returns {string} HTML string. + */ + function buildSectionLabel(text) { + return `
    ${escapeHtml(text)}
    `; + } + + /** + * Builds a horizontal divider. + * + * @returns {string} HTML string. + */ + function buildDivider() { + return `
    `; + } + + /** + * Builds a label/value row. The value may be trusted HTML (e.g. a button). + * + * @param {string} label Label text (escaped). + * @param {string} valueHtml Value HTML. + * @returns {string} HTML string. + */ + function buildRow(label, valueHtml) { + return [ + '', + ``, + ``, + '
    ${escapeHtml(label)}${valueHtml}
    ', + ].join(''); + } + + /** + * Builds a small colour swatch with its value. + * + * @param {string} color CSS colour. + * @returns {string} HTML string. + */ + function buildSwatch(color) { + const safe = escapeHtml(color); + return ` ${safe}`; + } + + // Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, + // so the whole module can be unit tested in Node. + // + // Hexes are addressed by offset coordinates [row, col], matching the keys v1 + // stored in state. "vertical" is Roll20's Hex (V) grid (pointy-top hexes, odd + // rows shifted right by half a hex). "horizontal" is Hex (H) (flat-top hexes, + // odd columns shifted down by half a hex). Internally the maths converts to + // cube coordinates, which make distance, rounding and line drawing exact. + + const SQRT3 = Math.sqrt(3); + + const ORIENTATION_VERTICAL = 'vertical'; + const ORIENTATION_HORIZONTAL = 'horizontal'; + + // Pixel spacing of a 1-unit hex grid. + // + // Legacy values were measured from the Legacy editor's grid by the v1 author + // and are kept exactly so existing v1 hexes stay aligned. Legacy hexes are + // slightly stretched rather than regular. + // + // Jumpgate draws mathematically regular hexes from the 70 px grid unit: the + // distance across the flats is one unit, so the corner radius is 70/√3. The + // first hex's bounding box sits at the page's top-left corner. (Taken from the + // Jumpgate client's hex grid, which builds cells with radius gridCellSize/√3.) + // Pages that still do not line up can be corrected with `!hexploration calibrate`. + const LEGACY_V = { + colStep: 75.19856198446, + rowStep: 66.965827824268, + originX: 37.5, + originY: 44, + }; + const LEGACY_H = { + colStep: 69.585127490377, + rowStep: 79.688789983504, + originX: 47, + originY: 40.5, + }; + const JUMPGATE_UNIT = 70; + + const GRID_PROFILES = { + legacy: { + [ORIENTATION_VERTICAL]: LEGACY_V, + [ORIENTATION_HORIZONTAL]: LEGACY_H, + }, + jumpgate: { + [ORIENTATION_VERTICAL]: { + colStep: JUMPGATE_UNIT, + rowStep: (JUMPGATE_UNIT * SQRT3) / 2, + originX: JUMPGATE_UNIT / 2, + originY: JUMPGATE_UNIT / SQRT3, + }, + [ORIENTATION_HORIZONTAL]: { + colStep: (JUMPGATE_UNIT * SQRT3) / 2, + rowStep: JUMPGATE_UNIT, + originX: JUMPGATE_UNIT / SQRT3, + originY: JUMPGATE_UNIT / 2, + }, + }, + }; + + /** + * Maps a Roll20 page grid_type to a hex orientation. + * + * @param {string} gridType Page grid_type ('hex' or 'hexr'). + * @returns {string|null} Orientation, or null when the grid is not hexagonal. + */ + function orientationForGridType(gridType) { + if (gridType === 'hex') { + return ORIENTATION_VERTICAL; + } + if (gridType === 'hexr') { + return ORIENTATION_HORIZONTAL; + } + return null; + } + + /** + * Builds a grid description for a page. + * + * @param {object} options Grid options. + * @param {string} options.gridType Page grid_type. + * @param {number} [options.scale=1] Page snapping_increment (cell size in units). + * @param {boolean} [options.jumpgate=false] True for Jumpgate geometry. + * @param {number} [options.offsetX=0] Jumpgate page grid_offset_x, in pixels. + * @param {number} [options.offsetY=0] Jumpgate page grid_offset_y, in pixels. Jumpgate + * measures it upwards, so a positive value moves the grid up the page. + * @param {object|null} [options.calibration] Per-page pixel overrides from calibrate. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function createGrid({ + gridType, + scale = 1, + jumpgate = false, + offsetX = 0, + offsetY = 0, + calibration = null, + }) { + const orientation = orientationForGridType(gridType); + if (!orientation) { + return null; + } + + const unit = Number(scale) > 0 ? Number(scale) : 1; + const profile = GRID_PROFILES[jumpgate ? 'jumpgate' : 'legacy'][orientation]; + const grid = { + orientation, + colStep: profile.colStep * unit, + rowStep: profile.rowStep * unit, + originX: profile.originX * unit + (jumpgate ? Number(offsetX) || 0 : 0), + originY: profile.originY * unit - (jumpgate ? Number(offsetY) || 0 : 0), + }; + + if (calibration) { + for (const key of ['colStep', 'rowStep', 'originX', 'originY']) { + if ( + Number.isFinite(calibration[key]) && + (key.startsWith('origin') || calibration[key] > 0) + ) { + grid[key] = calibration[key]; + } + } + } + + return grid; + } + + /** + * Returns true when an integer is odd, including negative values. + * + * @param {number} n Integer. + * @returns {boolean} True when odd. + */ + function isOdd(n) { + return (n & 1) === 1; + } + + /** + * Builds the state key for a hex. + * + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {string} Key in "row,col" form. + */ + function hexKey(row, col) { + return `${row},${col}`; + } + + /** + * Parses a "row,col" hex key. + * + * @param {string} key Hex key. + * @returns {number[]|null} [row, col], or null when malformed. + */ + function parseHexKey(key) { + const parts = String(key).split(','); + if (parts.length !== 2) { + return null; + } + const row = Number(parts[0]); + const col = Number(parts[1]); + return Number.isInteger(row) && Number.isInteger(col) ? [row, col] : null; + } + + /** + * Converts offset coordinates to cube coordinates. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [q, r, s]. + */ + function offsetToCube(grid, row, col) { + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = col - (row - (row & 1)) / 2; + r = row; + } else { + q = col; + r = row - (col - (col & 1)) / 2; + } + return [q, r, -q - r]; + } + + /** + * Converts cube coordinates to offset coordinates. + * + * @param {object} grid Grid object. + * @param {number[]} cube [q, r, s]. + * @returns {number[]} [row, col]. + */ + function cubeToOffset(grid, cube) { + const [q, r] = cube; + if (grid.orientation === ORIENTATION_VERTICAL) { + return [r, q + (r - (r & 1)) / 2]; + } + return [r + (q - (q & 1)) / 2, q]; + } + + /** + * Rounds fractional cube coordinates to the nearest hex. + * + * @param {number[]} cube Fractional [q, r, s]. + * @returns {number[]} Integer [q, r, s]. + */ + function cubeRound(cube) { + let q = Math.round(cube[0]); + let r = Math.round(cube[1]); + let s = Math.round(cube[2]); + const dq = Math.abs(q - cube[0]); + const dr = Math.abs(r - cube[1]); + const ds = Math.abs(s - cube[2]); + + if (dq > dr && dq > ds) { + q = -r - s; + } else if (dr > ds) { + r = -q - s; + } else { + s = -q - r; + } + // Normalise -0 so keys never contain "-0". + return [q + 0, r + 0, s + 0]; + } + + /** + * Returns the pixel centre of a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [x, y]. + */ + function hexToPixel(grid, row, col) { + if (grid.orientation === ORIENTATION_VERTICAL) { + return [ + grid.originX + (col + (isOdd(row) ? 0.5 : 0)) * grid.colStep, + grid.originY + row * grid.rowStep, + ]; + } + return [ + grid.originX + col * grid.colStep, + grid.originY + (row + (isOdd(col) ? 0.5 : 0)) * grid.rowStep, + ]; + } + + /** + * Returns the hex containing a pixel position. + * + * The grid is treated as a regular hex lattice scaled by colStep and rowStep, + * so this is exact for both regular (Jumpgate) and stretched (Legacy) hexes. + * + * @param {object} grid Grid object. + * @param {number} x Pixel x. + * @param {number} y Pixel y. + * @returns {number[]} [row, col]. + */ + function pixelToHex(grid, x, y) { + const colF = (x - grid.originX) / grid.colStep; + const rowF = (y - grid.originY) / grid.rowStep; + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = colF - rowF / 2; + r = rowF; + } else { + q = colF; + r = rowF - colF / 2; + } + return cubeToOffset(grid, cubeRound([q, r, -q - r])); + } + + /** + * Returns the number of hex steps between two hexes. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number} Distance in hexes. + */ + function hexDistance(grid, a, b) { + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + return Math.max(Math.abs(ca[0] - cb[0]), Math.abs(ca[1] - cb[1]), Math.abs(ca[2] - cb[2])); + } + + /** + * Returns every hex within a distance of a hex (excluding the hex itself), + * nearest first. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {number} radius Distance in hexes. + * @returns {number[][]} Array of [row, col]. + */ + function hexesWithin(grid, row, col, radius) { + const result = []; + const [q, r] = offsetToCube(grid, row, col); + for (let dist = 1; dist <= radius; dist++) { + for (let dq = -dist; dq <= dist; dq++) { + for (let dr = Math.max(-dist, -dq - dist); dr <= Math.min(dist, -dq + dist); dr++) { + const ds = -dq - dr; + if (Math.max(Math.abs(dq), Math.abs(dr), Math.abs(ds)) === dist) { + result.push(cubeToOffset(grid, [q + dq, r + dr, -(q + dq) - (r + dr)])); + } + } + } + } + return result; + } + + /** + * Returns the hexes on a straight line between two hexes, both ends included. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexLine(grid, a, b) { + const n = hexDistance(grid, a, b); + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + if (n === 0) { + return [[a[0], a[1]]]; + } + + // A tiny nudge stops the line landing exactly on hex edges, where rounding + // would otherwise pick a side inconsistently. + const nudge = [1e-6, 2e-6, -3e-6]; + const result = []; + for (let i = 0; i <= n; i++) { + const t = i / n; + const cube = [0, 1, 2].map((k) => ca[k] + nudge[k] + (cb[k] - ca[k]) * t); + result.push(cubeToOffset(grid, cubeRound(cube))); + } + return result; + } + + /** + * Returns the hexes strictly between two hexes on a straight line. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesBetween(grid, a, b) { + return hexLine(grid, a, b).slice(1, -1); + } + + /** + * Returns the hexes crossed by a pixel-space line segment, in travel order. + * + * @param {object} grid Grid object. + * @param {number[]} from [x, y]. + * @param {number[]} to [x, y]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesAlongSegment(grid, from, to) { + return hexLine(grid, pixelToHex(grid, from[0], from[1]), pixelToHex(grid, to[0], to[1])); + } + + /** + * Returns the six corner points of a hex in pixels. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of six [x, y] points, clockwise. + */ + function hexCorners(grid, row, col) { + const [cx, cy] = hexToPixel(grid, row, col); + const corners = []; + for (let i = 0; i < 6; i++) { + if (grid.orientation === ORIENTATION_VERTICAL) { + const angle = ((30 + 60 * i) * Math.PI) / 180; + corners.push([ + cx + (Math.cos(angle) / SQRT3) * grid.colStep, + cy + ((Math.sin(angle) * 2) / 3) * grid.rowStep, + ]); + } else { + const angle = (60 * i * Math.PI) / 180; + corners.push([ + cx + ((Math.cos(angle) * 2) / 3) * grid.colStep, + cy + (Math.sin(angle) / SQRT3) * grid.rowStep, + ]); + } + } + return corners; + } + + /** + * Returns every hex whose centre lies inside a bounding box. + * + * @param {object} grid Grid object. + * @param {object} box Box with left, top, right and bottom in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesInBox(grid, box) { + const [r0, c0] = pixelToHex(grid, box.left, box.top); + const [r1, c1] = pixelToHex(grid, box.right, box.bottom); + const result = []; + for (let row = Math.min(r0, r1) - 1; row <= Math.max(r0, r1) + 1; row++) { + for (let col = Math.min(c0, c1) - 1; col <= Math.max(c0, c1) + 1; col++) { + const [x, y] = hexToPixel(grid, row, col); + if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) { + result.push([row, col]); + } + } + } + return result; + } + + /** + * Returns every hex needed to cover a page completely, including the partial + * hexes along its edges. + * + * @param {object} grid Grid object. + * @param {number} widthPx Page width in pixels. + * @param {number} heightPx Page height in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesCoveringPage(grid, widthPx, heightPx) { + // A hex overlaps the page when its centre is within its own half-size of + // the page edge. Slivers thinner than a quarter pixel are ignored. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const padX = (vertical ? grid.colStep / 2 : (grid.colStep * 2) / 3) - 0.25; + const padY = (vertical ? (grid.rowStep * 2) / 3 : grid.rowStep / 2) - 0.25; + return hexesInBox(grid, { + left: -padX, + top: -padY, + right: widthPx + padX, + bottom: heightPx + padY, + }); + } + + /** + * Returns the hexes a token covers: every hex whose centre lies under the + * token, plus the hex under its centre. + * + * @param {object} grid Grid object. + * @param {number} x Token centre x. + * @param {number} y Token centre y. + * @param {number} width Token width in pixels. + * @param {number} height Token height in pixels. + * @returns {number[][]} Array of [row, col], centre hex first. + */ + function hexesUnderToken(grid, x, y, width, height) { + const centre = pixelToHex(grid, x, y); + // Shrink slightly so a token that only touches a neighbour's centre does not claim it. + const halfW = Math.max(0, width / 2 - 2); + const halfH = Math.max(0, height / 2 - 2); + const covered = hexesInBox(grid, { + left: x - halfW, + top: y - halfH, + right: x + halfW, + bottom: y + halfH, + }); + const centreKey = hexKey(centre[0], centre[1]); + return [centre, ...covered.filter(([r, c]) => hexKey(r, c) !== centreKey)]; + } + + /** + * Derives a calibration from tokens the GM has snapped to hex centres. + * + * One token corrects the grid origin. Two tokens in neighbouring cells of the + * same row (Hex V) or column (Hex H) also correct the hex spacing, keeping the + * current ratio between column and row spacing. + * + * @param {object} grid Current grid object. + * @param {number[][]} points Token centres [[x, y], ...]. + * @returns {object|null} Calibration, or null when the points cannot be used. + */ + function calibrateGrid(grid, points) { + if (!Array.isArray(points) || points.length === 0) { + return null; + } + + let { colStep, rowStep } = grid; + if (points.length >= 2) { + const [a, b] = points; + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const along = vertical ? Math.abs(b[0] - a[0]) : Math.abs(b[1] - a[1]); + const across = vertical ? Math.abs(b[1] - a[1]) : Math.abs(b[0] - a[0]); + const currentStep = vertical ? colStep : rowStep; + const steps = Math.round(along / currentStep); + if (steps < 1 || across > currentStep / 4) { + return null; + } + const ratio = rowStep / colStep; + if (vertical) { + colStep = along / steps; + rowStep = colStep * ratio; + } else { + rowStep = along / steps; + colStep = rowStep / ratio; + } + } + + const scaled = { ...grid, colStep, rowStep }; + const [px, py] = points[0]; + const [row, col] = pixelToHex(scaled, px, py); + const [cx, cy] = hexToPixel(scaled, row, col); + const calibration = { + colStep, + rowStep, + originX: grid.originX + (px - cx), + originY: grid.originY + (py - cy), + }; + + // Keep the origin inside the first cell so offsets stay small and stable. + // Shifting by two rows/columns preserves the odd/even offset pattern. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const wrapX = vertical ? colStep : colStep * 2; + const wrapY = vertical ? rowStep * 2 : rowStep; + calibration.originX = ((calibration.originX % wrapX) + wrapX) % wrapX; + calibration.originY = ((calibration.originY % wrapY) + wrapY) % wrapY; + return calibration; + } + + const TRANSLATION$m = { + titles: { + ready: 'Hexploration is gereed.', + settings: 'Hexploration-instellings', + languages: "Kies 'n taal", + pageSettings: 'Bladsyinstellings: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdragte', + confirm: 'Bevestig asseblief', + }, + discovery: { + title: 'Ligging ontdek', + }, + menu: { + draw: 'Teken', + reveal: 'Openbaar en versteek', + locations: 'Liggings', + tools: 'Gereedskap', + layerInUse: 'Nuwe seshoeke word op die {layer} geteken.', + pageSettingsHelp: + 'Hierdie instellings geld slegs vir hierdie bladsy. Instellings gemerk met ★ oorskryf die globale instellings.', + }, + buttons: { + fill: 'Vul', + fillInverse: 'Omgekeerde vulling', + undo: 'Ontdoen vulling', + reveal: 'Onthul', + conceal: 'Versteek', + explore: 'Verken', + revealPage: 'Onthul bladsy', + resetPage: 'Stel bladsy terug', + mark: 'Merk ligging', + unmark: 'Ontmerk', + name: 'Benoem seshoek', + settings: 'Instellings', + pageSettings: 'Bladsy-instellings', + status: 'Status', + rescan: 'Skandeer weer', + calibrate: 'Kalibreer', + calibrateReset: 'Stel kalibrasie terug', + help: 'Hulp', + change: 'Verander', + menu: 'Kieslys', + clearOverrides: 'Vee oorskrywings uit', + confirmReset: 'Ja, verwyder alle seshoeke', + }, + prompts: { + name: 'Liggingnaam (laat leeg om skoon te maak)', + }, + values: { + on: 'Aan', + off: 'Af', + none: 'Geen', + hexLayer: { + auto: 'Outo (voorgrond indien beskikbaar)', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', + }, + revealBy: { + players: 'Speler-tokens', + characters: 'Karaktertokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Verwyder', + glimpse: 'Glimp', + }, + announce: { + all: 'Almal', + gm: 'Slegs GM', + off: 'Af', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vul', + fillInverse: 'Omgekeerde vulling', + conceal: 'Versteek', + }, + }, + settings: { + language: { + label: 'Taal', + desc: 'Taal vir kieslyste, boodskappe en uitdeelstukke.', + }, + hexLayer: { + label: 'Seshoeklaag', + desc: 'Waar nuwe seshoeke geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die tokenlaag as die speletjie dit nie ondersteun nie.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nuwe seshoeke. Gebruik rgba() vir deursigtige seshoeke, byvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van die buitelyn van nuwe seshoeke.', + }, + labelColor: { + label: 'Etiketkleur', + desc: 'Kleur van die naametikette wat net die GM sien, op benoemde seshoeke.', + }, + glimpseColor: { + label: 'Glimpkleur', + desc: "Kleur waarna seshoeke verander wanneer hulle deurskynend word (Glimp-onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + }, + strokeWidth: { + label: 'Randdikte', + desc: 'Dikte van die buitelyn van nuwe seshoeke, in pieksels (0 tot 20).', + }, + maxDistance: { + label: 'Seshoek-onthullingsafstand', + desc: "Word op seshoeke gestoor wanneer hulle gevul word, so stel dit in voordat jy vul: om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien; met 0 word hulle slegs onthul deur hulle binne te gaan. Gebruik dit vir berge of woude. Laat leeg vir geen beperking nie.", + }, + revealDistance: { + label: 'Sigafstand', + desc: "Hoeveel seshoeke rondom 'n bewegende token onthul word (0 tot 20). 0 onthul slegs die seshoeke waardeur die token beweeg.", + }, + lineOfSight: { + label: 'Siglyn', + desc: "Wanneer dit aan is, versteek seshoeke wat bedek bly, soos berge wat met 'n Seshoek-onthullingsafstand gevul is, die seshoeke agter hulle. Dit maak slegs 'n verskil met 'n Sigafstand van 2 of meer.", + }, + revealPath: { + label: 'Onthul langs pad', + desc: "Wanneer dit aan is, word elke seshoek waardeur 'n token beweeg terwyl dit gesleep word (insluitend tussenpunte), onthul, nie net waar dit stop nie.", + }, + revealBy: { + label: 'Tokens wat onthul', + desc: "Watter tokens op die tokenlaag seshoeke onthul: tokens wat deur 'n speler beheer word, tokens wat enige karakter verteenwoordig, of elke token.", + }, + revealMode: { + label: 'Onthullingsmodus', + desc: "Met Verwyder word seshoeke binne sig verwyder. Met Glimp word hulle eerder deurskynend; hulle word verwyder wanneer 'n token hulle binnegaan.", + }, + announce: { + label: 'Kondig ontdekkings aan', + desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + }, + pingDiscoveries: { + label: 'Ping ontdekkings', + desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + }, + hideCoveredTokens: { + label: 'Versteek bedekte tokens', + desc: "Roll20 teken name, balke en auras bo seshoeke. Wanneer dit aan is, word die naam, balke en auras wat spelers kan sien, afgeskakel vir tokens onder 'n bedekte seshoek, en weer aangeskakel wanneer hulle ontbloot word.", + }, + }, + status: { + engine: 'Spelenjin', + grid: 'Rooster', + layer: 'Seshoeklaag', + hexes: 'Seshoeke', + named: 'Benoemde seshoeke', + icons: 'Liggingtokens', + glimpsed: 'Deurskynende seshoeke', + pending: "Liggings wat op 'n vulling wag", + calibrated: 'Gekalibreer', + overrides: 'Bladsy-oorskrywings', + undo: 'Ontdoen beskikbaar', + }, + messages: { + filled: + 'Vulling voltooi. Seshoeke geteken: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Seshoeke onthul: {count}.', + revealedPage: 'Elke seshoek op die bladsy is onthul ({count}).', + confirmReset: + 'Verwyder elke seshoek van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Seshoeke van die bladsy verwyder: {count}.', + undone: + 'Laaste vulling ontdoen. Seshoeke verwyder: {removed}. Herstileerde seshoeke herstel: {restored}.', + named: 'Seshoeke benoem as "{name}": {count}.', + unnamed: 'Name skoongemaak: {count}.', + marked: + 'Liggings versteek in bestaande seshoeke: {attached}. Wag vir die volgende vulling wat hulle bedek: {pending}.', + unmarked: 'Tokens wat nie meer liggings is nie: {count}.', + settingChanged: '{setting} gestel na {value}.', + rescanned: + 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', + calibrated: + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', + calibrationReset: + 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', + journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', + migrated: + "Jou Hexploration 1.x-seshoekkaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, gebruik Skandeer weer op elke seshoekkaartbladsy.", + pruned: + 'Gestoorde seshoeke wat nie meer bestaan nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, gebruik Skandeer weer op die bladsy om sy seshoeke weer op te tel.', + readyHint: + 'Tik !hexploration vir die kieslys, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + }, + warnings: { + foregroundUnavailable: + 'Hierdie speletjie ondersteun nie teken op die voorgrondlaag nie, dus is die seshoeke op die tokenlaag geteken.', + someFailed: + 'Seshoeke wat nie geteken kon word nie: {count}. Kyk in die API-konsole vir besonderhede.', + }, + errors: { + noPage: 'Kon nie die bladsy vind om aan te werk nie.', + notHex: "Hierdie bladsy gebruik nie 'n seshoekrooster nie.", + noPolygons: 'Kies een of meer getekende vorms om te vul.', + emptyArea: 'Die geselekteerde gebied bevat geen seshoekmiddelpunte nie.', + tooMany: 'Dit sal te veel seshoeke op een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tokens om te versteek.', + nothingToReveal: 'Kies seshoeke, getekende vorms of tokens om te onthul.', + noTokens: 'Kies eers een of meer tokens.', + noHexes: 'Kies eers een of meer seshoeke (of tokens wat op seshoeke staan).', + nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', + unknownCommand: 'Onbekende opdrag: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', + invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateFailed: 'Daardie tokens kan nie gebruik word om te kalibreer nie.', + unexpected: 'Iets het verkeerd geloop: {message}', + }, + hints: { + noPage: 'Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.', + notHex: 'Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.', + noPolygons: + "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", + emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", + tooMany: "Vul 'n kleiner gebied, of verdeel die gebied in verskeie vorms.", + noHexes: + 'Seshoeke is op die voorgrond- of tokenlaag; skakel oor na daardie laag om hulle te kies.', + unknownCommand: 'Tik !hexploration help om die opdragte te lys.', + unknownSetting: 'Tik !hexploration set om elke instelling te sien.', + calibrateNeedsTokens: + "Klik 'n token vas in die middel van 'n seshoek en kies dit. Kies 'n tweede token wat op 'n naburige seshoek in dieselfde ry (Hex V) of kolom (Hex H) vasgeklik is om ook die seshoekgrootte reg te stel.", + calibrateFailed: + 'Die twee tokens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, minstens een seshoek uitmekaar.', + unexpected: 'Besonderhede is in die API-konsole-logboek.', + }, + help: { + menu: 'Wys die kieslys.', + fill: 'Bedek die geselekteerde getekende vorms met seshoeke.', + fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', + undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', + reveal: + 'Onthul die geselekteerde seshoeke, en die seshoeke onder die geselekteerde vorms en tokens.', + revealPage: 'Onthul elke seshoek op die bladsy sonder aankondigings.', + conceal: 'Bedek die gebied onder die geselekteerde vorms en tokens weer met seshoeke.', + explore: 'Onthul rondom die geselekteerde tokens asof hulle pas daarheen beweeg het.', + resetPage: 'Verwyder elke seshoek op die bladsy (vra eers).', + name: 'Benoem die geselekteerde seshoeke, of die seshoeke onder die geselekteerde tokens. Laat die naam leeg om dit uit te vee.', + mark: 'Verander die geselekteerde tokens in versteekte liggings.', + unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', + set: "Verander 'n instelling, of wys alle instellings.", + pageSet: "Oorskryf 'n onthullingsinstelling slegs op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se oorskrywings.', + rescan: + "Herbou die bladsy se seshoeklys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + calibrate: + 'Belyn die seshoekrooster met een of twee geselekteerde tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', + status: 'Wys wat Hexploration van die huidige bladsy weet.', + journal: 'Herbou die Help- en Command Deck-uitdeelstukke.', + help: 'Wys hierdie lys.', + handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', + }, + deck: { + drawDesc: + "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + revealDesc: + 'Kies seshoeke, vorms of tokens om hulle te onthul of weer te bedek. Verken onthul rondom geselekteerde tokens asof hulle beweeg het.', + locationsDesc: + "Kies tokens om hulle as liggings onder seshoeke te versteek. Kies seshoeke of tokens om 'n seshoek te benoem.", + toolsDesc: + 'Instellings, bladsy-oorskrywings, status, herskandering van gekopieerde bladsye en kalibrering van die rooster.', + footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', + }, + handout: { + versionLabel: 'Weergawe', + subtitle: 'Seshoek-vir-seshoek-verkenning vir Roll20', + footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', + overview: { + heading: 'Oorsig', + body: "Hexploration bedek 'n seshoekkaart met ondeursigtige seshoeke. Soos die groep beweeg, word die seshoeke waardeur hulle gaan (en, as jy wil, die seshoeke rondom hulle) verwyder, sodat die kaart een seshoek op 'n slag ontbloot word. Versteekte liggings kan onder seshoeke geplaas word en word aangekondig wanneer hulle gevind word. Dit werk in Jumpgate- en Legacy-speletjies, op Hex (V)- en Hex (H)-roosters van enige grootte.", + demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", + }, + quickStart: { + heading: 'Vinnige Begin', + steps: [ + "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", + 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', + 'Kies die vorms en klik op Vul in die Command Deck (of tik !hexploration fill). Die vorms word deur seshoeke vervang.', + 'Opsioneel: kies voor die vulling tokens vir belangrike plekke en klik Merk ligging. Hulle word onder die seshoeke versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n speler-token. Elke seshoek waardeur dit beweeg, en die seshoeke binne sy Sigafstand, word onthul.", + ], + }, + commands: { + heading: 'Opdragte', + intro: + "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", + colCommand: 'Bevel', + colDesc: 'Wat dit doen', + }, + revealing: { + heading: 'Hoe onthulling werk', + points: [ + 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke, die naaste eerste. Met Siglyn aan word 'n seshoek nie onthul solank 'n bedekte seshoek tussen dit en die token lê nie. Nader seshoeke word gewoonlik eerste onthul, so in oop terrein verander Siglyn niks nie: dit maak slegs saak met 'n Sigafstand van 2 of meer en seshoeke wat bedek bly, soos terrein wat met 'n Seshoek-onthullingsafstand gevul is.", + "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", + "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + ], + }, + locations: { + heading: 'Benoemde seshoeke en liggings', + points: [ + "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", + 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", + 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + ], + }, + settings: { + heading: 'Instellings', + intro: + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Seshoeklaag, Tokens wat onthul en Taal kan ook op die Mod se instellingsbladsy gestel word.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beskrywing', + perPage: '(Kan per bladsy gestel word.)', + }, + jumpgate: { + heading: 'Jumpgate en Legacy', + points: [ + 'Hexploration bepaal watter enjin die speletjie gebruik en teken die ooreenstemmende soort vorm. Vorms wat in enige van die twee redigeerders geteken is, kan gevul word.', + 'Met Seshoeklaag op Outo gestel, word seshoeke op die voorgrondlaag bo tokens geteken, sodat spelers nie kan sien wat daaronder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tokenlaag eerder gebruik.', + "Jumpgate teken wiskundig reëlmatige seshoeke, wat 'n effens ander vorm as Legacy-seshoeke het. As die seshoeke nie met 'n bladsy se rooster belyn nie, klik 'n token vas op 'n seshoekmiddelpunt, kies dit en klik Kalibreer. Kies twee tokens in naburige seshoeke van dieselfde ry (Hex V) of kolom (Hex H) om ook die seshoekgrootte reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy seshoeke nuwe ID's. Gebruik Skandeer weer op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + ], + }, + upgrading: { + heading: 'Opgradering vanaf weergawe 1', + points: [ + "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", + 'Bestaande seshoekkaarte, name, liggingtokens en instellings word met die eerste begin outomaties opgegradeer.', + 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', + "Weergawe 1 het enige token wat 'n karakter verteenwoordig, seshoeke laat onthul. Stel Tokens wat onthul op Karaktertokens om daardie gedrag te behou.", + ], + colV1: 'Weergawe 1 opdrag', + colV2: 'Weergawe 2 opdrag', + }, + troubleshooting: { + heading: 'Probleemoplossing', + points: [ + "Niks gebeur wanneer 'n token beweeg nie: maak seker dat die token op die tokenlaag is en by Tokens wat onthul pas, en dat die bladsy seshoeke het (!hexploration status).", + "Seshoeke is van die rooster af verskuif: gebruik Kalibreer en kyk dan met 'n token op 'n paar seshoeke oor die kaart heen.", + "Seshoeke word nie meer onthul nadat 'n bladsy of speletjie gekopieer is nie: gebruik Skandeer weer op die bladsy.", + 'Vul sê die gebied het geen seshoekmiddelpunte nie: die vorm moet die middelpunt van ten minste een seshoek bevat.', + 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', + ], + }, + languages: { + heading: 'Tale', + body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + colLanguage: 'Taal', + colNative: 'Naam in eie taal', + colCode: 'Kode', + }, + credits: { + heading: 'Krediete', + original: 'Oorspronklike mod deur', + maintainer: 'Weergawe 2 onderhou deur', + marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', + support: + "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", + }, + }, + }; + + const TRANSLATION$l = { + titles: { + ready: 'Hexploration està a punt.', + settings: "Configuració d'Hexploration", + languages: 'Trieu un idioma', + pageSettings: 'Configuració de la pàgina: {page}', + status: "Estat d'Hexploration: {page}", + help: "Comandes d'Hexploration", + confirm: 'Si us plau, confirmeu', + }, + discovery: { + title: 'Ubicació descoberta', + }, + menu: { + draw: 'Dibuixa', + reveal: 'Revela i amaga', + locations: 'Ubicacions', + tools: 'Eines', + layerInUse: "S'estan dibuixant hexàgons nous a la {layer}.", + pageSettingsHelp: + "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", + }, + buttons: { + fill: 'Omple', + fillInverse: 'Emplenament invers', + undo: "Desfés l'emplenament", + reveal: 'Revela', + conceal: 'Amaga', + explore: 'Explora', + revealPage: 'Revela la pàgina', + resetPage: 'Restableix la pàgina', + mark: 'Marca la ubicació', + unmark: 'Desmarca', + name: "Anomena l'hexàgon", + settings: 'Configuració', + pageSettings: 'Configuració de la pàgina', + status: 'Estat', + rescan: 'Torna a escanejar', + calibrate: 'Calibra', + calibrateReset: 'Restableix la calibració', + help: 'Ajuda', + change: 'Canvia', + menu: 'Menú', + clearOverrides: 'Esborra les substitucions', + confirmReset: 'Sí, elimina tots els hexàgons', + }, + prompts: { + name: 'Nom de la ubicació (deixeu en blanc per esborrar)', + }, + values: { + on: 'Activat', + off: 'Desactivat', + none: 'Cap', + hexLayer: { + auto: 'Automàtic (primer pla si està disponible)', + foreground: 'capa de primer pla', + objects: 'capa de fitxes', + }, + revealBy: { + players: 'Fitxes de jugador', + characters: 'Fitxes de personatges', + all: 'Totes les fitxes', + }, + revealMode: { + clear: 'Neteja', + glimpse: "Cop d'ull", + }, + announce: { + all: 'Tothom', + gm: 'Només el GM', + off: 'Desactivat', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Omple', + fillInverse: 'Emplenament invers', + conceal: 'Amaga', + }, + }, + settings: { + language: { + label: 'Llengua', + desc: 'Idioma per a menús, missatges i fullets.', + }, + hexLayer: { + label: 'Capa dels hexàgons', + desc: "On es dibuixen els hexàgons nous. Automàtic prova la capa de primer pla (per sobre de les fitxes) i recorre a la capa de fitxes si el joc no l'admet.", + }, + fillColor: { + label: 'Color de farciment', + desc: 'Color dels hexàgons nous. Utilitzeu rgba() per a hexàgons transparents, per exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color de la vora', + desc: 'Color del contorn dels nous hexagonals.', + }, + labelColor: { + label: "Color de l'etiqueta", + desc: 'Color de les etiquetes de nom, visibles només per al GM, dels hexàgons amb nom.', + }, + glimpseColor: { + label: "Color de cop d'ull", + desc: "Color que prenen els hexàgons quan es veuen de cop d'ull (mode de revelació Cop d'ull). Utilitzeu un color rgba() transparent.", + }, + strokeWidth: { + label: 'Amplada de la vora', + desc: 'Amplada del contorn dels hexàgons nous, en píxels (de 0 a 20).', + }, + maxDistance: { + label: 'Distància de revelació dels hexàgons', + desc: "Es desa als hexàgons quan s'omplen, així que configureu-la abans d'omplir: canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure; amb 0, només es revelen quan s'hi entra. Utilitzeu-la per a muntanyes o boscos. Deixeu-ho buit perquè no hi hagi límit.", + }, + revealDistance: { + label: 'Distància de visió', + desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + }, + lineOfSight: { + label: 'Línia de visió', + desc: 'Quan està activat, els hexàgons que continuen coberts, com ara muntanyes omplertes amb una Distància de revelació dels hexàgons, amaguen els hexàgons que hi ha darrere. Només té efecte amb una Distància de visió de 2 o més.', + }, + revealPath: { + label: 'Revela al llarg del camí', + desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + }, + revealBy: { + label: 'Fitxes que revelen', + desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + }, + revealMode: { + label: 'Mode de revelació', + desc: "Neteja elimina els hexàgons a la vista. Cop d'ull, en canvi, els fa transparents; s'eliminen quan hi entra una fitxa.", + }, + announce: { + label: 'Anunciar descobriments', + desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', + }, + pingDiscoveries: { + label: 'Fer ping als descobriments', + desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', + }, + hideCoveredTokens: { + label: 'Amaga les fitxes cobertes', + desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + }, + }, + status: { + engine: 'Motor de joc', + grid: 'Quadrícula', + layer: 'Capa dels hexàgons', + hexes: 'Hexàgons', + named: 'Hexàgons amb nom', + icons: "Fitxes d'ubicació", + glimpsed: 'Hexàgons albirats', + pending: "Ubicacions pendents d'emplenament", + calibrated: 'Calibrat', + overrides: 'Substitucions de la pàgina', + undo: 'Es pot desfer', + }, + messages: { + filled: + 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', + revealed: 'Hexagones revelats: {count}.', + revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", + confirmReset: + 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', + resetPage: 'Hexàgons eliminats de la pàgina: {count}.', + undone: + 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + named: 'Hexàgons anomenats "{name}": {count}.', + unnamed: 'Noms esborrats: {count}.', + marked: + 'Ubicacions amagades en hexàgons existents: {attached}. Pendents del següent farciment que les cobreixi: {pending}.', + unmarked: 'Fitxes que ja no són ubicacions: {count}.', + settingChanged: "{setting} s'ha establert en {value}.", + rescanned: + "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", + calibrated: + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + calibrationReset: + "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', + migrated: + "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", + pruned: + "Hexàgons desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Torna a escanejar a la pàgina per recuperar-ne els hexàgons.", + readyHint: + 'Escriviu !hexploration per obrir el menú o obriu el fullet "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + someFailed: + "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", + }, + errors: { + noPage: "No s'ha pogut trobar la pàgina per treballar.", + notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', + noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', + emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", + tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', + nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer un o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToUndo: 'No hi ha cap emplenament per desfer.', + unknownCommand: 'Ordre desconeguda: {command}', + unknownSetting: 'Configuració desconeguda: {key}', + unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', + invalidValue: '"{value}" no és un valor vàlid per a {key}.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', + unexpected: "S'ha produït un error: {message}", + }, + hints: { + noPage: 'Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.', + notHex: + 'Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.', + noPolygons: + "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", + emptyArea: + 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', + tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", + noHexes: + 'Els hexàgons són a la capa de primer pla o a la de fitxes; canvieu a aquesta capa per seleccionar-los.', + unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', + unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', + calibrateNeedsTokens: + "Col·loqueu una fitxa al centre d'un hexàgon i seleccioneu-la. Seleccioneu una segona fitxa ajustada a un hexàgon veí de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + calibrateFailed: + "Les dues fitxes han d'estar a la mateixa fila (Hex V) o a la mateixa columna (Hex H), separades almenys per un hexàgon.", + unexpected: "Els detalls es troben al registre de la consola de l'API.", + }, + help: { + menu: 'Mostra el menú.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', + undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + reveal: + 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', + conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', + name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + mark: 'Converteix les fitxes seleccionades en llocs ocults.', + unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + set: 'Canvia un paràmetre o mostra tots els paràmetres.', + pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', + pageClear: 'Elimina les substitucions de la pàgina actual.', + rescan: + "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", + calibrate: + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + calibrateReset: 'Elimineu el calibratge de la pàgina actual.', + status: 'Mostra què sap Hexploration sobre la pàgina actual.', + journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", + help: 'Mostra aquesta llista.', + handout: 'Les instruccions completes es troben al fullet "{name}".', + }, + deck: { + drawDesc: + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfés l'emplenament reverteix l'últim emplenament.", + revealDesc: + "Selecciona hexàgons, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revela el voltant de les fitxes seleccionades com si s'haguessin mogut.", + locationsDesc: + 'Seleccioneu fitxes per amagar-les com a ubicacions sota els hexàgons. Seleccioneu hexàgons o fitxes per posar nom a un hexàgon.', + toolsDesc: + 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', + footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', + }, + handout: { + versionLabel: 'Versió', + subtitle: 'Exploració hexàgon a hexàgon per a Roll20', + footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', + overview: { + heading: 'Visió general', + body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + demo: 'Mira una petita demostració (de la versió 1)', + }, + quickStart: { + heading: 'Inici ràpid', + steps: [ + 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', + "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", + 'Seleccioneu les formes i feu clic a Omple al Command Deck (o escriviu !hexploration fill). Les formes se substitueixen per hexàgons.', + "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", + 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', + ], + }, + commands: { + heading: 'Ordres', + intro: + 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', + colCommand: 'Comandament', + colDesc: 'Què fa', + }, + revealing: { + heading: 'Com funciona la revelació', + points: [ + 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", + "La Distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons, començant pels més propers. Amb la Línia de visió activada, un hexàgon no es revela mentre hi hagi un hexàgon cobert entre ell i la fitxa. Normalment els hexàgons més propers es revelen primer, de manera que en terreny obert la Línia de visió no canvia res: només importa amb una Distància de visió de 2 o més i hexàgons que continuen coberts, com ara terreny omplert amb una Distància de revelació dels hexàgons.", + "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", + "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + ], + }, + locations: { + heading: 'Hexes i ubicacions anomenades', + points: [ + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", + "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", + ], + }, + settings: { + heading: 'Configuració', + intro: + 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', + colKey: 'clau', + colName: 'Configuració', + colDesc: 'Descripció', + perPage: '(Es pot configurar per pàgina.)', + }, + jumpgate: { + heading: 'Jumpgate i Legacy', + points: [ + 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', + "Amb Capa dels hexàgons establerta a Automàtic, els hexàgons es dibuixen a la capa de primer pla, per sobre de les fitxes, perquè els jugadors no puguin veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de fitxes.", + "Jumpgate dibuixa hexàgons matemàticament regulars, que tenen una forma lleugerament diferent dels hexàgons de Legacy. Si els hexàgons no s'alineen amb la graella d'una pàgina, ajusteu una fitxa al centre d'un hexàgon, seleccioneu-la i feu clic a Calibra. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + "Quan es copia una pàgina o un joc, els seus hexàgons reben identificadors nous. Executeu Torna a escanejar a la pàgina per tornar-los a recuperar, juntament amb les etiquetes de nom i les fitxes d'ubicació.", + ], + }, + upgrading: { + heading: 'Actualització de la versió 1', + points: [ + 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', + "Els mapes d'hexàgons, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament la primera vegada que s'inicia.", + 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', + ], + colV1: 'Comandament de la versió 1', + colV2: 'Comandament de la versió 2', + }, + troubleshooting: { + heading: 'Resolució de problemes', + points: [ + 'No passa res quan es mou una fitxa: comproveu que la fitxa és a la capa de fitxes i que coincideix amb Fitxes que revelen, i que la pàgina té hexàgons (!hexploration status).', + 'Els hexàgons estan desplaçats respecte de la quadrícula: utilitzeu Calibra i, a continuació, comproveu-ho amb una fitxa en uns quants hexàgons del mapa.', + 'Els hexàgons han deixat de revelar-se després de copiar una pàgina o un joc: executeu Torna a escanejar a la pàgina.', + "Omple diu que l'àrea no té centres d'hexàgon: la forma ha de contenir el centre d'almenys un hexàgon.", + "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", + ], + }, + languages: { + heading: 'Idiomes', + body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + colLanguage: 'Llengua', + colNative: 'Nom original', + colCode: 'Codi', + }, + credits: { + heading: 'Crèdits', + original: 'Mod original de', + maintainer: 'Versió 2 mantinguda per', + marketplace: "Els paquets d'art de l'Ada al mercat Roll20", + support: + "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", + }, + }, + }; + + const TRANSLATION$k = { + titles: { + ready: 'Hexploration 已就緒。', + settings: 'Hexploration 設定', + languages: '選擇語言', + pageSettings: '頁面設定：{page}', + status: 'Hexploration 狀態：{page}', + help: 'Hexploration 指令', + confirm: '請確認', + }, + discovery: { + title: '發現地點', + }, + menu: { + draw: '繪製', + reveal: '揭示與隱藏', + locations: '地點', + tools: '工具', + layerInUse: '正在 {layer} 上繪製新的六角形。', + pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', + }, + buttons: { + fill: '填充', + fillInverse: '反向填充', + undo: '撤銷填充', + reveal: '揭示', + conceal: '隱藏', + explore: '探索', + revealPage: '揭示整頁', + resetPage: '重置頁面', + mark: '標記地點', + unmark: '取消標記', + name: '命名六角格', + settings: '設定', + pageSettings: '頁面設定', + status: '狀態', + rescan: '重新掃描', + calibrate: '校準', + calibrateReset: '重置校準', + help: '說明', + change: '變更', + menu: '選單', + clearOverrides: '清除覆寫', + confirmReset: '是，移除所有六角格', + }, + prompts: { + name: '地點名稱（留空以清除）', + }, + values: { + on: '開', + off: '關', + none: '無', + hexLayer: { + auto: '自動（可用時使用前景層）', + foreground: '前景層', + objects: '令牌層', + }, + revealBy: { + players: '玩家令牌', + characters: '角色令牌', + all: '所有令牌', + }, + revealMode: { + clear: '清除', + glimpse: '瞥見', + }, + announce: { + all: '所有人', + gm: '僅限 GM', + off: '關', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '填充', + fillInverse: '反向填充', + conceal: '隱藏', + }, + }, + settings: { + language: { + label: '語言', + desc: '選單、訊息和講義的語言。', + }, + hexLayer: { + label: '六角格圖層', + desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + }, + fillColor: { + label: '填充顏色', + desc: '新六角格的顏色。若要讓六角格半透明，請使用 rgba()，例如 rgba(0,0,0,0.8)。', + }, + strokeColor: { + label: '邊框顏色', + desc: '新六邊形輪廓的顏色。', + }, + labelColor: { + label: '標籤顏色', + desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + }, + glimpseColor: { + label: '瞥見顏色', + desc: '六角格被瞥見時變成的顏色（「瞥見」揭示模式）。請使用半透明的 rgba() 顏色。', + }, + strokeWidth: { + label: '邊框寬度', + desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + }, + maxDistance: { + label: '六角格揭示距離', + desc: '六角格在填充時會儲存此值，因此請在填充前設定：之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於這麼多格以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。可用於山脈或森林。留空則無限制。', + }, + revealDistance: { + label: '視距', + desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + }, + lineOfSight: { + label: '視線', + desc: '啟用後，持續被覆蓋的六角格（例如以「六角格揭示距離」填充的山脈）會遮住其後方的六角格。只有在「視距」為 2 或以上時才會有差別。', + }, + revealPath: { + label: '沿路徑顯示', + desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + }, + revealBy: { + label: '可揭示的令牌', + desc: '令牌層上哪些令牌會揭示六角格：由玩家控制的令牌、代表任何角色的令牌，或所有令牌。', + }, + revealMode: { + label: '揭示模式', + desc: '清除會移除視線範圍內的六角格。瞥見則改為讓六角格變得半透明；令牌進入時才將其移除。', + }, + announce: { + label: '公告發現', + desc: '當發現指定位置時誰會看到聊天訊息。', + }, + pingDiscoveries: { + label: '標示發現位置', + desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + }, + hideCoveredTokens: { + label: '隱藏被覆蓋的令牌', + desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + }, + }, + status: { + engine: '遊戲引擎', + grid: '網格', + layer: '六角格圖層', + hexes: '六角格', + named: '已命名的六角格', + icons: '地點令牌', + glimpsed: '被瞥見的六角格', + pending: '等待填充的地點', + calibrated: '已校準', + overrides: '頁面覆寫', + undo: '可撤銷', + }, + messages: { + filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', + revealed: '六角形顯示：{count}。', + revealedPage: '已揭示頁面上的所有六角格（{count}）。', + confirmReset: + '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', + resetPage: '已從頁面移除的六角格：{count}。', + undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', + named: '名為「{name}」的六角形：{count}。', + unnamed: '已清除的名稱：{count}。', + marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', + unmarked: '不再是位置的標記：{count}。', + settingChanged: '{setting} 設定為 {value}。', + rescanned: + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', + calibrated: + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + journalRebuilt: '“{help}”和“{deck}”講義已重建。', + migrated: + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', + pruned: + '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', + readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', + }, + warnings: { + foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', + someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', + }, + errors: { + noPage: '找不到要處理的頁面。', + notHex: '此頁面不使用六角網格。', + noPolygons: '選擇一個或多個要填滿的繪製形狀。', + emptyArea: '所選區域不包含任何六角形中心。', + tooMany: '這會一次建立太多的六角形 ({count})。', + nothingToConceal: '選擇要隱藏的繪製形狀或標記。', + nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + noTokens: '首先選擇一個或多個令牌。', + noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + nothingToUndo: '沒有可撤消的填充。', + unknownCommand: '未知指令：{command}', + unknownSetting: '未知設定：{key}', + unknownPageSetting: '每頁可設定的設定：{keys}', + invalidValue: '“{value}”對於 {key} 不是有效值。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateFailed: '這些令牌不能用於校準。', + unexpected: '出了點問題：{message}', + }, + hints: { + noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', + notHex: '請在頁面設定中將頁面網格設為 Hex (V) 或 Hex (H)。', + noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', + emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', + tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', + noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + unknownCommand: '鍵入 !hexploration help 以列出指令。', + unknownSetting: '輸入 !hexploration set 查看每個設定。', + calibrateNeedsTokens: + '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', + unexpected: '詳細資訊位於 API 控制台日誌中。', + }, + help: { + menu: '顯示選單。', + fill: '用六角形覆蓋選定的繪製形狀。', + fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', + undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', + reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + revealPage: '揭示頁面上的所有六角格，不發布公告。', + conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', + explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + resetPage: '移除頁面上的所有六角格（會先確認）。', + name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', + mark: '將選取的標記變成隱藏位置。', + unmark: '停止將選定的標記隱藏在位置。', + set: '更改設定或顯示所有設定。', + pageSet: '僅覆蓋目前頁面上的顯示設定。', + pageClear: '刪除目前頁面的覆蓋。', + rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', + calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrateReset: '刪除目前頁面的校準。', + status: '顯示 Hexploration 對目前頁面的了解。', + journal: '重建說明與 Command Deck 講義。', + help: '顯示此清單。', + handout: '完整說明位於「{name}」講義。', + }, + deck: { + drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', + revealDesc: + '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', + toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', + footer: '有關完整說明，請參閱“{help}”講義。', + }, + handout: { + versionLabel: '版本', + subtitle: 'Roll20 的逐格六角格探索', + footer: '使用“{deck}”講義進行一鍵式控制項。', + overview: { + heading: '概述', + body: 'Hexploration 以不透明的六角格覆蓋六角格地圖。隊伍移動時，他們經過的六角格（以及你願意的話，周圍的六角格）會被移除，讓地圖一格一格地揭開。隱藏地點可以放在六角格下方，被找到時會公告。它適用於 Jumpgate 和 Legacy 遊戲，以及任何大小的 Hex (V) 和 Hex (H) 網格。', + demo: '觀看簡短的演示（來自版本 1）', + }, + quickStart: { + heading: '快速入門', + steps: [ + '開啟網格設為 Hex (V) 或 Hex (H) 的頁面。', + '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', + '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', + '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', + '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + ], + }, + commands: { + heading: '命令', + intro: + '只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。', + colCommand: '命令', + colDesc: '它的作用', + }, + revealing: { + heading: '揭示如何運作', + points: [ + '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', + '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', + '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', + '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', + 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', + 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', + ], + }, + locations: { + heading: '命名六角形和位置', + points: [ + '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', + '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', + ], + }, + settings: { + heading: '設定', + intro: + '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', + colKey: '鑰匙', + colName: '環境', + colDesc: '描述', + perPage: '（可按頁設定。）', + }, + jumpgate: { + heading: 'Jumpgate 與 Legacy', + points: [ + 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', + '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', + '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + ], + }, + upgrading: { + heading: '從版本 1 升級', + points: [ + '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', + '現有的六角格地圖、名稱、地點令牌與設定會在首次啟動時自動升級。', + '版本 1 的指令（包括 Hexploration_menu 巨集）仍然有效。', + '版本 1 允許任何代表角色的令牌揭示六角格。若要保留此行為，請將「可揭示的令牌」設為「角色令牌」。', + ], + colV1: '版本 1 指令', + colV2: '版本 2 指令', + }, + troubleshooting: { + heading: '故障排除', + points: [ + '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', + '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', + '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', + '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', + ], + }, + languages: { + heading: '語言', + body: '使用 !hexploration set language 選擇語言。可用語言：', + colLanguage: '語言', + colNative: '原文名稱', + colCode: '程式碼', + }, + credits: { + heading: '製作人員', + original: '原始模組由', + maintainer: '版本 2 維護者', + marketplace: 'Roll20 Marketplace 上的 Ada 藝術包', + support: + '如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。', + }, + }, + }; + + const TRANSLATION$j = { + titles: { + ready: 'Hexploration je připraven.', + settings: 'Nastavení Hexploration', + languages: 'Vyberte jazyk', + pageSettings: 'Nastavení stránky: {page}', + status: 'Stav Hexploration: {page}', + help: 'Příkazy Hexploration', + confirm: 'Potvrďte prosím', + }, + discovery: { + title: 'Místo objeveno', + }, + menu: { + draw: 'Kreslení', + reveal: 'Odhalení a skrytí', + locations: 'Místa', + tools: 'Nástroje', + layerInUse: 'Vrstva, do které se kreslí nové hexy: {layer}.', + pageSettingsHelp: + 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', + }, + buttons: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + undo: 'Vrátit výplň', + reveal: 'Odhalit', + conceal: 'Zakrýt', + explore: 'Prozkoumat', + revealPage: 'Odhalit stránku', + resetPage: 'Resetovat stránku', + mark: 'Označit místo', + unmark: 'Zrušit označení', + name: 'Pojmenovat hex', + settings: 'Nastavení', + pageSettings: 'Nastavení stránky', + status: 'Stav', + rescan: 'Znovu skenovat', + calibrate: 'Kalibrovat', + calibrateReset: 'Resetovat kalibraci', + help: 'Pomoc', + change: 'Změnit', + menu: 'Menu', + clearOverrides: 'Zrušit přepsání', + confirmReset: 'Ano, odebrat všechny hexy', + }, + prompts: { + name: 'Název místa (pro vymazání ponechte prázdné)', + }, + values: { + on: 'Zapnuto', + off: 'Vypnuto', + none: 'Žádné', + hexLayer: { + auto: 'Auto (popředí, pokud je k dispozici)', + foreground: 'vrstva popředí', + objects: 'vrstva žetonů', + }, + revealBy: { + players: 'Žetony hráčů', + characters: 'Žetony postav', + all: 'Všechny žetony', + }, + revealMode: { + clear: 'Odstranění', + glimpse: 'Záblesk', + }, + announce: { + all: 'Všichni', + gm: 'Pouze GM', + off: 'Vypnuto', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + conceal: 'Zakrýt', + }, + }, + settings: { + language: { + label: 'Jazyk', + desc: 'Jazyk pro nabídky, zprávy a letáky.', + }, + hexLayer: { + label: 'Vrstva šestiúhelníků', + desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', + }, + fillColor: { + label: 'Barva výplně', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Barva ohraničení', + desc: 'Barva obrysu nových hexů.', + }, + labelColor: { + label: 'Barva popisku', + desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', + }, + glimpseColor: { + label: 'Barva záblesku', + desc: 'Barva, kterou hexy získají při zahlédnutí (režim odhalování Záblesk). Použijte průhlednou barvu rgba().', + }, + strokeWidth: { + label: 'Šířka ohraničení', + desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', + }, + maxDistance: { + label: 'Vzdálenost odhalení šestiúhelníků', + desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', + }, + revealDistance: { + label: 'Vzdálenost dohledu', + desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', + }, + lineOfSight: { + label: 'Přímá viditelnost', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', + }, + revealPath: { + label: 'Odhalovat po cestě', + desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', + }, + revealBy: { + label: 'Žetony, které odhalují', + desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', + }, + revealMode: { + label: 'Režim odhalování', + desc: 'Odstranění odstraní hexy v dohledu. Záblesk je místo toho zprůhlední; odstraní se, když do nich vstoupí žeton.', + }, + announce: { + label: 'Oznamovat objevy', + desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', + }, + pingDiscoveries: { + label: 'Pingnout objevy', + desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', + }, + hideCoveredTokens: { + label: 'Skrýt zakryté žetony', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + }, + }, + status: { + engine: 'Herní engine', + grid: 'Mřížka', + layer: 'Vrstva hexů', + hexes: 'Hexy', + named: 'Pojmenované hexy', + icons: 'Žetony míst', + glimpsed: 'Zahlédnuté hexy', + pending: 'Místa čekající na výplň', + calibrated: 'Zkalibrováno', + overrides: 'Přepsání stránky', + undo: 'Lze vrátit zpět', + }, + messages: { + filled: + 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + revealed: 'Odhalené hexy: {count}.', + revealedPage: 'Každé odhalené hex na stránce ({count}).', + confirmReset: + 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: 'Ze stránky byly odstraněny hexy: {count}.', + undone: + 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', + named: 'Hexusy s názvem „{name}“: {count}.', + unnamed: 'Jména vymazána: {count}.', + marked: + 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', + unmarked: 'Tokeny, které již nejsou umístěními: {count}.', + settingChanged: '{setting} nastaveno na {value}.', + rescanned: + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', + calibrated: + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', + calibrationReset: + 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', + migrated: + 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', + pruned: + 'Uložené hexy, které již neexistují a byly zapomenuty: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte na stránce Znovu skenovat, aby se její hexy znovu načetly.', + readyHint: + 'Zadejte !hexploration pro otevření nabídky nebo otevřete leták "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', + someFailed: + 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', + }, + errors: { + noPage: 'Nelze najít stránku, na které by se dalo pracovat.', + notHex: 'Tato stránka nepoužívá hexovou mřížku.', + noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', + nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', + nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', + noTokens: 'Nejprve vyberte jeden nebo více žetonů.', + noHexes: 'Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).', + nothingToUndo: 'Neexistuje žádná výplň, kterou lze vrátit zpět.', + unknownCommand: 'Neznámý příkaz: {command}', + unknownSetting: 'Neznámé nastavení: {key}', + unknownPageSetting: 'Nastavení, která lze nastavit na stránce: {keys}', + invalidValue: '„{value}“ není platná hodnota pro {key}.', + calibrateNeedsTokens: 'Vyberte jeden nebo dva žetony přichycené na středy hexů.', + calibrateFailed: 'Tyto tokeny nelze použít ke kalibraci.', + unexpected: 'Něco se pokazilo: {message}', + }, + hints: { + noPage: 'Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.', + notHex: 'Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.', + noPolygons: + 'Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.', + emptyArea: 'Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.', + tooMany: 'Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.', + noHexes: 'Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.', + unknownCommand: 'Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.', + unknownSetting: 'Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.', + calibrateNeedsTokens: + 'Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.', + calibrateFailed: + 'Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.', + unexpected: 'Podrobnosti jsou v protokolu konzoly API.', + }, + help: { + menu: 'Ukaž menu.', + fill: 'Zakryjte vybrané nakreslené tvary hexy.', + fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', + undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', + reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', + revealPage: 'Odhalte každé hex na stránce bez oznámení.', + conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', + explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', + resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', + name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', + mark: 'Proměňte vybrané žetony na skrytá místa.', + unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + set: 'Změňte nastavení nebo zobrazte všechna nastavení.', + pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', + pageClear: 'Odstraňte přepsání aktuální stránky.', + rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + calibrate: + 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', + calibrateReset: 'Odstraňte kalibraci aktuální stránky.', + status: 'Zobrazit, co Hexploration ví o aktuální stránce.', + journal: 'Znovu vytvořte letáky „Pomoc“ a „Command Deck“.', + help: 'Zobrazit tento seznam.', + handout: 'Úplné pokyny jsou v letáku „{name}“.', + }, + deck: { + drawDesc: + 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', + revealDesc: + 'Vyberte hexy, tvary nebo žetony, abyste je odhalili nebo znovu zakryli. Prozkoumat odhalí okolí vybraných žetonů, jako by se pohnuly.', + locationsDesc: + 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', + toolsDesc: + 'Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.', + footer: 'Úplné pokyny naleznete v letáku „{help}“.', + }, + handout: { + versionLabel: 'Verze', + subtitle: 'Průzkum hex po hexu pro Roll20', + footer: 'Pro ovládání jedním kliknutím použijte leták „{deck}“.', + overview: { + heading: 'Přehled', + body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', + demo: 'Podívejte se na krátkou ukázku (od verze 1)', + }, + quickStart: { + heading: 'Rychlý start', + steps: [ + 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', + 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', + 'Vyberte tvary a v Command Deck klikněte na Vyplnit (nebo zadejte !hexploration fill). Tvary se nahradí hexy.', + 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Vzdálenosti dohledu jsou odhaleny.', + ], + }, + commands: { + heading: 'Příkazy', + intro: + 'Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.', + colCommand: 'Příkaz', + colDesc: 'Co to dělá', + }, + revealing: { + heading: 'Jak funguje odhalování', + points: [ + 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', + 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', + 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', + ], + }, + locations: { + heading: 'Pojmenované hexy a umístění', + points: [ + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', + 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', + ], + }, + settings: { + heading: 'Nastavení', + intro: + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', + colKey: 'Klíč', + colName: 'Nastavení', + colDesc: 'Popis', + perPage: '(Lze nastavit na stránku.)', + }, + jumpgate: { + heading: 'Jumpgate a Legacy', + points: [ + 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', + 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', + 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', + ], + }, + upgrading: { + heading: 'Upgrade z verze 1', + points: [ + 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', + 'Stávající hexové mapy, názvy, tokeny lokací a nastavení se při prvním spuštění automaticky aktualizují.', + 'Příkazy verze 1, včetně makra Hexploration_menu, stále fungují.', + 'Verze 1 umožňovala odhalovat hexy každému žetonu, který představoval postavu. Chcete-li toto chování zachovat, nastavte Žetony, které odhalují, na Žetony postav.', + ], + colV1: 'Příkaz verze 1', + colV2: 'Příkaz verze 2', + }, + troubleshooting: { + heading: 'Odstraňování problémů', + points: [ + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá nastavení Žetony, které odhalují, a zda stránka obsahuje hexy (!hexploration status).', + 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte na stránce Znovu skenovat.', + 'Vyplnit hlásí, že oblast neobsahuje žádné středy hexů: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', + ], + }, + languages: { + heading: 'Jazyky', + body: 'Jazyk vyberte příkazem !hexploration set language. Dostupné jazyky:', + colLanguage: 'Jazyk', + colNative: 'Vlastní název', + colCode: 'Kód', + }, + credits: { + heading: 'Kredity', + original: 'Původní mod od', + maintainer: 'Verze 2 spravovaná společností', + marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', + support: + 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', + }, + }, + }; + + const TRANSLATION$i = { + titles: { + ready: 'Hexploration er klar.', + settings: 'Indstillinger for Hexploration', + languages: 'Vælg et sprog', + pageSettings: 'Sideindstillinger: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandoer', + confirm: 'Bekræft venligst', + }, + discovery: { + title: 'Sted opdaget', + }, + menu: { + draw: 'Tegn', + reveal: 'Afslør og skjul', + locations: 'Steder', + tools: 'Værktøjer', + layerInUse: 'Nye hexfelter tegnes på {layer}.', + pageSettingsHelp: + 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', + }, + buttons: { + fill: 'Fyld', + fillInverse: 'Omvendt fyld', + undo: 'Fortryd fyld', + reveal: 'Afslør', + conceal: 'Skjul', + explore: 'Udforsk', + revealPage: 'Afslør side', + resetPage: 'Nulstil side', + mark: 'Marker sted', + unmark: 'Fjern markering', + name: 'Navngiv hexfelt', + settings: 'Indstillinger', + pageSettings: 'Sideindstillinger', + status: 'Status', + rescan: 'Scan igen', + calibrate: 'Kalibrer', + calibrateReset: 'Nulstil kalibrering', + help: 'Hjælp', + change: 'Skift', + menu: 'Menu', + clearOverrides: 'Ryd tilsidesættelser', + confirmReset: 'Ja, fjern alle hexfelter', + }, + prompts: { + name: 'Stednavn (lad feltet være tomt for at rydde)', + }, + values: { + on: 'Til', + off: 'Fra', + none: 'Ingen', + hexLayer: { + auto: 'Auto (forgrund, hvis tilgængelig)', + foreground: 'forgrundslaget', + objects: 'tokenlaget', + }, + revealBy: { + players: 'Spillertokens', + characters: 'Karaktertokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Fjern', + glimpse: 'Glimt', + }, + announce: { + all: 'Alle', + gm: 'Kun GM', + off: 'Fra', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fyld', + fillInverse: 'Omvendt fyld', + conceal: 'Skjul', + }, + }, + settings: { + language: { + label: 'Sprog', + desc: 'Sprog til menuer, beskeder og uddelingskopier.', + }, + hexLayer: { + label: 'Lag for hexfelter', + desc: 'Hvor nye hexfelter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + }, + fillColor: { + label: 'Fyldfarve', + desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfarve', + desc: 'Farve på omridset af nye sekskanter.', + }, + labelColor: { + label: 'Etiketfarve', + desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + }, + glimpseColor: { + label: 'Glimtfarve', + desc: 'Den farve, hexfelter skifter til, når de skimtes (afsløringstilstanden Glimt). Brug en gennemsigtig rgba()-farve.', + }, + strokeWidth: { + label: 'Kantbredde', + desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + }, + maxDistance: { + label: 'Afsløringsafstand for hexfelter', + desc: 'Gemmes på hexfelterne, når de udfyldes, så indstil den før udfyldning: Ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se; med 0 afsløres de kun ved at gå ind i dem. Brug den til bjerge eller skove. Lad feltet stå tomt for ingen grænse.', + }, + revealDistance: { + label: 'Synsafstand', + desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + }, + lineOfSight: { + label: 'Synslinje', + desc: 'Når den er slået til, skjuler hexfelter, der forbliver dækket, såsom bjerge udfyldt med en Afsløringsafstand for hexfelter, hexfelterne bag dem. Den gør kun en forskel med en Synsafstand på 2 eller mere.', + }, + revealPath: { + label: 'Afslør langs ruten', + desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + }, + revealBy: { + label: 'Afslørende tokens', + desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + }, + revealMode: { + label: 'Afsløringstilstand', + desc: 'Fjern fjerner hexfelter inden for synsvidde. Glimt gør dem i stedet gennemsigtige; de fjernes, når et token går ind i dem.', + }, + announce: { + label: 'Annoncer opdagelser', + desc: 'Hvem ser chatbeskeden, når en navngivet placering opdages.', + }, + pingDiscoveries: { + label: 'Ping opdagelser', + desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', + }, + hideCoveredTokens: { + label: 'Skjul dækkede tokens', + desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + }, + }, + status: { + engine: 'Spilmotor', + grid: 'Gitter', + layer: 'Lag for hexfelter', + hexes: 'Hexfelter', + named: 'Navngivne hexfelter', + icons: 'Stedtokens', + glimpsed: 'Gennemsigtige hexfelter', + pending: 'Steder, der venter på fyld', + calibrated: 'Kalibreret', + overrides: 'Sidetilsidesættelser', + undo: 'Fortryd tilgængelig', + }, + messages: { + filled: + 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexer afsløret: {count}.', + revealedPage: 'Hver hex på siden afsløret ({count}).', + confirmReset: + 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexer fjernet fra siden: {count}.', + undone: + 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', + named: 'Hexer med navnet "{name}": {count}.', + unnamed: 'Navne ryddet: {count}.', + marked: + 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + unmarked: 'Tokens, der ikke længere er placeringer: {count}.', + settingChanged: '{setting} indstillet til {value}.', + rescanned: + 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', + calibrated: + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', + calibrationReset: + 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + migrated: + 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', + pruned: + 'Gemte hexfelter, der ikke længere findes og er blevet glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Scan igen på siden for at finde dens hexfelter igen.', + readyHint: + 'Skriv !hexploration for at åbne menuen, eller åbn uddelingsarket "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', + someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', + }, + errors: { + noPage: 'Kunne ikke finde siden at arbejde på.', + notHex: 'Denne side bruger ikke et hex-gitter.', + noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', + emptyArea: 'Det valgte område indeholder ingen hex-centre.', + tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', + nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + noTokens: 'Vælg først et eller flere tokens.', + noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + nothingToUndo: 'Der er ingen udfyldning at fortryde.', + unknownCommand: 'Ukendt kommando: {command}', + unknownSetting: 'Ukendt indstilling: {key}', + unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', + invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', + unexpected: 'Noget gik galt: {message}', + }, + hints: { + noPage: 'Åbn den side, du vil arbejde på, eller vælg noget på den.', + notHex: 'Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.', + noPolygons: + 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', + emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', + tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', + noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', + unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', + calibrateNeedsTokens: + 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + calibrateFailed: + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + unexpected: 'Detaljer er i API-konsolloggen.', + }, + help: { + menu: 'Vis menuen.', + fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', + undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', + reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', + revealPage: 'Afslør hver hex på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', + resetPage: 'Fjern hver hex på siden (spørg først).', + name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + mark: 'Gør de valgte tokens til skjulte placeringer.', + unmark: 'Stop de valgte tokens med at være skjulte placeringer.', + set: 'Skift en indstilling, eller vis alle indstillinger.', + pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', + pageClear: 'Fjern den aktuelle sides tilsidesættelser.', + rescan: + 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + calibrate: + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + calibrateReset: 'Fjern den aktuelle sides kalibrering.', + status: 'Vis, hvad Hexploration ved om den aktuelle side.', + journal: 'Genopbyg uddelingsarkene Help og Command Deck.', + help: 'Vis denne liste.', + handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', + }, + deck: { + drawDesc: + 'Tegn figurer rundt om et område, vælg dem, og fyld derefter. Fortryd fyld annullerer den sidste fyldning.', + revealDesc: + 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', + locationsDesc: + 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + toolsDesc: + 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', + footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-udforskning for Roll20', + footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + overview: { + heading: 'Oversigt', + body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + demo: 'Se en kort demo (fra version 1)', + }, + quickStart: { + heading: 'Hurtig start', + steps: [ + 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', + 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', + 'Vælg figurerne, og klik på Fyld i Command Deck (eller skriv !hexploration fill). Figurerne erstattes af hexfelter.', + 'Valgfrit: Før du fylder, kan du vælge tokens for vigtige steder og klikke på Marker sted. De skjules under hexfelterne og annonceres, når de opdages.', + 'Flyt et spillertoken. Hvert hexfelt, det passerer igennem, og hexfelterne inden for dets Synsafstand afsløres.', + ], + }, + commands: { + heading: 'Kommandoer', + intro: + "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", + colCommand: 'Kommando', + colDesc: 'Hvad den gør', + }, + revealing: { + heading: 'Sådan fungerer afsløring', + points: [ + 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter, de nærmeste først. Med Synslinje slået til afsløres et hexfelt ikke, så længe der ligger et dækket hexfelt mellem det og tokenet. Nærmere hexfelter afsløres som regel først, så i åbent terræn ændrer Synslinje intet: Den har kun betydning med en Synsafstand på 2 eller mere og hexfelter, der forbliver dækket, såsom terræn udfyldt med en Afsløringsafstand for hexfelter.', + 'Afsløringsafstand for hexfelter gemmes på hvert hexfelt, når det udfyldes, så indstil den før udfyldning; ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se, og med 0 afsløres de kun ved at gå ind i dem. Til en bjergkæde: Sæt Afsløringsafstand for hexfelter til 0, udfyld bjergene, sæt den tilbage til ingen, og udfyld derefter landet bagved. Med Synsafstand 3 og Synslinje slået til ser gruppen det åbne terræn omkring sig, men ikke bjergene eller det, der ligger bag dem. Hvert bjerghexfelt afsløres, når et token går ind i det.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem. Gennemsigtige Glimt-hexfelter blokerer ikke Synslinje.', + 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', + 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', + ], + }, + locations: { + heading: 'Navngivne Hekser og Steder', + points: [ + 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', + 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', + ], + }, + settings: { + heading: 'Indstillinger', + intro: + 'Skift indstillinger med !hexploration set (eller knappen Indstillinger). Lag for hexfelter, Afslørende tokens og Sprog kan også indstilles på modens indstillingsside.', + colKey: 'Nøgle', + colName: 'Indstilling', + colDesc: 'Beskrivelse', + perPage: '(Kan indstilles pr. side.)', + }, + jumpgate: { + heading: 'Jumpgate og Legacy', + points: [ + 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', + 'Når Lag for hexfelter er sat til Auto, tegnes hexfelter på forgrundslaget over tokens, så spillerne ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexfelter, som har en lidt anden form end Legacy-hexfelter. Hvis hexfelterne ikke flugter med en sides gitter, så fastgør et token til midten af et hexfelt, vælg det, og klik på Kalibrer. Vælg to tokens i nabohexfelter i samme række (Hex V) eller kolonne (Hex H) for også at rette hexfeltstørrelsen.', + 'Når en side eller et spil kopieres, får hexfelterne nye id’er. Kør Scan igen på siden for at finde dem igen sammen med deres navneetiketter og stedtokens.', + ], + }, + upgrading: { + heading: 'Opgradering fra version 1', + points: [ + 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', + 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', + 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', + ], + colV1: 'Version 1 kommando', + colV2: 'Version 2 kommando', + }, + troubleshooting: { + heading: 'Fejlfinding', + points: [ + 'Der sker ikke noget, når et token flytter sig: Kontroller, at tokenet ligger på tokenlaget og matcher Afslørende tokens, og at siden har hexfelter (!hexploration status).', + 'Hexfelterne er forskudt i forhold til gitteret: Brug Kalibrer, og kontroller derefter med et token på nogle få hexfelter rundt om på kortet.', + 'Hexfelterne holdt op med at blive afsløret efter kopiering af en side eller et spil: Kør Scan igen på siden.', + 'Fyld siger, at området ikke har nogen hexfeltcentre: Figuren skal indeholde midten af mindst ét hexfelt.', + 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', + ], + }, + languages: { + heading: 'Sprog', + body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + colLanguage: 'Sprog', + colNative: 'Eget navn', + colCode: 'Kode', + }, + credits: { + heading: 'Kreditter', + original: 'Original mod af', + maintainer: 'Version 2 vedligeholdes af', + marketplace: 'Adas kunstpakker på Roll20 Marketplace', + support: + 'Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.', + }, + }, + }; + + const TRANSLATION$h = { + titles: { + ready: 'Hexploration is klaar.', + settings: 'Hexploration-instellingen', + languages: 'Kies een taal', + pageSettings: 'Pagina-instellingen: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdrachten', + confirm: 'Bevestig alstublieft', + }, + discovery: { + title: 'Locatie ontdekt', + }, + menu: { + draw: 'Tekenen', + reveal: 'Onthullen en verbergen', + locations: 'Locaties', + tools: 'Hulpmiddelen', + layerInUse: 'Nieuwe zeshoeken worden getekend op de {layer}.', + pageSettingsHelp: + 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', + }, + buttons: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + undo: 'Vulling ongedaan maken', + reveal: 'Onthullen', + conceal: 'Verbergen', + explore: 'Verkennen', + revealPage: 'Pagina onthullen', + resetPage: 'Pagina opnieuw instellen', + mark: 'Locatie markeren', + unmark: 'Markering opheffen', + name: 'Zeshoek benoemen', + settings: 'Instellingen', + pageSettings: 'Pagina-instellingen', + status: 'Status', + rescan: 'Opnieuw scannen', + calibrate: 'Kalibreren', + calibrateReset: 'Kalibratie opnieuw instellen', + help: 'Help', + change: 'Wijzigen', + menu: 'Menu', + clearOverrides: 'Overschrijvingen wissen', + confirmReset: 'Ja, verwijder alle zeshoeken', + }, + prompts: { + name: 'Locatienaam (leeg laten om te wissen)', + }, + values: { + on: 'Aan', + off: 'Uit', + none: 'Geen', + hexLayer: { + auto: 'Automatisch (voorgrond indien beschikbaar)', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', + }, + revealBy: { + players: 'Spelertokens', + characters: 'Personagetokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Wissen', + glimpse: 'Glimp', + }, + announce: { + all: 'Iedereen', + gm: 'Alleen GM', + off: 'Uit', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Taal', + desc: "Taal voor menu's, berichten en hand-outs.", + }, + hexLayer: { + label: 'Laag voor zeshoeken', + desc: 'Waar nieuwe zeshoeken worden getekend. Automatisch probeert de voorgrondlaag (boven tokens) en valt terug op de tokenlaag als het spel die niet ondersteunt.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van de omtrek van nieuwe vakjes.', + }, + labelColor: { + label: 'Labelkleur', + desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + }, + glimpseColor: { + label: 'Glimpkleur', + desc: 'Kleur die zeshoeken krijgen wanneer er een glimp van wordt opgevangen (onthullingsmodus Glimp). Gebruik een doorzichtige rgba()-kleur.', + }, + strokeWidth: { + label: 'Randbreedte', + desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Onthullingsafstand van zeshoeken', + desc: 'Wordt bij het vullen in de zeshoeken opgeslagen, dus stel dit in vóór het vullen: later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken; bij 0 worden ze alleen onthuld door ze te betreden. Gebruik dit voor bergen of bossen. Laat leeg voor geen limiet.', + }, + revealDistance: { + label: 'Zichtafstand', + desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + }, + lineOfSight: { + label: 'Zichtlijn', + desc: 'Wanneer deze optie aan staat, verbergen zeshoeken die bedekt blijven, zoals bergen die zijn gevuld met een Onthullingsafstand van zeshoeken, de zeshoeken erachter. Het maakt alleen verschil bij een Zichtafstand van 2 of meer.', + }, + revealPath: { + label: 'Onthullen langs pad', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + }, + revealBy: { + label: 'Tokens die onthullen', + desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + }, + revealMode: { + label: 'Onthullingsmodus', + desc: 'Wissen verwijdert zeshoeken binnen het zicht. Glimp maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer een token ze betreedt.', + }, + announce: { + label: 'Ontdekkingen aankondigen', + desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + }, + pingDiscoveries: { + label: 'Ontdekkingen pingen', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + }, + hideCoveredTokens: { + label: 'Bedekte tokens verbergen', + desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + }, + }, + status: { + engine: 'Game-engine', + grid: 'Rooster', + layer: 'Laag voor zeshoeken', + hexes: 'Zeshoeken', + named: 'Benoemde zeshoeken', + icons: 'Locatietokens', + glimpsed: 'Doorzichtige zeshoeken', + pending: 'Locaties die op een vulling wachten', + calibrated: 'Gekalibreerd', + overrides: 'Pagina-overschrijvingen', + undo: 'Ongedaan maken beschikbaar', + }, + messages: { + filled: + 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Hexen onthuld: {count}.', + revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + confirmReset: + 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Hexes verwijderd van de pagina: {count}.', + undone: + 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', + named: 'Hexen met de naam "{name}": {count}.', + unnamed: 'Namen gewist: {count}.', + marked: + 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + unmarked: 'Tokens die niet langer locaties zijn: {count}.', + settingChanged: '{setting} ingesteld op {value}.', + rescanned: + 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + calibrated: + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + calibrationReset: + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', + migrated: + 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', + pruned: + 'Opgeslagen zeshoeken die niet meer bestaan en zijn vergeten: {dropped}. Als dit spel of deze pagina is gekopieerd, voer dan Opnieuw scannen uit op de pagina om de zeshoeken weer op te pikken.', + readyHint: + 'Typ !hexploration voor het menu, of open de hand-out "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + someFailed: + 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + }, + errors: { + noPage: 'Kon de pagina niet vinden om aan te werken.', + notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', + noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', + emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', + tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', + nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + noTokens: 'Selecteer eerst een of meer tokens.', + noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', + unknownCommand: 'Onbekend commando: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellingen die per pagina kunnen worden ingesteld: {keys}', + invalidValue: '"{value}" is geen geldige waarde voor {key}.', + calibrateNeedsTokens: + 'Selecteer een of twee tokens die op de middelpunten van de zeshoeken zijn vastgemaakt.', + calibrateFailed: 'Deze tokens kunnen niet worden gebruikt om te kalibreren.', + unexpected: 'Er is iets misgegaan: {message}', + }, + hints: { + noPage: 'Open de pagina waaraan u wilt werken of selecteer er iets op.', + notHex: 'Stel het paginaraster in op Hex (V) of Hex (H) in Pagina-instellingen.', + noPolygons: + 'Teken een veelhoek, rechthoek, ellips of vorm uit de vrije hand rond het gebied, selecteer het en probeer het opnieuw.', + emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', + tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', + noHexes: + 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', + unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', + calibrateNeedsTokens: + 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + calibrateFailed: + 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', + unexpected: 'Details staan ​​in het API-consolelogboek.', + }, + help: { + menu: 'Laat de menukaart zien.', + fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', + undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + reveal: + 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', + revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', + explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', + resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', + name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + mark: 'Verander de geselecteerde tokens in verborgen locaties.', + unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', + set: 'Wijzig een instelling of toon alle instellingen.', + pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', + pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', + rescan: + 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + calibrate: + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', + calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', + status: 'Laat zien wat Hexploration weet over de huidige pagina.', + journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', + help: 'Laat deze lijst zien.', + handout: 'Volledige instructies vindt u in de hand-out "{name}".', + }, + deck: { + drawDesc: + 'Teken vormen rond een gebied, selecteer ze en vul ze dan. Vulling ongedaan maken draait de laatste vulling terug.', + revealDesc: + 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', + locationsDesc: + 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + toolsDesc: + "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", + footer: 'Zie de hand-out "{help}" voor volledige instructies.', + }, + handout: { + versionLabel: 'Versie', + subtitle: 'Hex-voor-hex verkenning voor Roll20', + footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', + overview: { + heading: 'Overzicht', + body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + demo: 'Bekijk een korte demo (vanaf versie 1)', + }, + quickStart: { + heading: 'Snel beginnen', + steps: [ + 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', + 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', + 'Selecteer de vormen en klik in het Command Deck op Vullen (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze worden verborgen onder de zeshoeken en aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelertoken. Elke zeshoek waar het doorheen gaat, en de zeshoeken binnen zijn Zichtafstand, worden onthuld.', + ], + }, + commands: { + heading: "Commando's", + intro: + "Alleen GM's kunnen deze commando's gebruiken. De meeste werken op de geselecteerde objecten; de rest handelt op de pagina die u bekijkt.", + colCommand: 'Commando', + colDesc: 'Wat het doet', + }, + revealing: { + heading: 'Hoe onthullen werkt', + points: [ + 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken, de dichtstbijzijnde eerst. Als Zichtlijn aan staat, wordt een zeshoek niet onthuld zolang er een bedekte zeshoek tussen die zeshoek en het token ligt. Dichterbij gelegen zeshoeken worden meestal eerst onthuld, dus in open terrein verandert Zichtlijn niets: het telt alleen bij een Zichtafstand van 2 of meer en zeshoeken die bedekt blijven, zoals terrein dat is gevuld met een Onthullingsafstand van zeshoeken.', + 'Onthullingsafstand van zeshoeken wordt bij het vullen in elke zeshoek opgeslagen, dus stel dit in vóór het vullen; later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken, en bij 0 worden ze alleen onthuld door ze te betreden. Voor een bergketen: stel Onthullingsafstand van zeshoeken in op 0, vul de bergen, zet de waarde terug op geen en vul daarna het land erachter. Met Zichtafstand 3 en Zichtlijn aan ziet de groep het open terrein om zich heen, maar niet de bergen of wat erachter ligt. Elke bergzeshoek wordt onthuld wanneer een token erin stapt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt. Doorzichtige Glimp-zeshoeken blokkeren de Zichtlijn niet.', + 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', + 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + ], + }, + locations: { + heading: 'Genoemde velden en locaties', + points: [ + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', + 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', + ], + }, + settings: { + heading: 'Instellingen', + intro: + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Laag voor zeshoeken, Tokens die onthullen en Taal kunnen ook worden ingesteld op de instellingenpagina van de mod.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beschrijving', + perPage: '(Kan per pagina worden ingesteld.)', + }, + jumpgate: { + heading: 'Jumpgate en erfenis', + points: [ + 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', + 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige zeshoeken, die een iets andere vorm hebben dan Legacy-zeshoeken. Als de zeshoeken niet samenvallen met het raster van een pagina, zet dan een token vast op het midden van een zeshoek, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende zeshoeken van dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', + 'Wanneer een pagina of spel wordt gekopieerd, krijgen de zeshoeken nieuwe ID’s. Voer Opnieuw scannen uit op de pagina om ze weer op te pikken, samen met hun naamlabels en locatietokens.', + ], + }, + upgrading: { + heading: 'Upgraden vanaf versie 1', + points: [ + 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', + 'Bestaande hexkaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch bijgewerkt.', + 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', + 'In versie 1 kon elk token dat een personage voorstelde zeshoeken onthullen. Stel Tokens die onthullen in op Personagetokens om dat gedrag te behouden.', + ], + colV1: 'Versie 1-opdracht', + colV2: 'Versie 2-opdracht', + }, + troubleshooting: { + heading: 'Problemen oplossen', + points: [ + 'Er gebeurt niets wanneer een token beweegt: controleer of het token op de tokenlaag staat en overeenkomt met Tokens die onthullen, en of de pagina zeshoeken heeft (!hexploration status).', + 'Zeshoeken zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer daarna met een token op een paar zeshoeken verspreid over de kaart.', + 'Zeshoeken worden niet meer onthuld na het kopiëren van een pagina of spel: voer Opnieuw scannen uit op de pagina.', + 'Vullen meldt dat het gebied geen middelpunten van zeshoeken bevat: de vorm moet het middelpunt van ten minste één zeshoek bevatten.', + 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', + ], + }, + languages: { + heading: 'Talen', + body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + colLanguage: 'Taal', + colNative: 'Eigen naam', + colCode: 'Code', + }, + credits: { + heading: 'Kredieten', + original: 'Originele mod door', + maintainer: 'Versie 2 onderhouden door', + marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", + support: + 'Als je een bug vindt of een idee hebt, plaats dan een bericht op het Roll20 Mod-forum of open een probleem op GitHub, en voeg eventuele berichten uit het API-consolelogboek toe.', + }, + }, + }; + + var localeEnUS = { + titles: { + ready: 'Hexploration is ready.', + settings: 'Hexploration Settings', + languages: 'Choose a Language', + pageSettings: 'Page Settings: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration Commands', + confirm: 'Please Confirm', + }, + discovery: { + title: 'Location Discovered', + }, + menu: { + draw: 'Draw', + reveal: 'Reveal and Hide', + locations: 'Locations', + tools: 'Tools', + layerInUse: 'New hexes are being drawn on the {layer}.', + pageSettingsHelp: + 'These settings apply to this page only. Settings marked ★ override the global settings.', + }, + buttons: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + undo: 'Undo Fill', + reveal: 'Reveal', + conceal: 'Conceal', + explore: 'Explore', + revealPage: 'Reveal Page', + resetPage: 'Reset Page', + mark: 'Mark Location', + unmark: 'Unmark', + name: 'Name Hex', + settings: 'Settings', + pageSettings: 'Page Settings', + status: 'Status', + rescan: 'Rescan', + calibrate: 'Calibrate', + calibrateReset: 'Reset Calibration', + help: 'Help', + change: 'Change', + menu: 'Menu', + clearOverrides: 'Clear Overrides', + confirmReset: 'Yes, Remove All Hexes', + }, + prompts: { + name: 'Location name (leave empty to clear)', + }, + values: { + on: 'On', + off: 'Off', + none: 'None', + hexLayer: { + auto: 'Auto (foreground if available)', + foreground: 'foreground layer', + objects: 'token layer', + }, + revealBy: { + players: 'Player tokens', + characters: 'Character tokens', + all: 'All tokens', + }, + revealMode: { + clear: 'Clear', + glimpse: 'Glimpse', + }, + announce: { + all: 'Everyone', + gm: 'GM only', + off: 'Off', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + conceal: 'Conceal', + }, + }, + settings: { + language: { + label: 'Language', + desc: 'Language for menus, messages and handouts.', + }, + hexLayer: { + label: 'Hex Layer', + desc: 'Where new hexes are drawn. Auto tries the foreground layer (above tokens) and falls back to the token layer if the game does not support it.', + }, + fillColor: { + label: 'Fill Colour', + desc: 'Colour of new hexes. Use rgba() for see-through hexes, for example rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Border Colour', + desc: 'Colour of the outline of new hexes.', + }, + labelColor: { + label: 'Label Colour', + desc: 'Colour of the GM-only name labels on named hexes.', + }, + glimpseColor: { + label: 'Glimpse Colour', + desc: 'Colour hexes change to when glimpsed (Glimpse reveal mode). Use a see-through rgba() colour.', + }, + strokeWidth: { + label: 'Border Width', + desc: 'Width of the outline of new hexes, in pixels (0 to 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Stored on hexes when they are filled, so set it before filling: changing it later does not affect hexes already on the map. A token must be within this many hexes to reveal them, however far it can see; with 0 they are only revealed by entering them. Use it for mountains or forests. Leave empty for no limit.', + }, + revealDistance: { + label: 'Sight Distance', + desc: 'How many hexes around a moving token are revealed (0 to 20). 0 reveals only the hexes the token passes through.', + }, + lineOfSight: { + label: 'Line of Sight', + desc: 'When on, hexes that stay covered, such as mountains filled with a Hex Reveal Distance, hide the hexes behind them. It only makes a difference with a Sight Distance of 2 or more.', + }, + revealPath: { + label: 'Reveal Along Path', + desc: 'When on, every hex a token passes through while being dragged (including waypoints) is revealed, not just where it stops.', + }, + revealBy: { + label: 'Tokens That Reveal', + desc: 'Which tokens on the token layer reveal hexes: tokens controlled by a player, tokens that represent any character, or every token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear removes hexes within sight. Glimpse makes them see-through instead; they are removed when a token enters them.', + }, + announce: { + label: 'Announce Discoveries', + desc: 'Who sees the chat message when a named location is discovered.', + }, + pingDiscoveries: { + label: 'Ping Discoveries', + desc: 'When on, players are pinged to a named location when it is discovered.', + }, + hideCoveredTokens: { + label: 'Hide Covered Tokens', + desc: 'Roll20 draws names, bars and auras above hexes. When on, tokens under a covered hex have their player-visible name, bars and auras switched off, and switched back on when they are uncovered.', + }, + }, + status: { + engine: 'Game engine', + grid: 'Grid', + layer: 'Hex layer', + hexes: 'Hexes', + named: 'Named hexes', + icons: 'Location tokens', + glimpsed: 'Glimpsed hexes', + pending: 'Locations waiting for a fill', + calibrated: 'Calibrated', + overrides: 'Page overrides', + undo: 'Undo available', + }, + messages: { + filled: + 'Fill complete. Hexes drawn: {created}. Restyled: {restyled}. Locations hidden: {icons}.', + revealed: 'Hexes revealed: {count}.', + revealedPage: 'Every hex on the page revealed ({count}).', + confirmReset: + 'Remove every hex from "{page}" ({count})? Location tokens return to the token layer. Undo cannot reverse this.', + resetPage: 'Hexes removed from the page: {count}.', + undone: 'Last fill undone. Hexes removed: {removed}. Restyled hexes restored: {restored}.', + named: 'Hexes named "{name}": {count}.', + unnamed: 'Names cleared: {count}.', + marked: + 'Locations hidden in existing hexes: {attached}. Waiting for the next fill that covers them: {pending}.', + unmarked: 'Tokens that are no longer locations: {count}.', + settingChanged: '{setting} set to {value}.', + rescanned: + 'Rescan complete. Kept: {kept}. Adopted: {adopted}. Re-filed: {moved}. Missing and forgotten: {dropped}. Labels re-linked: {labels}. Location tokens re-linked: {icons}.', + calibrated: + 'Grid calibrated (column step {colStep}px, row step {rowStep}px). Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + calibrationReset: + 'Calibration removed. Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + 'Your Hexploration 1.x hex maps have been upgraded. If this game was copied from a Legacy game, run Rescan on each hex map page.', + pruned: + 'Saved hexes that no longer exist and were forgotten: {dropped}. If this game or page was copied, run Rescan on the page to pick its hexes up again.', + readyHint: + 'Type !hexploration for the menu, or open the "Hexploration - Command Deck" handout.', + }, + warnings: { + foregroundUnavailable: + 'This game does not support drawing on the foreground layer, so hexes were drawn on the token layer.', + someFailed: 'Hexes that could not be drawn: {count}. Check the API console for details.', + }, + errors: { + noPage: 'Could not find the page to work on.', + notHex: 'This page does not use a hex grid.', + noPolygons: 'Select one or more drawn shapes to fill.', + emptyArea: 'The selected area does not contain any hex centres.', + tooMany: 'That would create too many hexes in one go ({count}).', + nothingToConceal: 'Select drawn shapes or tokens to conceal.', + nothingToReveal: 'Select hexes, drawn shapes or tokens to reveal.', + noTokens: 'Select one or more tokens first.', + noHexes: 'Select one or more hexes (or tokens standing on hexes) first.', + nothingToUndo: 'There is no fill to undo.', + unknownCommand: 'Unknown command: {command}', + unknownSetting: 'Unknown setting: {key}', + unknownPageSetting: 'Settings that can be set per page: {keys}', + invalidValue: '"{value}" is not a valid value for {key}.', + calibrateNeedsTokens: 'Select one or two tokens snapped to hex centres.', + calibrateFailed: 'Those tokens cannot be used to calibrate.', + unexpected: 'Something went wrong: {message}', + }, + hints: { + noPage: 'Open the page you want to work on, or select something on it.', + notHex: 'Set the page grid to Hex (V) or Hex (H) in Page Settings.', + noPolygons: + 'Draw a polygon, rectangle, ellipse or freehand shape around the area, select it, then try again.', + emptyArea: 'Draw a larger shape, or check the page grid settings.', + tooMany: 'Fill a smaller area, or split the area into several shapes.', + noHexes: 'Hexes are on the foreground or token layer; switch to that layer to select them.', + unknownCommand: 'Type !hexploration help to list the commands.', + unknownSetting: 'Type !hexploration set to see every setting.', + calibrateNeedsTokens: + 'Snap a token to the centre of a hex and select it. Select a second token snapped to a neighbouring hex in the same row (Hex V) or column (Hex H) to correct the hex size too.', + calibrateFailed: + 'Two tokens must be in the same row (Hex V) or the same column (Hex H), at least one hex apart.', + unexpected: 'Details are in the API console log.', + }, + help: { + menu: 'Show the menu.', + fill: 'Cover the selected drawn shapes with hexes.', + fillInverse: 'Cover the whole page except inside the selected shapes.', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: 'Reveal the selected hexes, and the hexes under the selected shapes and tokens.', + revealPage: 'Reveal every hex on the page without announcements.', + conceal: 'Cover the area under the selected shapes and tokens with hexes again.', + explore: 'Reveal around the selected tokens as if they had just moved there.', + resetPage: 'Remove every hex on the page (asks first).', + name: 'Name the selected hexes, or the hexes under the selected tokens. Leave the name empty to clear it.', + mark: 'Turn the selected tokens into hidden locations.', + unmark: 'Stop the selected tokens being hidden locations.', + set: 'Change a setting, or show all settings.', + pageSet: 'Override a reveal setting on the current page only.', + pageClear: 'Remove the current page’s overrides.', + rescan: 'Rebuild the page’s hex list, for example after copying a page or game.', + calibrate: 'Line the hex grid up with one or two selected tokens snapped to hex centres.', + calibrateReset: 'Remove the current page’s calibration.', + status: 'Show what Hexploration knows about the current page.', + journal: 'Rebuild the Help and Command Deck handouts.', + help: 'Show this list.', + handout: 'Full instructions are in the "{name}" handout.', + }, + deck: { + drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', + revealDesc: + 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', + locationsDesc: + 'Select tokens to hide them as locations under hexes. Select hexes or tokens to name a hex.', + toolsDesc: + 'Settings, page overrides, status, rescanning copied pages and calibrating the grid.', + footer: 'See the "{help}" handout for full instructions.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex exploration for Roll20', + footer: 'Use the "{deck}" handout for one-click controls.', + overview: { + heading: 'Overview', + body: 'Hexploration covers a hex map with opaque hexes. As the party moves, the hexes they pass through (and, if you like, the hexes around them) are removed, so the map is uncovered one hex at a time. Hidden locations can be placed under hexes and are announced when found. It works in Jumpgate and Legacy games, on Hex (V) and Hex (H) grids of any size.', + demo: 'Watch a short demo (from version 1)', + }, + quickStart: { + heading: 'Quick Start', + steps: [ + 'Open a page whose grid is set to Hex (V) or Hex (H).', + 'Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide.', + 'Select the shapes and click Fill in the Command Deck (or type !hexploration fill). The shapes are replaced by hexes.', + 'Optional: before filling, select tokens for important places and click Mark Location. They are hidden under the hexes and announced when discovered.', + 'Move a player token. Every hex it passes through, and the hexes within its Sight Distance, are revealed.', + ], + }, + commands: { + heading: 'Commands', + intro: + 'Only GMs can use these commands. Most act on the selected objects; the rest act on the page you are viewing.', + colCommand: 'Command', + colDesc: 'What it does', + }, + revealing: { + heading: 'How Revealing Works', + points: [ + 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', + 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', + 'Sight Distance reveals the hexes around each of those hexes, nearest first. With Line of Sight on, a hex is not revealed while a covered hex lies between it and the token. Nearer hexes are usually revealed first, so in open country Line of Sight changes nothing: it only matters with a Sight Distance of 2 or more and hexes that stay covered, such as terrain filled with a Hex Reveal Distance.', + 'Hex Reveal Distance is stored on each hex when it is filled, so set it before filling; changing it later does not affect hexes already on the map. A token must be within that many hexes to reveal them, however far it can see, and with 0 they are only revealed by entering them. For a mountain range: set Hex Reveal Distance to 0, fill the mountains, set it back to none, then fill the land beyond. With Sight Distance 3 and Line of Sight on, the party sees the open ground around them, but not the mountains or what lies behind them. Each mountain hex is revealed when a token walks into it.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them. Glimpsed hexes do not block Line of Sight.', + 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + ], + }, + locations: { + heading: 'Named Hexes and Locations', + points: [ + 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', + 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', + 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', + ], + }, + settings: { + heading: 'Settings', + intro: + 'Change settings with !hexploration set (or the Settings button). Hex Layer, Tokens That Reveal and Language can also be set on the Mod’s settings page.', + colKey: 'Key', + colName: 'Setting', + colDesc: 'Description', + perPage: '(Can be set per page.)', + }, + jumpgate: { + heading: 'Jumpgate and Legacy', + points: [ + 'Hexploration works out which engine the game uses and draws the matching kind of shape. Shapes drawn in either editor can be filled.', + 'With Hex Layer set to Auto, hexes are drawn on the foreground layer, above tokens, so players cannot see what is underneath. If the foreground layer is not available, the token layer is used instead.', + 'Jumpgate draws mathematically regular hexes, which are a slightly different shape from Legacy hexes. If the hexes do not line up with a page’s grid, snap a token to a hex centre, select it and click Calibrate. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size too.', + 'When a page or game is copied, its hexes get new IDs. Run Rescan on the page to pick them up again, together with their name labels and location tokens.', + ], + }, + upgrading: { + heading: 'Upgrading from Version 1', + points: [ + 'Version 2 no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. You can remove them unless another mod uses them.', + 'Existing hex maps, names, location tokens and settings are upgraded automatically on the first start.', + 'The version 1 commands, including the Hexploration_menu macro, still work.', + 'Version 1 let any token that represented a character reveal hexes. Set Tokens That Reveal to Character tokens to keep that behaviour.', + ], + colV1: 'Version 1 command', + colV2: 'Version 2 command', + }, + troubleshooting: { + heading: 'Troubleshooting', + points: [ + 'Nothing happens when a token moves: check the token is on the token layer and matches Tokens That Reveal, and that the page has hexes (!hexploration status).', + 'Hexes are offset from the grid: use Calibrate, then check with a token on a few hexes across the map.', + 'Hexes stopped revealing after copying a page or game: run Rescan on the page.', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: 'Languages', + body: 'Choose a language with !hexploration set language. Available languages:', + colLanguage: 'Language', + colNative: 'Native name', + colCode: 'Code', + }, + credits: { + heading: 'Credits', + original: 'Original mod by', + maintainer: 'Version 2 maintained by', + marketplace: 'Ada’s art packs on the Roll20 Marketplace', + support: + 'If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log.', + }, + }, + }; + + const TRANSLATION$g = { + titles: { + ready: 'Hexploration on valmis.', + settings: 'Hexploration-asetukset', + languages: 'Valitse kieli', + pageSettings: 'Sivuasetukset: {page}', + status: 'Hexploration-tila: {page}', + help: 'Hexploration-komennot', + confirm: 'Vahvista', + }, + discovery: { + title: 'Sijainti löydetty', + }, + menu: { + draw: 'Piirto', + reveal: 'Paljasta ja piilota', + locations: 'Sijainnit', + tools: 'Työkalut', + layerInUse: 'Uudet heksat piirretään tasolle: {layer}.', + pageSettingsHelp: + 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', + }, + buttons: { + fill: 'Täytä', + fillInverse: 'Käänteinen täyttö', + undo: 'Kumoa täyttö', + reveal: 'Paljasta', + conceal: 'Peitä', + explore: 'Tutki', + revealPage: 'Paljasta sivu', + resetPage: 'Nollaa sivu', + mark: 'Merkitse sijainti', + unmark: 'Poista merkintä', + name: 'Nimeä heksa', + settings: 'Asetukset', + pageSettings: 'Sivuasetukset', + status: 'Tila', + rescan: 'Skannaa uudelleen', + calibrate: 'Kalibroi', + calibrateReset: 'Nollaa kalibrointi', + help: 'Ohje', + change: 'Muuta', + menu: 'Valikko', + clearOverrides: 'Tyhjennä ohitukset', + confirmReset: 'Kyllä, poista kaikki heksat', + }, + prompts: { + name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', + }, + values: { + on: 'Päällä', + off: 'Pois', + none: 'Ei mitään', + hexLayer: { + auto: 'Automaattinen (etuala, jos saatavilla)', + foreground: 'etualan taso', + objects: 'merkkitaso', + }, + revealBy: { + players: 'Pelaajien merkit', + characters: 'Hahmojen merkit', + all: 'Kaikki merkit', + }, + revealMode: { + clear: 'Poisto', + glimpse: 'Vilkaisu', + }, + announce: { + all: 'Kaikki', + gm: 'Vain GM', + off: 'Pois', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Täyttö', + fillInverse: 'Käänteinen täyttö', + conceal: 'Peitto', + }, + }, + settings: { + language: { + label: 'Kieli', + desc: 'Valikkojen, viestien ja monisteiden kieli.', + }, + hexLayer: { + label: 'Heksataso', + desc: 'Mihin uudet heksat piirretään. Automaattinen kokeilee etualan tasoa (merkkien yläpuolella) ja käyttää merkkitasoa, jos peli ei tue sitä.', + }, + fillColor: { + label: 'Täyttöväri', + desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Reunan väri', + desc: 'Uusien kuusioiden ääriviivan väri.', + }, + labelColor: { + label: 'Nimilappujen väri', + desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + }, + glimpseColor: { + label: 'Vilkaisun väri', + desc: 'Väri, jonka heksat saavat Vilkaisu-tilassa. Käytä läpikuultavaa rgba()-väriä.', + }, + strokeWidth: { + label: 'Reunan leveys', + desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', + }, + maxDistance: { + label: 'Heksojen paljastusetäisyys', + desc: 'Tallennetaan heksoihin, kun ne täytetään, joten aseta se ennen täyttämistä: myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee; arvolla 0 ne paljastuvat vain, kun niihin astutaan. Käytä sitä vuorille tai metsille. Jätä tyhjäksi, jos rajaa ei haluta.', + }, + revealDistance: { + label: 'Näköetäisyys', + desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', + }, + lineOfSight: { + label: 'Näköyhteys', + desc: 'Kun asetus on päällä, peitettyinä pysyvät heksat, kuten Heksojen paljastusetäisyys -asetuksella täytetyt vuoret, kätkevät takanaan olevat heksat. Sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän.', + }, + revealPath: { + label: 'Paljasta reitin varrelta', + desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + }, + revealBy: { + label: 'Paljastavat merkit', + desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + }, + revealMode: { + label: 'Paljastustila', + desc: 'Poisto poistaa näköetäisyydellä olevat heksat. Vilkaisu tekee niistä sen sijaan läpikuultavia; ne poistetaan, kun merkki astuu niihin.', + }, + announce: { + label: 'Ilmoita löydöt', + desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', + }, + pingDiscoveries: { + label: 'Pingaa löydöt', + desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', + }, + hideCoveredTokens: { + label: 'Piilota peitetyt merkit', + desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + }, + }, + status: { + engine: 'Pelimoottori', + grid: 'Ruudukko', + layer: 'Heksataso', + hexes: 'Heksat', + named: 'Nimetyt heksat', + icons: 'Sijaintimerkit', + glimpsed: 'Vilkaistut heksat', + pending: 'Täyttöä odottavat sijainnit', + calibrated: 'Kalibroitu', + overrides: 'Sivun ohitukset', + undo: 'Kumoaminen käytettävissä', + }, + messages: { + filled: + 'Täyttö valmis. Heksat piirretty: {created}. Uudelleen muotoiltu: {restyled}. Piilotetut sijainnit: {icons}.', + revealed: 'Heksat paljastettiin: {count}.', + revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', + confirmReset: + 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Heksit poistettu sivulta: {count}.', + undone: + 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksaalit nimeltä "{name}": {count}.', + unnamed: 'Poistetut nimet: {count}.', + marked: + 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + settingChanged: '{setting} asetettu arvoon {value}.', + rescanned: + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + calibrated: + 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + calibrationReset: + 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', + migrated: + 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', + pruned: + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla Skannaa uudelleen, jotta sen heksat löytyvät taas.', + readyHint: + 'Kirjoita !hexploration avataksesi valikon, tai avaa moniste "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', + }, + errors: { + noPage: 'Työstettävää sivua ei löytynyt.', + notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', + emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', + tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', + nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + noTokens: 'Valitse ensin yksi tai useampi merkki.', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + nothingToUndo: 'Kumoavaa täyttöä ei ole.', + unknownCommand: 'Tuntematon komento: {command}', + unknownSetting: 'Tuntematon asetus: {key}', + unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', + invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', + calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', + calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + unexpected: 'Jotain meni pieleen: {message}', + }, + hints: { + noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', + notHex: 'Aseta sivun ruudukoksi Hex (V) tai Hex (H) sivun asetuksista.', + noPolygons: + 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', + emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', + tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', + noHexes: + 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', + unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', + calibrateNeedsTokens: + 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', + calibrateFailed: + 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', + }, + help: { + menu: 'Näytä valikko.', + fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', + reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + explore: + 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', + resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', + mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', + unmark: 'Estä valittujen merkkien piilottaminen.', + set: 'Muuta asetusta tai näytä kaikki asetukset.', + pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', + pageClear: 'Poista nykyisen sivun ohitukset.', + rescan: + 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', + calibrate: + 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + calibrateReset: 'Poista nykyisen sivun kalibrointi.', + status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', + journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', + help: 'Näytä tämä luettelo.', + handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', + }, + deck: { + drawDesc: + 'Piirrä muotoja alueen ympärille, valitse ne ja napsauta Täytä. Kumoa täyttö peruu viimeisimmän täytön.', + revealDesc: + 'Valitse heksoja, muotoja tai merkkejä paljastaaksesi ne tai peittääksesi ne uudelleen. Tutki paljastaa valittujen merkkien ympäristön ikään kuin ne olisivat juuri siirtyneet sinne.', + locationsDesc: + 'Valitse merkit piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksoja tai merkkejä nimetäksesi heksan.', + toolsDesc: + 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', + footer: 'Katso täydelliset ohjeet monisteesta "{help}".', + }, + handout: { + versionLabel: 'Versio', + subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', + overview: { + heading: 'Yleiskatsaus', + body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + demo: 'Katso lyhyt esittely (versiosta 1)', + }, + quickStart: { + heading: 'Pika-aloitus', + steps: [ + 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', + 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', + 'Valitse muodot ja napsauta Command Deck -monisteessa Täytä (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: valitse ennen täyttöä merkit tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan heksojen alle, ja niistä ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajan merkkiä. Jokainen heksa, jonka läpi se kulkee, ja sen Näköetäisyyden sisällä olevat heksat paljastetaan.', + ], + }, + commands: { + heading: 'komennot', + intro: + 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', + colCommand: 'Komento', + colDesc: 'Mitä se tekee', + }, + revealing: { + heading: 'Kuinka paljastaminen toimii', + points: [ + 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat, lähimmät ensin. Kun Näköyhteys on päällä, heksaa ei paljasteta niin kauan kuin sen ja merkin välissä on peitetty heksa. Lähemmät heksat paljastuvat yleensä ensin, joten avoimessa maastossa Näköyhteys ei muuta mitään: sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän ja jotkin heksat pysyvät peitettyinä, kuten Heksojen paljastusetäisyys -asetuksella täytetty maasto.', + 'Heksojen paljastusetäisyys tallennetaan jokaiseen heksaan, kun se täytetään, joten aseta se ennen täyttämistä; myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, vaikka se näkisi kauemmas, ja arvolla 0 ne paljastuvat vain, kun niihin astutaan. Vuorijonoa varten: aseta Heksojen paljastusetäisyys arvoon 0, täytä vuoret, palauta asetus tyhjäksi ja täytä sitten takana oleva maa. Kun Näköetäisyys on 3 ja Näköyhteys on päällä, seurue näkee ympärillään olevan avoimen maaston mutta ei vuoria eikä sitä, mitä niiden takana on. Kukin vuoriheksa paljastuu, kun merkki astuu siihen.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin. Vilkaisun läpikuultavat heksat eivät estä näkyvyyttä Näköyhteys-asetuksessa.', + 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', + 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', + ], + }, + locations: { + heading: 'Nimetty Heksit ja sijainnit', + points: [ + 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', + 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', + ], + }, + settings: { + heading: 'Asetukset', + intro: + 'Muuta asetuksia komennolla !hexploration set (tai Asetukset-painikkeella). Heksatason, Paljastavat merkit ja Kielen voi asettaa myös modin asetussivulla.', + colKey: 'Avain', + colName: 'Asetus', + colDesc: 'Kuvaus', + perPage: '(Voidaan asettaa sivukohtaisesti.)', + }, + jumpgate: { + heading: 'Jumpgate ja Legacy', + points: [ + 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', + 'Kun Heksataso on Automaattinen, heksat piirretään etualan tasolle merkkien yläpuolelle, joten pelaajat eivät näe, mitä alla on. Jos etualan taso ei ole käytettävissä, käytetään merkkitasoa.', + 'Jumpgate piirtää matemaattisesti säännöllisiä heksoja, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksat eivät osu sivun ruudukkoon, kiinnitä merkki heksan keskipisteeseen, valitse se ja napsauta Kalibroi. Korjaa myös heksan koko valitsemalla kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) vierekkäisistä heksoista.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnisteet. Suorita sivulla Skannaa uudelleen, jotta ne löytyvät taas nimilappuineen ja sijaintimerkkeineen.', + ], + }, + upgrading: { + heading: 'Päivitys versiosta 1', + points: [ + 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', + 'Nykyiset heksakartat, nimet, sijaintimerkit ja asetukset päivitetään automaattisesti ensimmäisellä käynnistyksellä.', + 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', + 'Versiossa 1 mikä tahansa hahmoa edustava merkki paljasti heksoja. Säilytä tämä toiminta asettamalla Paljastavat merkit arvoon Hahmojen merkit.', + ], + colV1: 'Version 1 komento', + colV2: 'Version 2 komento', + }, + troubleshooting: { + heading: 'Vianetsintä', + points: [ + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkitasolla ja vastaa Paljastavat merkit -asetusta ja että sivulla on heksoja (!hexploration status).', + 'Heksat ovat siirtyneet ruudukosta: käytä Kalibroi-toimintoa ja tarkista sitten merkillä muutama heksa eri puolilta karttaa.', + 'Heksat lakkasivat paljastumasta sivun tai pelin kopioinnin jälkeen: suorita sivulla Skannaa uudelleen.', + 'Täytä ilmoittaa, ettei alueella ole heksojen keskipisteitä: muodon on sisällettävä vähintään yhden heksan keskipiste.', + 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', + ], + }, + languages: { + heading: 'Kielet', + body: 'Valitse kieli komennolla !hexploration set language. Käytettävissä olevat kielet:', + colLanguage: 'Kieli', + colNative: 'Oma nimi', + colCode: 'Koodi', + }, + credits: { + heading: 'Krediitit', + original: 'Alkuperäisen modin tekijä', + maintainer: 'Versio 2 ylläpitäjä', + marketplace: 'Adan taidepaketit Roll20 Marketplacessa', + support: + 'Jos löydät virheen tai sinulla on idea, kirjoita viesti Roll20 Mod -foorumille tai avaa ongelma GitHubissa ja sisällytä kaikki viestit API-konsolin lokista.', + }, + }, + }; + + const TRANSLATION$f = { + titles: { + ready: 'Hexploration est prêt.', + settings: "Paramètres d'Hexploration", + languages: 'Choisissez une langue', + pageSettings: 'Paramètres de la page : {page}', + status: "État d'Hexploration : {page}", + help: "Commandes d'Hexploration", + confirm: 'Veuillez confirmer', + }, + discovery: { + title: 'Emplacement découvert', + }, + menu: { + draw: 'Dessiner', + reveal: 'Révéler et masquer', + locations: 'Emplacements', + tools: 'Outils', + layerInUse: 'De nouveaux hexagones sont dessinés sur le {layer}.', + pageSettingsHelp: + "Ces paramètres s'appliquent uniquement à cette page. Les paramètres marqués ★ remplacent les paramètres globaux.", + }, + buttons: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + undo: 'Annuler le remplissage', + reveal: 'Révéler', + conceal: 'Cacher', + explore: 'Explorer', + revealPage: 'Révéler la page', + resetPage: 'Réinitialiser la page', + mark: "Marquer l'emplacement", + unmark: 'Démarquer', + name: "Nommer l'hexagone", + settings: 'Paramètres', + pageSettings: 'Paramètres de la page', + status: 'Statut', + rescan: 'Nouvelle analyse', + calibrate: 'Calibrer', + calibrateReset: 'Réinitialiser le calibrage', + help: 'Aide', + change: 'Modifier', + menu: 'Menu', + clearOverrides: 'Effacer les remplacements', + confirmReset: 'Oui, supprimer tous les hexagones', + }, + prompts: { + name: 'Nom du lieu (laissez vide pour effacer)', + }, + values: { + on: 'Activé', + off: 'Désactivé', + none: 'Aucun', + hexLayer: { + auto: 'Auto (premier plan si disponible)', + foreground: 'calque de premier plan', + objects: 'calque des jetons', + }, + revealBy: { + players: 'Jetons de joueur', + characters: 'Jetons de personnage', + all: 'Tous les jetons', + }, + revealMode: { + clear: 'Effacer', + glimpse: 'Aperçu', + }, + announce: { + all: 'Tout le monde', + gm: 'MJ uniquement', + off: 'Désactivé', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + conceal: 'Cacher', + }, + }, + settings: { + language: { + label: 'Langue', + desc: 'Langue des menus, des messages et des documents.', + }, + hexLayer: { + label: 'Calque des hexagones', + desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', + }, + fillColor: { + label: 'Couleur de remplissage', + desc: 'Couleur des nouveaux hexagones. Utilisez rgba() pour les hexagones transparents, par exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Couleur de la bordure', + desc: 'Couleur du contour des nouveaux hexagones.', + }, + labelColor: { + label: "Couleur de l'étiquette", + desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + }, + glimpseColor: { + label: "Couleur d'aperçu", + desc: 'Couleur que prennent les hexagones aperçus (mode de révélation Aperçu). Utilisez une couleur rgba() transparente.', + }, + strokeWidth: { + label: 'Largeur de la bordure', + desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + }, + maxDistance: { + label: 'Distance de révélation des hexagones', + desc: "Enregistrée sur les hexagones au moment où ils sont remplis, donc réglez-la avant de remplir : la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir ; avec 0, ils ne sont révélés qu'en y entrant. Utilisez-la pour des montagnes ou des forêts. Laissez vide pour ne fixer aucune limite.", + }, + revealDistance: { + label: 'Distance de vue', + desc: "Combien d'hexagones autour d'un jeton en mouvement sont révélés (0 à 20). 0 révèle uniquement les hexagones traversés par le jeton.", + }, + lineOfSight: { + label: 'Ligne de vue', + desc: "Lorsque cette option est activée, les hexagones qui restent couverts, comme des montagnes remplies avec une Distance de révélation des hexagones, cachent les hexagones situés derrière eux. Elle n'a d'effet qu'avec une Distance de vue de 2 ou plus.", + }, + revealPath: { + label: 'Révéler le long du chemin', + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + }, + revealBy: { + label: 'Jetons révélateurs', + desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", + }, + revealMode: { + label: 'Mode de révélation', + desc: "Effacer supprime les hexagones à portée de vue. Aperçu les rend plutôt transparents ; ils sont supprimés lorsqu'un jeton y entre.", + }, + announce: { + label: 'Annoncer les découvertes', + desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", + }, + pingDiscoveries: { + label: 'Pinger les découvertes', + desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", + }, + hideCoveredTokens: { + label: 'Masquer les jetons couverts', + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + }, + }, + status: { + engine: 'Moteur de jeu', + grid: 'Grille', + layer: 'Calque des hexagones', + hexes: 'Hexagones', + named: 'Hexagones nommés', + icons: "Jetons d'emplacement", + glimpsed: 'Hexagones aperçus', + pending: 'Emplacements en attente de remplissage', + calibrated: 'Calibré', + overrides: 'Remplacements de page', + undo: 'Annulation disponible', + }, + messages: { + filled: + 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', + revealed: 'Hexs révélés : {count}.', + revealedPage: 'Chaque hexagone de la page révélé ({count}).', + confirmReset: + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', + resetPage: 'Hexs supprimés de la page : {count}.', + undone: + 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', + named: 'Hexs nommés "{name}" : {count}.', + unnamed: 'Noms effacés : {count}.', + marked: + 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', + settingChanged: '{setting} défini sur {value}.', + rescanned: + 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + calibrated: + 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + calibrationReset: + 'Calibrage supprimé. Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + journalRebuilt: 'Les documents « {help} » et « {deck} » ont été reconstruits.', + migrated: + "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", + pruned: + "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + readyHint: + 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', + someFailed: + "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + }, + errors: { + noPage: 'Impossible de trouver la page sur laquelle travailler.', + notHex: "Cette page n'utilise pas de grille hexadécimale.", + noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', + emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", + tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", + nothingToConceal: 'Sélectionnez des formes dessinées ou des jetons à masquer.', + nothingToReveal: 'Sélectionnez des hexagones, des formes dessinées ou des jetons à révéler.', + noTokens: "Sélectionnez d'abord un ou plusieurs jetons.", + noHexes: + "Sélectionnez d'abord un ou plusieurs hexagones (ou des jetons placés sur des hexagones).", + nothingToUndo: "Il n'y a aucun remplissage à défaire.", + unknownCommand: 'Commande inconnue : {command}', + unknownSetting: 'Paramètre inconnu : {key}', + unknownPageSetting: 'Paramètres pouvant être définis par page : {keys}', + invalidValue: '"{value}" n\'est pas une valeur valide pour {key}.', + calibrateNeedsTokens: 'Sélectionnez un ou deux jetons accrochés aux centres des hexagones.', + calibrateFailed: 'Ces jetons ne peuvent pas être utilisés pour calibrer.', + unexpected: "Un problème s'est produit : {message}", + }, + hints: { + noPage: + 'Ouvrez la page sur laquelle vous souhaitez travailler ou sélectionnez quelque chose dessus.', + notHex: 'Définissez la grille de la page sur Hex (V) ou Hex (H) dans Paramètres de page.', + noPolygons: + 'Dessinez un polygone, un rectangle, une ellipse ou une forme à main levée autour de la zone, sélectionnez-le, puis réessayez.', + emptyArea: + 'Dessinez une forme plus grande ou vérifiez les paramètres de la grille de la page.', + tooMany: 'Remplissez une zone plus petite ou divisez la zone en plusieurs formes.', + noHexes: + 'Les hexagones sont au premier plan ou sur la couche de jetons ; passez à ce calque pour les sélectionner.', + unknownCommand: 'Tapez !hexploration help pour lister les commandes.', + unknownSetting: 'Tapez !hexploration set pour voir tous les paramètres.', + calibrateNeedsTokens: + "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + calibrateFailed: + "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + unexpected: 'Les détails se trouvent dans le journal de la console API.', + }, + help: { + menu: 'Afficher le menu.', + fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', + fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", + undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + reveal: + 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', + revealPage: 'Révélez chaque hexagone de la page sans annonce.', + conceal: + 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', + explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", + mark: 'Transformez les jetons sélectionnés en emplacements cachés.', + unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", + set: 'Modifiez un paramètre ou affichez tous les paramètres.', + pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', + pageClear: 'Supprimez les remplacements de la page actuelle.', + rescan: + 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + calibrate: + 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', + calibrateReset: 'Supprimez le calibrage de la page actuelle.', + status: 'Montre ce que Hexploration sait de la page actuelle.', + journal: 'Reconstruisez les documents Help et Command Deck.', + help: 'Montrez cette liste.', + handout: 'Les instructions complètes se trouvent dans le document « {name} ».', + }, + deck: { + drawDesc: + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez. Annuler le remplissage annule le dernier remplissage.", + revealDesc: + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir. Explorer révèle les alentours des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + locationsDesc: + "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", + toolsDesc: + 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Exploration hex par hex pour Roll20', + footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', + overview: { + heading: 'Aperçu', + body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + demo: 'Regardez une courte démo (à partir de la version 1)', + }, + quickStart: { + heading: 'Démarrage rapide', + steps: [ + 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', + 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', + 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", + "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + ], + }, + commands: { + heading: 'Commandes', + intro: + 'Seuls les MJ peuvent utiliser ces commandes. La plupart agissent sur les objets sélectionnés ; le reste agit sur la page que vous consultez.', + colCommand: 'Commande', + colDesc: 'Ce que ça fait', + }, + revealing: { + heading: 'Comment fonctionne la révélation', + points: [ + 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', + "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", + "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", + "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + ], + }, + locations: { + heading: 'Hexs et emplacements nommés', + points: [ + "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", + 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', + "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", + ], + }, + settings: { + heading: 'Paramètres', + intro: + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). Calque des hexagones, Jetons révélateurs et Langue peuvent aussi être définis sur la page de paramètres du mod.', + colKey: 'Clé', + colName: 'Paramètre', + colDesc: 'Description', + perPage: '(Peut être défini par page.)', + }, + jumpgate: { + heading: 'Jumpgate et héritage', + points: [ + "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", + "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", + "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", + ], + }, + upgrading: { + heading: 'Mise à niveau à partir de la version 1', + points: [ + "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", + 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', + 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', + 'La version 1 permettait à tout jeton représentant un personnage de révéler des hexagones. Réglez Jetons révélateurs sur Jetons de personnage pour conserver ce comportement.', + ], + colV1: 'Commande version 1', + colV2: 'Commande version 2', + }, + troubleshooting: { + heading: 'Dépannage', + points: [ + 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', + 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', + "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", + ], + }, + languages: { + heading: 'Langues', + body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + colLanguage: 'Langue', + colNative: "Nom d'origine", + colCode: 'Code', + }, + credits: { + heading: 'Crédits', + original: 'Mod original par', + maintainer: 'Version 2 maintenue par', + marketplace: "Les packs artistiques d'Ada sur le Marketplace Roll20", + support: + 'Si vous trouvez un bug ou avez une idée, publiez-le sur le forum Roll20 Mod ou ouvrez un problème sur GitHub et incluez tous les messages du journal de la console API.', + }, + }, + }; + + const TRANSLATION$e = { + titles: { + ready: 'Hexploration ist bereit.', + settings: 'Hexploration-Einstellungen', + languages: 'Sprache wählen', + pageSettings: 'Seiteneinstellungen: {page}', + status: 'Hexploration-Status: {page}', + help: 'Hexploration-Befehle', + confirm: 'Bitte bestätigen', + }, + discovery: { + title: 'Standort entdeckt', + }, + menu: { + draw: 'Zeichnen', + reveal: 'Aufdecken und Verdecken', + locations: 'Standorte', + tools: 'Werkzeuge', + layerInUse: 'Neue Hexfelder werden auf der {layer} gezeichnet.', + pageSettingsHelp: + 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', + }, + buttons: { + fill: 'Füllen', + fillInverse: 'Umgekehrt füllen', + undo: 'Füllung rückgängig machen', + reveal: 'Aufdecken', + conceal: 'Verbergen', + explore: 'Erkunden', + revealPage: 'Seite aufdecken', + resetPage: 'Seite zurücksetzen', + mark: 'Standort markieren', + unmark: 'Markierung aufheben', + name: 'Hexfeld benennen', + settings: 'Einstellungen', + pageSettings: 'Seiteneinstellungen', + status: 'Status', + rescan: 'Erneut scannen', + calibrate: 'Kalibrieren', + calibrateReset: 'Kalibrierung zurücksetzen', + help: 'Hilfe', + change: 'Ändern', + menu: 'Menü', + clearOverrides: 'Überschreibungen löschen', + confirmReset: 'Ja, alle Hexfelder entfernen', + }, + prompts: { + name: 'Standortname (zum Löschen leer lassen)', + }, + values: { + on: 'An', + off: 'Aus', + none: 'Keine', + hexLayer: { + auto: 'Auto (Vordergrund, falls verfügbar)', + foreground: 'Vordergrundebene', + objects: 'Token-Ebene', + }, + revealBy: { + players: 'Spielertoken', + characters: 'Charaktertoken', + all: 'Alle Token', + }, + revealMode: { + clear: 'Entfernen', + glimpse: 'Durchsicht', + }, + announce: { + all: 'Alle', + gm: 'Nur GM', + off: 'Aus', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Füllen', + fillInverse: 'Umgekehrt füllen', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Sprache', + desc: 'Sprache für Menüs, Nachrichten und Handouts.', + }, + hexLayer: { + label: 'Hexfeld-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. „Auto“ versucht es mit der Vordergrundebene (über den Token) und weicht auf die Token-Ebene aus, wenn das Spiel sie nicht unterstützt.', + }, + fillColor: { + label: 'Füllfarbe', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randfarbe', + desc: 'Farbe der Umrisse neuer Hexfelder.', + }, + labelColor: { + label: 'Beschriftungsfarbe', + desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', + }, + glimpseColor: { + label: 'Durchsicht-Farbe', + desc: 'Farbe, die Hexfelder annehmen, wenn sie durchsichtig werden (Aufdeckmodus „Durchsicht“). Verwenden Sie eine durchsichtige rgba()-Farbe.', + }, + strokeWidth: { + label: 'Randbreite', + desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', + }, + maxDistance: { + label: 'Aufdeckungsdistanz für Hexfelder', + desc: 'Wird beim Füllen in den Hexfeldern gespeichert, also vor dem Füllen festlegen: Spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann; bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für Berge oder Wälder verwenden. Für keine Begrenzung leer lassen.', + }, + revealDistance: { + label: 'Sichtweite', + desc: 'Wie viele Hexfelder um einen beweglichen Spielstein herum angezeigt werden (0 bis 20). 0 zeigt nur die Hexfelder an, die der Token durchquert.', + }, + lineOfSight: { + label: 'Sichtlinie', + desc: 'Wenn diese Option aktiviert ist, verbergen Hexfelder, die verdeckt bleiben, etwa Berge, die mit einer Aufdeckungsdistanz für Hexfelder gefüllt wurden, die Hexfelder dahinter. Das macht nur bei einer Sichtweite von 2 oder mehr einen Unterschied.', + }, + revealPath: { + label: 'Entlang des Wegs aufdecken', + desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', + }, + revealBy: { + label: 'Aufdeckende Token', + desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + }, + revealMode: { + label: 'Aufdeckmodus', + desc: '„Entfernen“ entfernt Hexfelder in Sichtweite. „Durchsicht“ macht sie stattdessen durchsichtig; sie werden entfernt, sobald ein Token sie betritt.', + }, + announce: { + label: 'Entdeckungen ankündigen', + desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', + }, + pingDiscoveries: { + label: 'Entdeckungen anpingen', + desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', + }, + hideCoveredTokens: { + label: 'Verdeckte Token ausblenden', + desc: 'Roll20 zeichnet Namen, Balken und Auren über Hexfeldern. Wenn diese Option aktiviert ist, werden der für den Spieler sichtbare Name, die Balken und die Auren von Spielsteinen unter einem abgedeckten Hexfeld ausgeschaltet und wieder eingeschaltet, wenn sie aufgedeckt werden.', + }, + }, + status: { + engine: 'Spiel-Engine', + grid: 'Raster', + layer: 'Hexfeld-Ebene', + hexes: 'Hexfelder', + named: 'Benannte Hexfelder', + icons: 'Standort-Token', + glimpsed: 'Durchsichtige Hexfelder', + pending: 'Standorte, die auf eine Füllung warten', + calibrated: 'Kalibriert', + overrides: 'Seitenüberschreibungen', + undo: 'Rückgängig möglich', + }, + messages: { + filled: + 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', + revealed: 'Aufgedeckte Verhexungen: {count}.', + revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + confirmReset: + 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + undone: + 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexen mit dem Namen „{name}“: {count}.', + unnamed: 'Gelöschte Namen: {count}.', + marked: + 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', + unmarked: 'Token, die keine Standorte mehr sind: {count}.', + settingChanged: '{setting} wird auf {value} gesetzt.', + rescanned: + 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + calibrated: + 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + calibrationReset: + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', + migrated: + 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', + pruned: + 'Gespeicherte Hexfelder, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie auf der Seite „Erneut scannen“ aus, um ihre Hexfelder wieder zu erfassen.', + readyHint: + 'Geben Sie !hexploration ein, um das Menü aufzurufen, oder öffnen Sie das Handout "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', + someFailed: + 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + }, + errors: { + noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', + notHex: 'Diese Seite verwendet kein Hex-Raster.', + noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', + emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', + tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + nothingToConceal: + 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + nothingToReveal: + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', + noHexes: + 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', + nothingToUndo: 'Es gibt keine Füllung, die rückgängig gemacht werden könnte.', + unknownCommand: 'Unbekannter Befehl: {command}', + unknownSetting: 'Unbekannte Einstellung: {key}', + unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', + invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', + calibrateNeedsTokens: + 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', + unexpected: 'Es ist ein Fehler aufgetreten: {message}', + }, + hints: { + noPage: + 'Öffnen Sie die Seite, an der Sie arbeiten möchten, oder wählen Sie etwas darauf aus.', + notHex: + 'Stellen Sie das Seitenraster in den Seiteneinstellungen auf Hex (V) oder Hex (H) ein.', + noPolygons: + 'Zeichnen Sie ein Polygon, ein Rechteck, eine Ellipse oder eine Freihandform um den Bereich, wählen Sie es aus und versuchen Sie es erneut.', + emptyArea: + 'Zeichnen Sie eine größere Form oder überprüfen Sie die Seitenrastereinstellungen.', + tooMany: + 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', + noHexes: + 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', + unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', + calibrateNeedsTokens: + 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', + calibrateFailed: + 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + unexpected: 'Details finden Sie im API-Konsolenprotokoll.', + }, + help: { + menu: 'Zeigen Sie das Menü an.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', + undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + reveal: + 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', + revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + conceal: + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + explore: + 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', + set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', + pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', + rescan: + 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + calibrate: + 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', + status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', + journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', + help: 'Diese Liste anzeigen.', + handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', + }, + deck: { + drawDesc: + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie dann. „Füllung rückgängig machen“ macht die letzte Füllung rückgängig.', + revealDesc: + 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', + locationsDesc: + 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + toolsDesc: + 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', + footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-für-Hex-Erkundung für Roll20', + footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', + overview: { + heading: 'Überblick', + body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', + }, + quickStart: { + heading: 'Schnellstart', + steps: [ + 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', + 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf Füllen (oder geben Sie !hexploration fill ein). Die Formen werden durch Hexfelder ersetzt.', + 'Optional: Wählen Sie vor dem Füllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie werden unter den Hexfeldern versteckt und bei ihrer Entdeckung angekündigt.', + 'Bewegen Sie einen Spieler-Token. Jedes Hexfeld, das er durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + ], + }, + commands: { + heading: 'Befehle', + intro: + 'Nur GMs können diese Befehle verwenden. Die meisten wirken auf die ausgewählten Objekte; Der Rest wirkt auf der Seite, die Sie gerade betrachten.', + colCommand: 'Befehl', + colDesc: 'Was es bewirkt', + }, + revealing: { + heading: 'Wie Offenlegung funktioniert', + points: [ + 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf, die nächstgelegenen zuerst. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nicht aufgedeckt, solange ein verdecktes Hexfeld zwischen ihm und dem Token liegt. Nähere Hexfelder werden meist zuerst aufgedeckt, daher ändert „Sichtlinie“ in offenem Gelände nichts: Sie spielt nur bei einer „Sichtweite“ von 2 oder mehr und bei Hexfeldern eine Rolle, die verdeckt bleiben, etwa Gelände, das mit einer „Aufdeckungsdistanz für Hexfelder“ gefüllt wurde.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Füllen in jedem Hexfeld gespeichert, legen Sie sie also vor dem Füllen fest; spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Token muss sich innerhalb so vieler Hexfelder befinden, um sie aufzudecken, egal wie weit es sehen kann, und bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für eine Bergkette: Setzen Sie „Aufdeckungsdistanz für Hexfelder“ auf 0, füllen Sie die Berge, setzen Sie den Wert wieder auf „keine“ zurück und füllen Sie dann das Land dahinter. Mit „Sichtweite“ 3 und aktivierter „Sichtlinie“ sieht die Gruppe das offene Gelände um sich herum, aber weder die Berge noch das, was dahinter liegt. Jedes Berg-Hexfeld wird aufgedeckt, wenn ein Token es betritt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt. Durchsichtige Hexfelder blockieren die „Sichtlinie“ nicht.', + 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + ], + }, + locations: { + heading: 'Benannte Hexfelder und Orte', + points: [ + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', + 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', + 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', + ], + }, + settings: { + heading: 'Einstellungen', + intro: + 'Ändern Sie Einstellungen mit !hexploration set (oder über die Schaltfläche „Einstellungen“). „Hexfeld-Ebene“, „Aufdeckende Token“ und „Sprache“ lassen sich auch auf der Einstellungsseite des Mods festlegen.', + colKey: 'Schlüssel', + colName: 'Einstellung', + colDesc: 'Beschreibung', + perPage: '(Kann pro Seite eingestellt werden.)', + }, + jumpgate: { + heading: 'Jumpgate und Legacy', + points: [ + 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', + 'Ist „Hexfeld-Ebene“ auf „Auto“ gesetzt, werden Hexfelder auf der Vordergrundebene über den Token gezeichnet, sodass Spieler nicht sehen können, was darunter liegt. Ist die Vordergrundebene nicht verfügbar, wird stattdessen die Token-Ebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Hexfelder, deren Form leicht von Legacy-Hexfeldern abweicht. Wenn die Hexfelder nicht mit dem Raster einer Seite übereinstimmen, rasten Sie einen Token in der Mitte eines Hexfelds ein, wählen Sie ihn aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Token in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie auf der Seite „Erneut scannen“ aus, um sie zusammen mit ihren Namensbeschriftungen und Standort-Token wieder zu erfassen.', + ], + }, + upgrading: { + heading: 'Upgrade von Version 1', + points: [ + 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', + 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', + 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', + ], + colV1: 'Befehl der Version 1', + colV2: 'Befehl der Version 2', + }, + troubleshooting: { + heading: 'Fehlerbehebung', + points: [ + 'Nichts passiert, wenn sich ein Token bewegt: Prüfen Sie, ob der Token auf der Token-Ebene liegt und zu „Aufdeckende Token“ passt und ob die Seite Hexfelder hat (!hexploration status).', + 'Hexfelder sind gegenüber dem Raster versetzt: Verwenden Sie „Kalibrieren“ und prüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Hexfelder werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr aufgedeckt: Führen Sie auf der Seite „Erneut scannen“ aus.', + '„Füllen“ meldet, dass der Bereich keine Hexfeld-Mittelpunkte enthält: Die Form muss den Mittelpunkt von mindestens einem Hexfeld enthalten.', + 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', + ], + }, + languages: { + heading: 'Sprachen', + body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + colLanguage: 'Sprache', + colNative: 'Eigenbezeichnung', + colCode: 'Code', + }, + credits: { + heading: 'Credits', + original: 'Original-Mod von', + maintainer: 'Version 2 verwaltet von', + marketplace: 'Adas Kunstpakete auf dem Roll20-Marktplatz', + support: + 'Wenn Sie einen Fehler finden oder eine Idee haben, posten Sie im Roll20 Mod-Forum oder öffnen Sie ein Problem auf GitHub und fügen Sie alle Meldungen aus dem API-Konsolenprotokoll hinzu.', + }, + }, + }; + + const TRANSLATION$d = { + titles: { + ready: 'Το Hexploration είναι έτοιμο.', + settings: 'Ρυθμίσεις Hexploration', + languages: 'Επιλέξτε μια γλώσσα', + pageSettings: 'Ρυθμίσεις σελίδας: {page}', + status: 'Κατάσταση Hexploration: {page}', + help: 'Εντολές Hexploration', + confirm: 'Επιβεβαιώστε', + }, + discovery: { + title: 'Ανακαλύφθηκε τοποθεσία', + }, + menu: { + draw: 'Σχεδίαση', + reveal: 'Αποκάλυψη και απόκρυψη', + locations: 'Τοποθεσίες', + tools: 'Εργαλεία', + layerInUse: 'Νέα εξάγωνα σχεδιάζονται στο {layer}.', + pageSettingsHelp: + 'Αυτές οι ρυθμίσεις ισχύουν μόνο για αυτήν τη σελίδα. Οι ρυθμίσεις με την ένδειξη ★ αντικαθιστούν τις καθολικές ρυθμίσεις.', + }, + buttons: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + undo: 'Αναίρεση γεμίσματος', + reveal: 'Αποκάλυψη', + conceal: 'Απόκρυψη', + explore: 'Εξερεύνηση', + revealPage: 'Αποκάλυψη σελίδας', + resetPage: 'Επαναφορά σελίδας', + mark: 'Επισήμανση τοποθεσίας', + unmark: 'Κατάργηση επισήμανσης', + name: 'Ονομασία εξαγώνου', + settings: 'Ρυθμίσεις', + pageSettings: 'Ρυθμίσεις σελίδας', + status: 'Κατάσταση', + rescan: 'Επανασάρωση', + calibrate: 'Βαθμονόμηση', + calibrateReset: 'Επαναφορά βαθμονόμησης', + help: 'Βοήθεια', + change: 'Αλλαγή', + menu: 'Μενού', + clearOverrides: 'Κατάργηση παρακάμψεων', + confirmReset: 'Ναι, αφαίρεση όλων των εξαγώνων', + }, + prompts: { + name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', + }, + values: { + on: 'Ενεργό', + off: 'Ανενεργό', + none: 'Κανένα', + hexLayer: { + auto: 'Αυτόματο (πρώτο πλάνο, αν είναι διαθέσιμο)', + foreground: 'επίπεδο πρώτου πλάνου', + objects: 'επίπεδο διακριτικών', + }, + revealBy: { + players: 'Διακριτικά παικτών', + characters: 'Διακριτικά χαρακτήρων', + all: 'Όλα τα διακριτικά', + }, + revealMode: { + clear: 'Καθαρισμός', + glimpse: 'Ματιά', + }, + announce: { + all: 'Όλοι', + gm: 'Μόνο GM', + off: 'Ανενεργό', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + conceal: 'Απόκρυψη', + }, + }, + settings: { + language: { + label: 'Γλώσσα', + desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', + }, + hexLayer: { + label: 'Επίπεδο εξαγώνων', + desc: 'Πού σχεδιάζονται τα νέα εξάγωνα. Το «Αυτόματο» δοκιμάζει το επίπεδο πρώτου πλάνου (πάνω από τα διακριτικά) και, αν το παιχνίδι δεν το υποστηρίζει, χρησιμοποιεί το επίπεδο διακριτικών.', + }, + fillColor: { + label: 'Χρώμα πλήρωσης', + desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Χρώμα περιγράμματος', + desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + }, + labelColor: { + label: 'Χρώμα ετικετών', + desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', + }, + glimpseColor: { + label: 'Χρώμα Ματιάς', + desc: 'Το χρώμα που παίρνουν τα εξάγωνα στη λειτουργία «Ματιά». Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + }, + strokeWidth: { + label: 'Πλάτος περιγράμματος', + desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + }, + maxDistance: { + label: 'Απόσταση αποκάλυψης εξαγώνων', + desc: 'Αποθηκεύεται στα εξάγωνα όταν γεμίζονται, οπότε ορίστε το πριν από το γέμισμα: αν το αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει· με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Χρησιμοποιήστε το για βουνά ή δάση. Αφήστε το κενό για να μην υπάρχει όριο.', + }, + revealDistance: { + label: 'Απόσταση όρασης', + desc: 'Πόσα εξάγωνα γύρω από ένα κινούμενο διακριτικό αποκαλύπτονται (0 έως 20). Το 0 αποκαλύπτει μόνο τα εξάγωνα από τα οποία διέρχεται το διακριτικό.', + }, + lineOfSight: { + label: 'Γραμμή όρασης', + desc: 'Όταν είναι ενεργοποιημένο, τα εξάγωνα που παραμένουν καλυμμένα, όπως βουνά που γεμίστηκαν με «Απόσταση αποκάλυψης εξαγώνων», κρύβουν τα εξάγωνα πίσω τους. Κάνει διαφορά μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη.', + }, + revealPath: { + label: 'Αποκάλυψη κατά μήκος της διαδρομής', + desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', + }, + revealBy: { + label: 'Διακριτικά που αποκαλύπτουν', + desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + }, + revealMode: { + label: 'Λειτουργία αποκάλυψης', + desc: "Ο «Καθαρισμός» αφαιρεί τα εξάγωνα εντός όρασης. Η «Ματιά» τα κάνει αντί γι' αυτό διαφανή· αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.", + }, + announce: { + label: 'Ανακοίνωση ανακαλύψεων', + desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', + }, + pingDiscoveries: { + label: 'Ping στις ανακαλύψεις', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + }, + hideCoveredTokens: { + label: 'Απόκρυψη καλυμμένων διακριτικών', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + }, + }, + status: { + engine: 'Μηχανή παιχνιδιού', + grid: 'Πλέγμα', + layer: 'Επίπεδο εξαγώνων', + hexes: 'Εξάγωνα', + named: 'Ονομασμένα εξάγωνα', + icons: 'Διακριτικά τοποθεσιών', + glimpsed: 'Εξάγωνα σε Ματιά', + pending: 'Τοποθεσίες που περιμένουν γέμισμα', + calibrated: 'Βαθμονομημένο', + overrides: 'Παρακάμψεις σελίδας', + undo: 'Αναίρεση διαθέσιμη', + }, + messages: { + filled: + 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', + revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + confirmReset: + 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', + resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', + undone: + 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', + named: 'Hexes με όνομα "{name}": {count}.', + unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', + marked: + 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', + settingChanged: 'Το {setting} ορίστηκε σε {value}.', + rescanned: + 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + calibrated: + 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + calibrationReset: + 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', + migrated: + 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', + pruned: + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πια και ξεχάστηκαν: {dropped}. Αν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά τα εξάγωνά της.', + readyHint: + 'Πληκτρολογήστε !hexploration για να ανοίξει το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + someFailed: + 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + }, + errors: { + noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', + notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', + tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', + unknownCommand: 'Άγνωστη εντολή: {command}', + unknownSetting: 'Άγνωστη ρύθμιση: {key}', + unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', + invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', + unexpected: 'Κάτι πήγε στραβά: {message}', + }, + hints: { + noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', + notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + noPolygons: + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', + noHexes: + 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', + unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', + calibrateNeedsTokens: + 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + calibrateFailed: + 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', + }, + help: { + menu: 'Εμφάνιση του μενού.', + fill: 'Καλύψτε τα επιλεγμένα σχεδιασμένα σχήματα με εξάγωνα.', + fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', + undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', + reveal: + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', + conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', + name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', + mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', + unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', + pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', + pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', + rescan: + 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + calibrate: + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', + status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', + journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', + help: 'Εμφάνιση αυτής της λίστας.', + handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', + }, + deck: { + drawDesc: + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και κάντε «Γέμισμα». Η «Αναίρεση γεμίσματος» αναιρεί το τελευταίο γέμισμα.', + revealDesc: + 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', + locationsDesc: + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + toolsDesc: + 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', + footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', + }, + handout: { + versionLabel: 'Εκδοχή', + subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', + overview: { + heading: 'Επισκόπηση', + body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', + }, + quickStart: { + heading: 'Γρήγορη εκκίνηση', + steps: [ + 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', + 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Γέμισμα στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν από το γέμισμα, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην «Επισήμανση τοποθεσίας». Κρύβονται κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και τα εξάγωνα εντός της «Απόστασης όρασης» του, αποκαλύπτονται.', + ], + }, + commands: { + heading: 'Εντολές', + intro: + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + colCommand: 'Εντολή', + colDesc: 'Τι κάνει', + }, + revealing: { + heading: 'Πώς λειτουργεί η αποκάλυψη', + points: [ + 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα, ξεκινώντας από τα πλησιέστερα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο δεν αποκαλύπτεται όσο παρεμβάλλεται καλυμμένο εξάγωνο ανάμεσα σε αυτό και στο διακριτικό. Τα πλησιέστερα εξάγωνα συνήθως αποκαλύπτονται πρώτα, οπότε σε ανοιχτό έδαφος η «Γραμμή όρασης» δεν αλλάζει τίποτα: έχει σημασία μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη και εξάγωνα που παραμένουν καλυμμένα, όπως έδαφος που γεμίστηκε με «Απόσταση αποκάλυψης εξαγώνων».', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται σε κάθε εξάγωνο όταν γεμίζεται, οπότε ορίστε την πριν από το γέμισμα· αν την αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει, και με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Για μια οροσειρά: ορίστε την «Απόσταση αποκάλυψης εξαγώνων» σε 0, γεμίστε τα βουνά, επαναφέρετέ την σε καμία τιμή και μετά γεμίστε τη γη πέρα από αυτά. Με «Απόσταση όρασης» 3 και ενεργή τη «Γραμμή όρασης», η ομάδα βλέπει το ανοιχτό έδαφος γύρω της, αλλά όχι τα βουνά ή ό,τι βρίσκεται πίσω τους. Κάθε ορεινό εξάγωνο αποκαλύπτεται όταν ένα διακριτικό μπει σε αυτό.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό. Τα εξάγωνα σε κατάσταση «Ματιά» δεν εμποδίζουν τη «Γραμμή όρασης».', + 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', + 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + ], + }, + locations: { + heading: 'Με όνομα Hexes and Locations', + points: [ + 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + ], + }, + settings: { + heading: 'Ρυθμίσεις', + intro: + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', + colKey: 'Κλειδί', + colName: 'Σύνθεση', + colDesc: 'Περιγραφή', + perPage: '(Μπορεί να οριστεί ανά σελίδα.)', + }, + jumpgate: { + heading: 'Jumpgate και Legacy', + points: [ + 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', + 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', + ], + }, + upgrading: { + heading: 'Αναβάθμιση από την έκδοση 1', + points: [ + 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', + 'Οι υπάρχοντες εξαγωνικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσιών και οι ρυθμίσεις αναβαθμίζονται αυτόματα στην πρώτη εκκίνηση.', + 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', + 'Η έκδοση 1 επέτρεπε σε κάθε διακριτικό που αντιπροσώπευε χαρακτήρα να αποκαλύπτει εξάγωνα. Ορίστε τα «Διακριτικά που αποκαλύπτουν» σε «Διακριτικά χαρακτήρων» για να διατηρήσετε αυτή τη συμπεριφορά.', + ], + colV1: 'Εντολή έκδοσης 1', + colV2: 'Εντολή έκδοσης 2', + }, + troubleshooting: { + heading: 'Αντιμετώπιση προβλημάτων', + points: [ + 'Δεν συμβαίνει τίποτα όταν μετακινείται ένα διακριτικό: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο διακριτικών και ταιριάζει με τη ρύθμιση «Διακριτικά που αποκαλύπτουν», και ότι η σελίδα έχει εξάγωνα (!hexploration status).', + 'Τα εξάγωνα είναι μετατοπισμένα από το πλέγμα: χρησιμοποιήστε τη «Βαθμονόμηση» και μετά ελέγξτε με ένα διακριτικό μερικά εξάγωνα σε διάφορα σημεία του χάρτη.', + 'Τα εξάγωνα σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε «Επανασάρωση» στη σελίδα.', + 'Το «Γέμισμα» αναφέρει ότι η περιοχή δεν έχει κέντρα εξαγώνων: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξαγώνου.', + 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', + ], + }, + languages: { + heading: 'Γλώσσες', + body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + colLanguage: 'Γλώσσα', + colNative: 'Όνομα στη γλώσσα της', + colCode: 'Κώδικας', + }, + credits: { + heading: 'Πιστώσεις', + original: 'Πρωτότυπο mod από', + maintainer: 'Έκδοση 2 που διατηρείται από', + marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', + support: + 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', + }, + }, + }; + + const TRANSLATION$c = { + titles: { + ready: 'Hexploration מוכן.', + settings: 'הגדרות Hexploration', + languages: 'בחירת שפה', + pageSettings: 'הגדרות דף: {page}', + status: 'מצב Hexploration: {page}', + help: 'פקודות Hexploration', + confirm: 'נא לאשר', + }, + discovery: { + title: 'מיקום התגלה', + }, + menu: { + draw: 'ציור', + reveal: 'חשיפה והסתרה', + locations: 'מיקומים', + tools: 'כלים', + layerInUse: 'משושים חדשים מצוירים על {layer}.', + pageSettingsHelp: + 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', + }, + buttons: { + fill: 'מילוי', + fillInverse: 'מילוי הפוך', + undo: 'ביטול מילוי', + reveal: 'חשיפה', + conceal: 'הסתרה', + explore: 'חקירה', + revealPage: 'חשיפת הדף', + resetPage: 'איפוס הדף', + mark: 'סימון מיקום', + unmark: 'ביטול סימון', + name: 'מתן שם למשושה', + settings: 'הגדרות', + pageSettings: 'הגדרות דף', + status: 'מצב', + rescan: 'סריקה מחדש', + calibrate: 'כיול', + calibrateReset: 'אפס כיול', + help: 'עזרה', + change: 'שינוי', + menu: 'תפריט', + clearOverrides: 'ניקוי עקיפות', + confirmReset: 'כן, הסר את כל המשושים', + }, + prompts: { + name: 'שם המיקום (השאירו ריק כדי לנקות)', + }, + values: { + on: 'מופעל', + off: 'כבוי', + none: 'ללא', + hexLayer: { + auto: 'אוטומטי (שכבת החזית אם זמינה)', + foreground: 'שכבת החזית', + objects: 'שכבת האסימונים', + }, + revealBy: { + players: 'אסימוני שחקנים', + characters: 'אסימוני דמויות', + all: 'כל האסימונים', + }, + revealMode: { + clear: 'הסרה', + glimpse: 'הצצה', + }, + announce: { + all: 'כולם', + gm: 'GM בלבד', + off: 'כבוי', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'מילוי', + fillInverse: 'מילוי הפוך', + conceal: 'הסתרה', + }, + }, + settings: { + language: { + label: 'שפה', + desc: 'שפה לתפריטים, הודעות ודפי מידע.', + }, + hexLayer: { + label: 'שכבת המשושים', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + }, + fillColor: { + label: 'צבע מילוי', + desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'צבע מסגרת', + desc: 'צבע קווי המתאר של משושות חדשות.', + }, + labelColor: { + label: 'צבע תווית', + desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + }, + glimpseColor: { + label: 'צבע הצצה', + desc: 'הצבע שאליו משושים משתנים בעת הצצה (מצב החשיפה הצצה). השתמש בצבע rgba() שקוף.', + }, + strokeWidth: { + label: 'עובי מסגרת', + desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', + }, + maxDistance: { + label: 'מרחק חשיפת משושים', + desc: 'נשמר על המשושים בעת מילוים, לכן הגדר אותו לפני המילוי: שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות; עם 0 הם נחשפים רק כשנכנסים אליהם. השתמש בו להרים או ליערות. השאר ריק ללא הגבלה.', + }, + revealDistance: { + label: 'מרחק ראייה', + desc: 'כמה משושים סביב אסימון נע נחשפים (0 עד 20). 0 חושף רק את המשושים שהאסימון עובר דרכם.', + }, + lineOfSight: { + label: 'קו ראייה', + desc: 'כאשר מופעל, משושים שנשארים מכוסים, כמו הרים שמולאו עם מרחק חשיפת משושים, מסתירים את המשושים שמאחוריהם. יש לכך השפעה רק עם מרחק ראייה של 2 ומעלה.', + }, + revealPath: { + label: 'חשיפה לאורך המסלול', + desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', + }, + revealBy: { + label: 'אסימונים חושפים', + desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', + }, + revealMode: { + label: 'מצב חשיפה', + desc: 'הסרה מסירה משושים שבטווח הראייה. הצצה הופכת אותם לשקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + }, + announce: { + label: 'הכרזה על תגליות', + desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", + }, + pingDiscoveries: { + label: 'פינג לתגליות', + desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', + }, + hideCoveredTokens: { + label: 'הסתר אסימונים מכוסים', + desc: 'Roll20 מצייר שמות, פסים והילות מעל משושים. כשההגדרה מופעלת, השם, הפסים וההילות הגלויים לשחקנים של אסימונים שמתחת למשושה מכוסה נכבים, ומופעלים שוב כשהם נחשפים.', + }, + }, + status: { + engine: 'מנוע משחק', + grid: 'רשת', + layer: 'שכבת המשושים', + hexes: 'משושים', + named: 'משושים עם שם', + icons: 'אסימוני מיקום', + glimpsed: 'משושים בהצצה', + pending: 'מיקומים ממתינים למילוי', + calibrated: 'מכויל', + overrides: 'עקיפות דף', + undo: 'ניתן לבטל', + }, + messages: { + filled: + 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', + revealed: 'נחשפו משושים: {count}.', + revealedPage: 'כל hex בדף נחשף ({count}).', + confirmReset: + 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', + resetPage: 'הקסים הוסרו מהדף: {count}.', + undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', + named: 'hexes בשם "{name}": {count}.', + unnamed: 'שמות נוקו: {count}.', + marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', + settingChanged: '{setting} מוגדר ל-{value}.', + rescanned: + 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + calibrated: + 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + calibrationReset: + 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', + migrated: + 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', + pruned: + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + readyHint: + 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', + someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + }, + errors: { + noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', + notHex: 'דף זה אינו משתמש ברשת משושה.', + noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', + tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', + nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', + noTokens: 'תחילה בחר אסימון אחד או יותר.', + noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + nothingToUndo: 'אין מילוי לבטל.', + unknownCommand: 'פקודה לא ידועה: {command}', + unknownSetting: 'הגדרה לא ידועה: {key}', + unknownPageSetting: 'הגדרות שניתן להגדיר לכל עמוד: {keys}', + invalidValue: '"{value}" אינו ערך חוקי עבור {key}.', + calibrateNeedsTokens: 'בחר אסימון אחד או שניים שהוצמדו למרכזי משושה.', + calibrateFailed: 'לא ניתן להשתמש באסימונים האלה לכיול.', + unexpected: 'משהו השתבש: {message}', + }, + hints: { + noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', + notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + noPolygons: + 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', + noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', + unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', + unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', + calibrateNeedsTokens: + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + calibrateFailed: + 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', + }, + help: { + menu: 'הצג את התפריט.', + fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', + undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', + revealPage: 'חשוף כל קסם בדף ללא הודעות.', + conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', + resetPage: 'הסר כל hex בדף (שואל תחילה).', + name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', + unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + set: 'שנה הגדרה או הצג את כל ההגדרות.', + pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', + pageClear: 'הסר את העקיפות של הדף הנוכחי.', + rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', + calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + calibrateReset: 'הסר את הכיול של הדף הנוכחי.', + status: 'הצג מה Hexploration יודע על הדף הנוכחי.', + journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', + help: 'הצג רשימה זו.', + handout: 'ההנחיות המלאות נמצאות בדף "{name}".', + }, + deck: { + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. ביטול מילוי מבטל את המילוי האחרון.', + revealDesc: + 'בחר משושים, צורות או אסימונים כדי לחשוף אותם או לכסות אותם שוב. חקירה חושפת את הסביבה של האסימונים הנבחרים כאילו הם זזו לשם.', + locationsDesc: + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר משושים או אסימונים כדי לתת שם למשושה.', + toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', + footer: 'עיין בדף "{help}" להנחיות מלאות.', + }, + handout: { + versionLabel: 'גִרְסָה', + subtitle: 'חקירה משושה אחר קסם עבור Roll20', + footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', + overview: { + heading: 'סקירה כללית', + body: 'Hexploration מכסה מפת משושים במשושים אטומים. כשהחבורה זזה, המשושים שהיא עוברת דרכם (ואם תרצו, גם המשושים שסביבה) מוסרים, כך שהמפה נחשפת משושה אחר משושה. אפשר להציב מיקומים מוסתרים מתחת למשושים, והם מוכרזים כשהם נמצאים. הכלי עובד במשחקי Jumpgate ו-Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + demo: 'צפו בהדגמה קצרה (מגרסה 1)', + }, + quickStart: { + heading: 'התחלה מהירה', + steps: [ + 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', + 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות במשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סימון מיקום. הם מוסתרים מתחת למשושים ומוכרזים כשהם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והמשושים שבתוך מרחק הראייה שלו, נחשפים.', + ], + }, + commands: { + heading: 'פקודות', + intro: + 'רק GMs יכולים להשתמש בפקודות אלה. רובם פועלים על האובייקטים שנבחרו; השאר פועלים בדף שבו אתה צופה.', + colCommand: 'פְּקוּדָה', + colDesc: 'מה זה עושה', + }, + revealing: { + heading: 'איך עובד גילוי', + points: [ + 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושים, מהקרוב ביותר תחילה. כשקו ראייה מופעל, משושה אינו נחשף כל עוד יש משושה מכוסה בינו לבין האסימון. משושים קרובים יותר נחשפים בדרך כלל ראשונים, ולכן בשטח פתוח קו ראייה אינו משנה דבר: יש לו השפעה רק עם מרחק ראייה של 2 ומעלה ומשושים שנשארים מכוסים, כמו שטח שמולא עם מרחק חשיפת משושים.', + 'מרחק חשיפת משושים נשמר על כל משושה בעת מילויו, לכן הגדר אותו לפני המילוי; שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות, ועם 0 הם נחשפים רק כשנכנסים אליהם. לרכס הרים: הגדר את מרחק חשיפת משושים ל-0, מלא את ההרים, החזר אותו ל"ללא", ואז מלא את השטח שמעבר להם. עם מרחק ראייה 3 וקו ראייה מופעל, החבורה רואה את השטח הפתוח סביבה, אך לא את ההרים או את מה שמאחוריהם. כל משושה הר נחשף כאשר אסימון נכנס אליו.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם. משושים במצב הצצה אינם חוסמים קו ראייה.', + 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', + 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', + ], + }, + locations: { + heading: 'בשם משושים ומיקומים', + points: [ + 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', + 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', + 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', + ], + }, + settings: { + heading: 'הגדרות', + intro: + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', + colKey: 'מַפְתֵחַ', + colName: 'סְבִיבָה', + colDesc: 'תֵאוּר', + perPage: '(ניתן להגדיר לכל עמוד.)', + }, + jumpgate: { + heading: 'Jumpgate ו-Legacy', + points: [ + 'Hexploration מזהה באיזה מנוע המשחק משתמש ומצייר את סוג הצורה המתאים. אפשר למלא צורות שצוירו בכל אחד משני העורכים.', + 'כששכבת המשושים מוגדרת לאוטומטי, משושים מצוירים בשכבת החזית, מעל האסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימונים במקום זאת.', + 'Jumpgate מצייר משושים משוכללים מתמטית, שצורתם שונה מעט ממשושי Legacy. אם המשושים אינם מתיישרים עם הרשת של הדף, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים במשושים שכנים באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', + 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', + ], + }, + upgrading: { + heading: 'משדרג מגרסה 1', + points: [ + 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', + 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', + 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', + ], + colV1: 'פקודה גרסה 1', + colV2: 'פקודה גרסה 2', + }, + troubleshooting: { + heading: 'פתרון בעיות', + points: [ + 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', + 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', + 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', + 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', + ], + }, + languages: { + heading: 'שפות', + body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + colLanguage: 'שָׂפָה', + colNative: 'שם בשפת המקור', + colCode: 'קוד', + }, + credits: { + heading: 'קרדיטים', + original: 'מוד מקורי מאת', + maintainer: 'גרסה 2 מתוחזקת על ידי', + marketplace: 'חבילות האמנות של עדה ב-Roll20 Marketplace', + support: + 'אם אתה מוצא באג או יש לך רעיון, פרסם בפורום Roll20 Mod או פתח בעיה ב-GitHub, וכלול הודעות כלשהן מיומן מסוף ה-API.', + }, + }, + }; + + const TRANSLATION$b = { + titles: { + ready: 'A Hexploration készen áll.', + settings: 'Hexploration-beállítások', + languages: 'Válasszon nyelvet', + pageSettings: 'Oldalbeállítások: {page}', + status: 'Hexploration-állapot: {page}', + help: 'Hexploration parancsok', + confirm: 'Kérjük, erősítse meg', + }, + discovery: { + title: 'Helyszín felfedezve', + }, + menu: { + draw: 'Rajzolás', + reveal: 'Felfedés és elrejtés', + locations: 'Helyszínek', + tools: 'Eszközök', + layerInUse: 'Az új hatszögek ide kerülnek: {layer}.', + pageSettingsHelp: + 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', + }, + buttons: { + fill: 'Kitöltés', + fillInverse: 'Inverz kitöltés', + undo: 'Kitöltés visszavonása', + reveal: 'Felfedés', + conceal: 'Lefedés', + explore: 'Felderítés', + revealPage: 'Oldal felfedése', + resetPage: 'Oldal visszaállítása', + mark: 'Helyszín megjelölése', + unmark: 'Jelölés törlése', + name: 'Hatszög elnevezése', + settings: 'Beállítások', + pageSettings: 'Oldalbeállítások', + status: 'Állapot', + rescan: 'Újraszkennelés', + calibrate: 'Kalibrálás', + calibrateReset: 'Kalibrálás visszaállítása', + help: 'Segítség', + change: 'Módosítás', + menu: 'Menü', + clearOverrides: 'Felülbírálások törlése', + confirmReset: 'Igen, minden hatszög eltávolítása', + }, + prompts: { + name: 'Helynév (a törléshez hagyja üresen)', + }, + values: { + on: 'Be', + off: 'Ki', + none: 'Nincs', + hexLayer: { + auto: 'Automatikus (előtér, ha elérhető)', + foreground: 'előtérréteg', + objects: 'tokenréteg', + }, + revealBy: { + players: 'Játékos tokenek', + characters: 'Karakter tokenek', + all: 'Minden token', + }, + revealMode: { + clear: 'Eltávolítás', + glimpse: 'Bepillantás', + }, + announce: { + all: 'Mindenki', + gm: 'Csak a GM', + off: 'Ki', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Kitöltés', + fillInverse: 'Inverz kitöltés', + conceal: 'Lefedés', + }, + }, + settings: { + language: { + label: 'Nyelv', + desc: 'A menük, üzenetek és tájékoztatók nyelve.', + }, + hexLayer: { + label: 'Hatszögek rétege', + desc: 'Hová kerülnek az új hatszögek. Az Automatikus az előtérréteggel próbálkozik (a tokenek fölött), és ha a játék ezt nem támogatja, a tokenréteget használja.', + }, + fillColor: { + label: 'Kitöltés színe', + desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Szegély színe', + desc: 'Az új hatszögek körvonalának színe.', + }, + labelColor: { + label: 'Címke színe', + desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + }, + glimpseColor: { + label: 'Bepillantás színe', + desc: 'Az a szín, amelyre a hatszögek bepillantáskor váltanak (Bepillantás felfedési mód). Használjon átlátszó rgba() színt.', + }, + strokeWidth: { + label: 'Szegély szélessége', + desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', + }, + maxDistance: { + label: 'Hatszögek felfedési távolsága', + desc: 'A hatszögek kitöltésekor kerül tárolásra rajtuk, ezért a kitöltés előtt állítsa be: a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is; 0 esetén csak akkor fedődnek fel, ha belépnek beléjük. Hegyekhez vagy erdőkhöz használja. Hagyja üresen, ha nem kíván korlátozást.', + }, + revealDistance: { + label: 'Látótávolság', + desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + }, + lineOfSight: { + label: 'Látóvonal', + desc: 'Ha be van kapcsolva, a fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött hegyek, eltakarják a mögöttük lévő hatszögeket. Csak akkor számít, ha a Látótávolság legalább 2.', + }, + revealPath: { + label: 'Felfedés az útvonal mentén', + desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + }, + revealBy: { + label: 'Felfedő tokenek', + desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + }, + revealMode: { + label: 'Felfedési mód', + desc: 'Az Eltávolítás mód eltávolítja a látótávolságon belüli hatszögeket. A Bepillantás mód ehelyett átlátszóvá teszi őket; akkor tűnnek el, amikor egy token belép beléjük.', + }, + announce: { + label: 'Felfedezések bejelentése', + desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', + }, + pingDiscoveries: { + label: 'Felfedezések pingelése', + desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', + }, + hideCoveredTokens: { + label: 'Lefedett tokenek elrejtése', + desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + }, + }, + status: { + engine: 'Játékmotor', + grid: 'Rács', + layer: 'Hatszögek rétege', + hexes: 'Hatszögek', + named: 'Elnevezett hatszögek', + icons: 'Helyszíntokenek', + glimpsed: 'Bepillantott hatszögek', + pending: 'Kitöltésre váró helyszínek', + calibrated: 'Kalibrálva', + overrides: 'Oldalszintű felülbírálások', + undo: 'Visszavonható', + }, + messages: { + filled: + 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', + revealed: 'Felfedezett hatszögek: {count}.', + revealedPage: 'Az oldalon minden hex látható ({count}).', + confirmReset: + 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + resetPage: 'Az oldalról eltávolított hatszögek: {count}.', + undone: + 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', + named: '"{name}" nevű hatszögek: {count}.', + unnamed: 'Törölt nevek: {count}.', + marked: + 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + unmarked: 'Tokenek, amelyek már nem helyek: {count}.', + settingChanged: '{setting} értéke {value}.', + rescanned: + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + calibrated: + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + calibrationReset: + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', + journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + migrated: + 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', + pruned: + 'Mentett hatszögek, amelyek már nem léteznek, és törlődtek a nyilvántartásból: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraszkennelést az oldalon, hogy újra felvegye a hatszögeit.', + readyHint: + 'A menühöz írja be a !hexploration parancsot, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + }, + warnings: { + foregroundUnavailable: + 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', + }, + errors: { + noPage: 'Nem található az oldal, amelyen dolgozni kellene.', + notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', + emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', + tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', + nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + nothingToReveal: + 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + noTokens: 'Először válasszon ki egy vagy több tokent.', + noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + nothingToUndo: 'Nincs visszavonható kitöltés.', + unknownCommand: 'Ismeretlen parancs: {command}', + unknownSetting: 'Ismeretlen beállítás: {key}', + unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', + invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', + calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', + unexpected: 'Hiba történt: {message}', + }, + hints: { + noPage: 'Nyissa meg azt az oldalt, amelyen dolgozni szeretne, vagy válasszon rajta valamit.', + notHex: 'Állítsa az oldalrácsot Hex (V) vagy Hex (H) értékre az Oldalbeállításokban.', + noPolygons: + 'Rajzoljon sokszöget, téglalapot, ellipszist vagy szabadkézi alakzatot a terület köré, jelölje ki, majd próbálkozzon újra.', + emptyArea: 'Rajzoljon nagyobb alakzatot, vagy ellenőrizze az oldalrács beállításait.', + tooMany: 'Töltsön ki egy kisebb területet, vagy ossza fel több formára.', + noHexes: + 'A hatszögek az előtérben vagy a token rétegben vannak; váltson át arra a rétegre a kijelölésükhöz.', + unknownCommand: 'Írja be a !hexploration help parancsot a parancsok listázásához.', + unknownSetting: 'Minden beállítás megtekintéséhez írja be a !hexploration set parancsot.', + calibrateNeedsTokens: + 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', + calibrateFailed: + 'A két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hex H) kell lennie, egymástól legalább egy hatszögnyire.', + unexpected: 'A részletek az API-konzol naplójában találhatók.', + }, + help: { + menu: 'Mutasd a menüt.', + fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', + undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', + reveal: + 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', + revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + conceal: + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', + resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', + name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', + unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', + set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', + pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', + pageClear: 'Távolítsa el az aktuális oldal felülírásait.', + rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', + calibrate: + 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', + status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', + journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', + help: 'Mutasd ezt a listát.', + handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', + }, + deck: { + drawDesc: + 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', + revealDesc: + 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', + locationsDesc: + 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + toolsDesc: + 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', + footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', + }, + handout: { + versionLabel: 'Változat', + subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', + overview: { + heading: 'Áttekintés', + body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + }, + quickStart: { + heading: 'Gyors kezdés', + steps: [ + 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', + 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', + 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', + 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', + ], + }, + commands: { + heading: 'Parancsok', + intro: + 'Csak a GM-ek használhatják ezeket a parancsokat. A legtöbb a kiválasztott objektumokra hat; a többi az éppen megtekintett oldalon működik.', + colCommand: 'Parancs', + colDesc: 'Mit csinál', + }, + revealing: { + heading: 'Hogyan működik a feltárás', + points: [ + 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel, a legközelebbiekkel kezdve. Ha a Látóvonal be van kapcsolva, egy hatszög nem fedődik fel, amíg közte és a token között lefedett hatszög van. A közelebbi hatszögek általában előbb fedődnek fel, így nyílt terepen a Látóvonal semmin sem változtat: csak akkor számít, ha a Látótávolság legalább 2, és vannak fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött terep.', + 'A Hatszögek felfedési távolsága minden hatszögön a kitöltésekor kerül tárolásra, ezért a kitöltés előtt állítsa be; a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is, 0 esetén pedig csak akkor fedődnek fel, ha belépnek beléjük. Hegyvonulathoz: állítsa a Hatszögek felfedési távolsága értékét 0-ra, töltse ki a hegyeket, állítsa vissza üresre (korlátozás nélkül), majd töltse ki a mögöttük lévő vidéket. Ha a Látótávolság 3 és a Látóvonal be van kapcsolva, a csapat látja a körülötte lévő nyílt terepet, de a hegyeket és azt, ami mögöttük van, nem. Minden hegyi hatszög akkor fedődik fel, amikor egy token belép bele.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és eltávolításra kerülnek, amikor egy token belép beléjük. A Bepillantás módban látott hatszögek a Látóvonal szempontjából nem számítanak takarásnak.', + 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', + 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', + ], + }, + locations: { + heading: 'Hexák és helyek neve', + points: [ + 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', + 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', + ], + }, + settings: { + heading: 'Beállítások elemre', + intro: + 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', + colKey: 'Kulcsfontosságú', + colName: 'Beállítás', + colDesc: 'Leírás', + perPage: '(Oldalonként beállítható.)', + }, + jumpgate: { + heading: 'Jumpgate és Legacy', + points: [ + 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', + 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', + ], + }, + upgrading: { + heading: 'Frissítés az 1-es verzióról', + points: [ + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', + 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', + ], + colV1: '1-es verzió parancs', + colV2: '2-es verzió parancs', + }, + troubleshooting: { + heading: 'Hibaelhárítás', + points: [ + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, megfelel-e a Felfedő tokenek beállításnak, és vannak-e hatszögek az oldalon (!hexploration status).', + 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', + 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', + 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', + 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + ], + }, + languages: { + heading: 'Nyelvek', + body: 'Nyelvet a !hexploration set language paranccsal választhat. Elérhető nyelvek:', + colLanguage: 'Nyelv', + colNative: 'Saját név', + colCode: 'Kód', + }, + credits: { + heading: 'Kredit', + original: 'Az eredeti mod szerzője', + maintainer: 'A 2-es verziót karbantartja', + marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', + support: + 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + }, + }, + }; + + const TRANSLATION$a = { + titles: { + ready: 'Hexploration è pronto.', + settings: 'Impostazioni di Hexploration', + languages: 'Scegli una lingua', + pageSettings: 'Impostazioni pagina: {page}', + status: 'Stato di Hexploration: {page}', + help: 'Comandi di Hexploration', + confirm: 'Conferma', + }, + discovery: { + title: 'Posizione scoperta', + }, + menu: { + draw: 'Disegna', + reveal: 'Rivela e nascondi', + locations: 'Posizioni', + tools: 'Strumenti', + layerInUse: 'I nuovi esagoni vengono disegnati sul {layer}.', + pageSettingsHelp: + 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', + }, + buttons: { + fill: 'Riempi', + fillInverse: 'Riempimento inverso', + undo: 'Annulla riempimento', + reveal: 'Rivela', + conceal: 'Nascondi', + explore: 'Esplora', + revealPage: 'Rivela pagina', + resetPage: 'Reimposta pagina', + mark: 'Segna posizione', + unmark: 'Rimuovi segno', + name: 'Nomina esagono', + settings: 'Impostazioni', + pageSettings: 'Impostazioni pagina', + status: 'Stato', + rescan: 'Nuova scansione', + calibrate: 'Calibra', + calibrateReset: 'Ripristina calibrazione', + help: 'Aiuto', + change: 'Modifica', + menu: 'Menu', + clearOverrides: 'Cancella sostituzioni', + confirmReset: 'Sì, rimuovi tutti gli esagoni', + }, + prompts: { + name: 'Nome della posizione (lascia vuoto per cancellare)', + }, + values: { + on: 'Attivo', + off: 'Disattivo', + none: 'Nessuno', + hexLayer: { + auto: 'Automatico (in primo piano se disponibile)', + foreground: 'livello in primo piano', + objects: 'livello dei segnalini', + }, + revealBy: { + players: 'Segnalini dei giocatori', + characters: 'Segnalini dei personaggi', + all: 'Tutti i segnalini', + }, + revealMode: { + clear: 'Elimina', + glimpse: 'Intravedi', + }, + announce: { + all: 'Tutti', + gm: 'Solo il GM', + off: 'Disattivo', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Riempi', + fillInverse: 'Riempimento inverso', + conceal: 'Nascondi', + }, + }, + settings: { + language: { + label: 'Lingua', + desc: 'Lingua per menu, messaggi e dispense.', + }, + hexLayer: { + label: 'Livello degli esagoni', + desc: 'Dove vengono disegnati i nuovi esagoni. Automatico prova il livello in primo piano (sopra i segnalini) e ripiega sul livello dei segnalini se il gioco non lo supporta.', + }, + fillColor: { + label: 'Colore riempimento', + desc: 'Colore dei nuovi esagoni. Usa rgba() per esagoni trasparenti, ad esempio rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Colore del bordo', + desc: 'Colore del contorno dei nuovi esagoni.', + }, + labelColor: { + label: "Colore dell'etichetta", + desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', + }, + glimpseColor: { + label: 'Colore degli esagoni intravisti', + desc: 'Colore che assumono gli esagoni intravisti (modalità di rivelazione Intravedi). Usa un colore rgba() trasparente.', + }, + strokeWidth: { + label: 'Larghezza del bordo', + desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', + }, + maxDistance: { + label: 'Distanza di rivelazione degli esagoni', + desc: 'Memorizzata sugli esagoni quando vengono riempiti, quindi impostala prima di riempire: modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere; con 0 vengono rivelati solo entrandoci. Usala per montagne o foreste. Lascia vuoto per nessun limite.', + }, + revealDistance: { + label: 'Distanza di vista', + desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', + }, + lineOfSight: { + label: 'Linea di vista', + desc: 'Quando è attivo, gli esagoni che restano coperti, come le montagne riempite con una Distanza di rivelazione degli esagoni, nascondono gli esagoni dietro di essi. Fa differenza solo con una Distanza di vista di 2 o più.', + }, + revealPath: { + label: 'Rivela lungo il percorso', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + }, + revealBy: { + label: 'Segnalini che rivelano', + desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + }, + revealMode: { + label: 'Modalità di rivelazione', + desc: 'Elimina rimuove gli esagoni in vista. Intravedi invece li rende trasparenti; vengono rimossi quando un segnalino vi entra.', + }, + announce: { + label: 'Annuncia le scoperte', + desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', + }, + pingDiscoveries: { + label: 'Ping sulle scoperte', + desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + }, + hideCoveredTokens: { + label: 'Nascondi i segnalini coperti', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + }, + }, + status: { + engine: 'Motore di gioco', + grid: 'Griglia', + layer: 'Livello degli esagoni', + hexes: 'Esagoni', + named: 'Esagoni con nome', + icons: 'Segnalini di posizione', + glimpsed: 'Esagoni intravisti', + pending: 'Posizioni in attesa di riempimento', + calibrated: 'Calibrato', + overrides: 'Sostituzioni di pagina', + undo: 'Annullamento disponibile', + }, + messages: { + filled: + 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + revealed: 'Esagoni rivelati: {count}.', + revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', + confirmReset: + 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + resetPage: 'Esagoni rimossi dalla pagina: {count}.', + undone: + 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', + named: 'Esagoni denominati "{name}": {count}.', + unnamed: 'Nomi cancellati: {count}.', + marked: + 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', + unmarked: 'Token che non rappresentano più posizioni: {count}.', + settingChanged: '{setting} impostato su {value}.', + rescanned: + 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + calibrated: + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + calibrationReset: + 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', + migrated: + 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', + pruned: + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Nuova scansione sulla pagina per riprenderne gli esagoni.', + readyHint: + 'Digita !hexploration per il menu, oppure apri la dispensa "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + someFailed: + 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', + }, + errors: { + noPage: 'Impossibile trovare la pagina su cui lavorare.', + notHex: 'Questa pagina non usa una griglia esagonale.', + noPolygons: 'Seleziona una o più forme disegnate da riempire.', + emptyArea: "L'area selezionata non contiene alcun centro di esagono.", + tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', + nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', + noTokens: 'Seleziona prima uno o più token.', + noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToUndo: "Non c'è nessun riempimento da annullare.", + unknownCommand: 'Comando sconosciuto: {command}', + unknownSetting: 'Impostazione sconosciuta: {key}', + unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', + invalidValue: '"{value}" non è un valore valido per {key}.', + calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', + calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + unexpected: 'Qualcosa è andato storto: {message}', + }, + hints: { + noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', + notHex: 'Imposta la griglia della pagina su Hex (V) o Hex (H) nelle Impostazioni pagina.', + noPolygons: + "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", + emptyArea: + 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', + tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", + noHexes: + 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + unknownCommand: 'Digita !hexploration help per elencare i comandi.', + unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', + calibrateNeedsTokens: + 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + calibrateFailed: + 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + unexpected: 'I dettagli si trovano nel registro della console API.', + }, + help: { + menu: 'Mostra il menù.', + fill: 'Copri le forme disegnate selezionate con esagoni.', + fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", + undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + reveal: + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', + conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", + explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', + unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + set: "Modifica un'impostazione o mostra tutte le impostazioni.", + pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageClear: 'Rimuovi le sostituzioni della pagina corrente.', + rescan: + "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + calibrate: + 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', + status: 'Mostra cosa sa Hexploration sulla pagina corrente.', + journal: 'Ricostruisci le dispense Help e Command Deck.', + help: 'Mostra questo elenco.', + handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + }, + deck: { + drawDesc: + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla riempimento annulla l'ultimo riempimento.", + revealDesc: + 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', + locationsDesc: + 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + toolsDesc: + 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', + footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + }, + handout: { + versionLabel: 'Versione', + subtitle: 'Esplorazione esagono per esagono per Roll20', + footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + overview: { + heading: 'Panoramica', + body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + demo: 'Guarda una breve demo (dalla versione 1)', + }, + quickStart: { + heading: 'Avvio rapido', + steps: [ + 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', + "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", + 'Seleziona le forme e fai clic su Riempi nel Command Deck (oppure digita !hexploration fill). Le forme vengono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i segnalini dei luoghi importanti e fai clic su Segna posizione. Vengono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un segnalino giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di vista, vengono rivelati.', + ], + }, + commands: { + heading: 'Comandi', + intro: + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + colCommand: 'Comando', + colDesc: 'Cosa fa', + }, + revealing: { + heading: 'Come funziona la rivelazione', + points: [ + 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', + "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', + 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', + "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", + ], + }, + locations: { + heading: 'Esagoni e posizioni con nome', + points: [ + 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', + "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", + 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", + ], + }, + settings: { + heading: 'Impostazioni', + intro: + 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', + colKey: 'Chiave', + colName: 'Collocamento', + colDesc: 'Descrizione', + perPage: '(Può essere impostato per pagina.)', + }, + jumpgate: { + heading: 'Jumpgate e Legacy', + points: [ + "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", + 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', + ], + }, + upgrading: { + heading: 'Aggiornamento dalla versione 1', + points: [ + 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', + 'Le mappe a esagoni, i nomi, i segnalini di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', + 'La versione 1 permetteva a qualsiasi segnalino che rappresentasse un personaggio di rivelare esagoni. Imposta Segnalini che rivelano su Segnalini dei personaggi per mantenere quel comportamento.', + ], + colV1: 'Comando della versione 1', + colV2: 'Comando della versione 2', + }, + troubleshooting: { + heading: 'Risoluzione dei problemi', + points: [ + 'Non succede nulla quando un segnalino si muove: controlla che il segnalino sia sul livello dei segnalini e corrisponda a Segnalini che rivelano, e che la pagina abbia esagoni (!hexploration status).', + 'Gli esagoni sono sfalsati rispetto alla griglia: usa Calibra, poi controlla con un segnalino su alcuni esagoni in vari punti della mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Nuova scansione sulla pagina.', + "Riempi indica che l'area non contiene centri di esagono: la forma deve contenere il centro di almeno un esagono.", + 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', + ], + }, + languages: { + heading: 'Lingue', + body: 'Scegli una lingua con !hexploration set language. Lingue disponibili:', + colLanguage: 'Lingua', + colNative: 'Nome originale', + colCode: 'Codice', + }, + credits: { + heading: 'Crediti', + original: 'Mod originale di', + maintainer: 'Versione 2 mantenuta da', + marketplace: 'I pacchetti artistici di Ada sul Marketplace Roll20', + support: + "Se trovi un bug o hai un'idea, pubblica un post nel forum Roll20 Mod o apri un problema su GitHub e includi eventuali messaggi dal registro della console API.", + }, + }, + }; + + const TRANSLATION$9 = { + titles: { + ready: 'Hexploration の準備ができました。', + settings: 'Hexploration 設定', + languages: '言語の選択', + pageSettings: 'ページ設定: {page}', + status: 'Hexploration ステータス: {page}', + help: 'Hexploration コマンド', + confirm: 'ご確認ください', + }, + discovery: { + title: '場所が発見されました', + }, + menu: { + draw: '描画', + reveal: '表示と非表示', + locations: '場所', + tools: 'ツール', + layerInUse: '新しいヘクスが {layer} に描画されています。', + pageSettingsHelp: + 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', + }, + buttons: { + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', + undo: '塗りつぶしを元に戻す', + reveal: '表示', + conceal: '隠す', + explore: '探索', + revealPage: 'ページを全表示', + resetPage: 'ページをリセット', + mark: '場所としてマーク', + unmark: 'マーク解除', + name: 'ヘクスに名前を付ける', + settings: '設定', + pageSettings: 'ページ設定', + status: 'ステータス', + rescan: '再スキャン', + calibrate: '調整', + calibrateReset: '調整をリセット', + help: 'ヘルプ', + change: '変更', + menu: 'メニュー', + clearOverrides: '上書きを解除', + confirmReset: 'はい、すべてのヘクスを削除', + }, + prompts: { + name: '場所の名前 (クリアするには空白のままにします)', + }, + values: { + on: 'オン', + off: 'オフ', + none: 'なし', + hexLayer: { + auto: '自動（可能なら前景レイヤー）', + foreground: '前景レイヤー', + objects: 'トークンレイヤー', + }, + revealBy: { + players: 'プレイヤートークン', + characters: 'キャラクタートークン', + all: 'すべてのトークン', + }, + revealMode: { + clear: '除去', + glimpse: '透過', + }, + announce: { + all: '全員', + gm: 'GMのみ', + off: 'オフ', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', + conceal: '隠す', + }, + }, + settings: { + language: { + label: '言語', + desc: 'メニュー、メッセージ、配布資料の言語。', + }, + hexLayer: { + label: 'ヘクスのレイヤー', + desc: '新しいヘクスを描画する場所。自動では前景レイヤー（トークンの上）を試し、ゲームが対応していない場合はトークンレイヤーを使用します。', + }, + fillColor: { + label: '塗りつぶしの色', + desc: '新しいヘクスの色。シースルー ヘクスには rgba() を使用します (例: rgba(0,0,0,0.8))。', + }, + strokeColor: { + label: '枠線の色', + desc: '新しいヘクスの輪郭の色。', + }, + labelColor: { + label: 'ラベルの色', + desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', + }, + glimpseColor: { + label: '透過色', + desc: '透過したときにヘクスが変わる色（表示モード「透過」）。半透明の rgba() カラーを使用してください。', + }, + strokeWidth: { + label: '枠線の幅', + desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', + }, + maxDistance: { + label: 'ヘクスの公開距離', + desc: 'ヘクスを塗りつぶすときにヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス以内にいる必要があります。0の場合、ヘクスに入ったときにのみ公開されます。山や森に使用します。制限を設けない場合は空のままにします。', + }, + revealDistance: { + label: '視界距離', + desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + }, + lineOfSight: { + label: '視線', + desc: 'オンの場合、「ヘクスの公開距離」を設定して塗りつぶした山など、覆われたままのヘクスが、その背後のヘクスを隠します。「視界距離」が2以上の場合にのみ違いが出ます。', + }, + revealPath: { + label: '経路に沿って表示', + desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', + }, + revealBy: { + label: '公開するトークン', + desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + }, + revealMode: { + label: '公開モード', + desc: '除去は視界内のヘクスを取り除きます。透過は代わりにヘクスを半透明にし、トークンが入ると取り除きます。', + }, + announce: { + label: '発見を通知', + desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', + }, + pingDiscoveries: { + label: '発見地点をピン', + desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + }, + hideCoveredTokens: { + label: '覆われたトークンを隠す', + desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', + }, + }, + status: { + engine: 'ゲームエンジン', + grid: 'グリッド', + layer: 'ヘクスレイヤー', + hexes: 'ヘクス', + named: '名前付きヘクス', + icons: '場所トークン', + glimpsed: '透過中のヘクス', + pending: '塗りつぶし待ちの場所', + calibrated: '調整済み', + overrides: 'ページの上書き', + undo: '元に戻せる操作', + }, + messages: { + filled: + '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + revealed: '明らかになったヘクス: {count}。', + revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', + confirmReset: + '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + resetPage: 'ページから削除されたヘクス: {count}。', + undone: + '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', + named: '「{name}」という名前のヘクス: {count}。', + unnamed: '削除された名前: {count}。', + marked: + '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + unmarked: '場所ではなくなったトークン: {count}。', + settingChanged: '{setting} を {value} に設定します。', + rescanned: + '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + calibrated: + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + calibrationReset: + 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', + migrated: + 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + pruned: + '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', + readyHint: + 'メニューを開くには !hexploration と入力するか、配布資料 "Hexploration - Command Deck" を開きます。', + }, + warnings: { + foregroundUnavailable: + 'このゲームは前景レイヤーでの描画をサポートしていないため、ヘクスはトークン レイヤーに描画されました。', + someFailed: + '描画できなかったヘクス: {count}。詳細については API コンソールを確認してください。', + }, + errors: { + noPage: '作業するページが見つかりませんでした。', + notHex: 'このページはヘクスグリッドを使用していません。', + noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', + emptyArea: '選択した領域には六角中心が含まれていません。', + tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', + nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', + nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', + noTokens: '最初に 1 つ以上のトークンを選択します。', + noHexes: '最初に 1 つ以上のヘクス (またはヘクス上にあるトークン) を選択します。', + nothingToUndo: '元に戻す塗りつぶしはありません。', + unknownCommand: '不明なコマンド: {command}', + unknownSetting: '不明な設定: {key}', + unknownPageSetting: 'ページごとに設定できる設定: {keys}', + invalidValue: '「{value}」は、{key} の有効な値ではありません。', + calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateFailed: 'これらのトークンは調整には使用できません。', + unexpected: '問題が発生しました: {message}', + }, + hints: { + noPage: '作業したいページを開くか、ページ上で何かを選択します。', + notHex: 'ページ設定でページのグリッドを Hex (V) または Hex (H) に設定してください。', + noPolygons: + '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', + emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', + tooMany: 'より小さい領域を塗りつぶすか、領域をいくつかの形状に分割します。', + noHexes: 'ヘクスは前景またはトークン層にあります。そのレイヤーに切り替えて選択します。', + unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', + unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', + calibrateNeedsTokens: + 'トークンをヘクスの中心にスナップして選択します。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにスナップした 2 つ目のトークンも選択すると、ヘクスのサイズも補正されます。', + calibrateFailed: + '2 つのトークンは同じ行 (Hex V) または同じ列 (Hex H) にあり、少なくとも 1 ヘクス離れている必要があります。', + unexpected: '詳細は API コンソールのログに記載されています。', + }, + help: { + menu: 'メニューを表示します。', + fill: '選択した描画形状を六角形で覆います。', + fillInverse: '選択した図形の内側を除いてページ全体を覆います。', + undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', + revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', + conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', + resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', + name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', + mark: '選択したトークンを非表示の場所に変更します。', + unmark: '選択したトークンが非表示の場所になるのを停止します。', + set: '設定を変更するか、すべての設定を表示します。', + pageSet: '現在のページでのみ公開設定をオーバーライドします。', + pageClear: '現在のページのオーバーライドを削除します。', + rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', + calibrate: + '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + calibrateReset: '現在のページの調整を削除します。', + status: '現在のページについて Hexploration が知っていることを表示します。', + journal: 'ヘルプと Command Deck の配布資料を再構築します。', + help: 'このリストを表示します。', + handout: '完全な手順は配布資料「{name}」に記載されています。', + }, + deck: { + drawDesc: + '領域の周囲に図形を描き、選択して塗りつぶします。「塗りつぶしを元に戻す」で最後の塗りつぶしを取り消せます。', + revealDesc: + 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', + locationsDesc: + 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + toolsDesc: + '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', + footer: '完全な手順については、配布資料「{help}」を参照してください。', + }, + handout: { + versionLabel: 'バージョン', + subtitle: 'Roll20 のヘクスごとの探索', + footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', + overview: { + heading: '概要', + body: 'Hexploration は、ヘクスマップを不透明なヘクスで覆います。パーティが移動すると、通過したヘクス（必要に応じてその周囲のヘクスも）が取り除かれ、マップが 1 ヘクスずつ明らかになります。隠し場所をヘクスの下に配置でき、見つかるとアナウンスされます。Jumpgate と Legacy の両方のゲームで、任意のサイズの Hex (V) および Hex (H) グリッドで動作します。', + demo: '短いデモを見る (バージョン 1 から)', + }, + quickStart: { + heading: 'クイックスタート', + steps: [ + 'グリッドが Hex (V) または Hex (H) に設定されたページを開きます。', + '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', + '図形を選択し、Command Deck の「塗りつぶし」をクリックします（または !hexploration fill と入力します）。図形がヘクスに置き換わります。', + '任意: 塗りつぶす前に、重要な場所のトークンを選択して「場所としてマーク」をクリックします。それらはヘクスの下に隠され、発見されるとアナウンスされます。', + 'プレイヤートークンを移動します。通過したすべてのヘクスと、その視界距離内のヘクスが表示されます。', + ], + }, + commands: { + heading: 'コマンド', + intro: + 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', + colCommand: '指示', + colDesc: '何をするのか', + }, + revealing: { + heading: '暴露の仕組み', + points: [ + 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', + 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを近い順に公開します。「視線」がオンの場合、ヘクスとトークンの間に覆われたヘクスがある間は、そのヘクスは公開されません。通常は近いヘクスから先に公開されるため、開けた土地では「視線」は何も変えません。意味を持つのは、「視界距離」が2以上で、「ヘクスの公開距離」を設定して塗りつぶした地形など、覆われたままのヘクスがある場合だけです。', + '「ヘクスの公開距離」は、ヘクスを塗りつぶすときに各ヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはその数のヘクス以内にいる必要があり、0の場合はヘクスに入ったときにのみ公開されます。山脈の場合：「ヘクスの公開距離」を0に設定して山を塗りつぶし、設定をなしに戻してから、その先の土地を塗りつぶします。「視界距離」を3にして「視線」をオンにすると、パーティーは周囲の開けた土地は見えますが、山やその背後にあるものは見えません。各山岳ヘクスは、トークンがその中に入ったときに公開されます。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。透過状態のヘクスは「視線」を遮りません。', + 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', + 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', + ], + }, + locations: { + heading: '名前付きヘクスと場所', + points: [ + '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', + 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', + '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', + ], + }, + settings: { + heading: '設定', + intro: + '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', + colKey: '鍵', + colName: '設定', + colDesc: '説明', + perPage: '（ページごとに設定可能）', + }, + jumpgate: { + heading: 'Jumpgate と Legacy', + points: [ + 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', + '「ヘクスのレイヤー」が「自動」の場合、ヘクスは前景レイヤー（トークンの上）に描画されるため、プレイヤーはその下にあるものを見ることができません。前景レイヤーが使用できない場合は、代わりにトークンレイヤーが使用されます。', + 'Jumpgate は数学的に正確な正六角形のヘクスを描画するため、Legacy のヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃わない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにある 2 つのトークンを選択すると、ヘクスのサイズも補正されます。', + 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', + ], + }, + upgrading: { + heading: 'バージョン1からのアップグレード', + points: [ + 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', + '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', + 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', + ], + colV1: 'バージョン1のコマンド', + colV2: 'バージョン 2 コマンド', + }, + troubleshooting: { + heading: 'トラブルシューティング', + points: [ + 'トークンを動かしても何も起こらない: トークンがトークンレイヤー上にあり「公開するトークン」の設定に合っていること、ページにヘクスがあること（!hexploration status）を確認してください。', + 'ヘクスがグリッドからずれている: 「調整」を使い、マップ上のいくつかのヘクスにトークンを置いて確認してください。', + 'ページまたはゲームをコピーした後、ヘクスが表示されなくなりました。ページで再スキャンを実行してください。', + '「塗りつぶし」で領域にヘクスの中心がないと表示される: 図形には少なくとも 1 つのヘクスの中心が含まれている必要があります。', + 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', + ], + }, + languages: { + heading: '言語', + body: '!hexploration set language で言語を選択します。利用可能な言語:', + colLanguage: '言語', + colNative: '現地語での名称', + colCode: 'コード', + }, + credits: { + heading: 'クレジット', + original: 'オリジナル版の作者', + maintainer: 'バージョン 2 の保守者', + marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', + support: + 'バグを見つけた場合やアイデアがある場合は、Roll20 Mod フォーラムに投稿するか、GitHub で問題を開いて、API コンソール ログからのメッセージを含めてください。', + }, + }, + }; + + const TRANSLATION$8 = { + titles: { + ready: 'Hexploration이 준비되었습니다.', + settings: 'Hexploration 설정', + languages: '언어 선택', + pageSettings: '페이지 설정: {page}', + status: 'Hexploration 상태: {page}', + help: 'Hexploration 명령어', + confirm: '확인해주세요', + }, + discovery: { + title: '위치 발견', + }, + menu: { + draw: '그리기', + reveal: '공개 및 숨기기', + locations: '위치', + tools: '도구', + layerInUse: '{layer}에 새로운 헥스가 그려지고 있습니다.', + pageSettingsHelp: + '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', + }, + buttons: { + fill: '채우기', + fillInverse: '반전 채우기', + undo: '채우기 취소', + reveal: '공개', + conceal: '숨기기', + explore: '탐색', + revealPage: '페이지 전체 공개', + resetPage: '페이지 초기화', + mark: '위치 표시', + unmark: '표시 해제', + name: '헥스 이름 지정', + settings: '설정', + pageSettings: '페이지 설정', + status: '상태', + rescan: '다시 스캔', + calibrate: '보정', + calibrateReset: '보정 초기화', + help: '도움말', + change: '변경', + menu: '메뉴', + clearOverrides: '재정의 지우기', + confirmReset: '예, 모든 헥스 제거', + }, + prompts: { + name: '위치 이름(지우려면 비워 두세요)', + }, + values: { + on: '켜짐', + off: '꺼짐', + none: '없음', + hexLayer: { + auto: '자동(사용 가능한 경우 전경)', + foreground: '전경 레이어', + objects: '토큰 레이어', + }, + revealBy: { + players: '플레이어 토큰', + characters: '캐릭터 토큰', + all: '모든 토큰', + }, + revealMode: { + clear: '제거', + glimpse: '반투명', + }, + announce: { + all: '모두', + gm: 'GM 전용', + off: '꺼짐', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '채우기', + fillInverse: '반전 채우기', + conceal: '숨기기', + }, + }, + settings: { + language: { + label: '언어', + desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', + }, + hexLayer: { + label: '헥스 레이어', + desc: '새 헥스를 그릴 위치입니다. 자동은 전경 레이어(토큰 위)를 먼저 시도하고, 게임이 지원하지 않으면 토큰 레이어를 사용합니다.', + }, + fillColor: { + label: '채우기 색상', + desc: '새 헥스의 색상입니다. 비쳐 보이는 헥스를 원하면 rgba()를 사용하세요(예: rgba(0,0,0,0.8)).', + }, + strokeColor: { + label: '테두리 색상', + desc: '새로운 육각형의 윤곽선 색상입니다.', + }, + labelColor: { + label: '라벨 색상', + desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + }, + glimpseColor: { + label: '반투명 색상', + desc: '반투명 상태가 된 헥스의 색상입니다(반투명 공개 모드). 비쳐 보이는 rgba() 색상을 사용하세요.', + }, + strokeWidth: { + label: '테두리 너비', + desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', + }, + maxDistance: { + label: '헥스 공개 거리', + desc: '헥스를 채울 때 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 이 헥스 수 이내에 있어야 합니다. 0이면 헥스에 들어가야만 공개됩니다. 산이나 숲에 사용하세요. 제한이 없으면 비워 두세요.', + }, + revealDistance: { + label: '시야 거리', + desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + }, + lineOfSight: { + label: '시선', + desc: '켜져 있으면, 헥스 공개 거리로 채운 산처럼 계속 덮여 있는 헥스가 그 뒤의 헥스를 가립니다. 시야 거리가 2 이상일 때만 차이가 있습니다.', + }, + revealPath: { + label: '경로를 따라 표시', + desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', + }, + revealBy: { + label: '공개하는 토큰', + desc: '토큰 레이어의 어떤 토큰이 헥스를 공개할지 정합니다: 플레이어가 조종하는 토큰, 캐릭터를 나타내는 토큰 또는 모든 토큰.', + }, + revealMode: { + label: '공개 모드', + desc: '제거는 시야 안의 헥스를 없앱니다. 반투명은 대신 헥스를 비쳐 보이게 하며, 토큰이 들어가면 제거합니다.', + }, + announce: { + label: '발견 알림', + desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', + }, + pingDiscoveries: { + label: '발견 위치 핑', + desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', + }, + hideCoveredTokens: { + label: '덮인 토큰 숨기기', + desc: 'Roll20은 이름, 막대, 오라를 헥스 위에 그립니다. 켜져 있으면 덮인 헥스 아래에 있는 토큰의 플레이어에게 보이는 이름, 막대, 오라를 끄고, 덮개가 벗겨지면 다시 켭니다.', + }, + }, + status: { + engine: '게임 엔진', + grid: '그리드', + layer: '헥스 레이어', + hexes: '헥스', + named: '명명된 헥스', + icons: '위치 토큰', + glimpsed: '반투명 헥스', + pending: '채우기를 기다리는 위치', + calibrated: '보정됨', + overrides: '페이지 재정의', + undo: '실행 취소 가능', + }, + messages: { + filled: + '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', + revealed: '공개된 헥스: {count}.', + revealedPage: '페이지의 모든 헥스를 공개했습니다({count}).', + confirmReset: + '"{page}"의 모든 헥스({count})를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 이 작업은 실행 취소로 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거한 헥스: {count}.', + undone: + '마지막 채우기를 취소했습니다. 제거한 헥스: {removed}. 원래 스타일로 복원한 헥스: {restored}.', + named: '"{name}"이라는 헥스: {count}.', + unnamed: '지워진 이름: {count}.', + marked: + '기존 헥스 아래에 숨긴 위치: {attached}. 이 위치를 덮을 다음 채우기를 기다리는 위치: {pending}.', + unmarked: '더 이상 위치가 아닌 토큰: {count}.', + settingChanged: '{setting}이(가) {value}로 설정되었습니다.', + rescanned: + '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + calibrated: + '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + calibrationReset: + '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', + migrated: + 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', + pruned: + '더 이상 존재하지 않아 잊어버린 저장된 헥스: {dropped}. 이 게임이나 페이지를 복사했다면 해당 페이지에서 다시 스캔을 실행해 헥스를 다시 인식시키세요.', + readyHint: + '메뉴를 보려면 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 여세요.', + }, + warnings: { + foregroundUnavailable: + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', + someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + }, + errors: { + noPage: '작업할 페이지를 찾을 수 없습니다.', + notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', + emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', + tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', + nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', + nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + noTokens: '먼저 하나 이상의 토큰을 선택하세요.', + noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', + nothingToUndo: '실행 취소할 채우기가 없습니다.', + unknownCommand: '알 수 없는 명령: {command}', + unknownSetting: '알 수 없는 설정: {key}', + unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', + invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', + calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', + unexpected: '문제가 발생했습니다: {message}', + }, + hints: { + noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', + notHex: '페이지 설정에서 페이지 격자를 Hex (V) 또는 Hex (H)로 설정하세요.', + noPolygons: + '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', + emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', + tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', + noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', + calibrateNeedsTokens: + '토큰 하나를 헥스 중심에 스냅한 뒤 선택하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 스냅한 두 번째 토큰도 선택하면 헥스 크기까지 보정합니다.', + calibrateFailed: + '두 토큰은 같은 행(Hex V) 또는 같은 열(Hex H)에 있어야 하며, 적어도 헥스 한 칸 이상 떨어져 있어야 합니다.', + unexpected: '세부정보는 API 콘솔 로그에 있습니다.', + }, + help: { + menu: '메뉴를 보여주세요.', + fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', + undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', + reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', + explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', + resetPage: '페이지의 모든 헥스를 제거합니다(먼저 확인합니다).', + name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', + mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', + unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', + set: '설정을 변경하거나 모든 설정을 표시합니다.', + pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', + pageClear: '현재 페이지의 재정의를 제거합니다.', + rescan: + '페이지의 헥스 목록을 다시 만듭니다. 예를 들어 페이지나 게임을 복사한 뒤에 사용합니다.', + calibrate: '헥스 중심에 스냅된 토큰 한두 개를 선택해 헥스 격자를 맞춥니다.', + calibrateReset: '현재 페이지의 보정을 제거합니다.', + status: '현재 페이지에 대해 Hexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 Command Deck 유인물을 다시 만듭니다.', + help: '이 목록을 보여주세요.', + handout: '전체 지침은 "{name}" 유인물에 있습니다.', + }, + deck: { + drawDesc: + '영역 주위에 도형을 그리고 선택한 다음 채웁니다. 채우기 취소는 마지막 채우기를 되돌립니다.', + revealDesc: + '헥스, 도형 또는 토큰을 선택해 공개하거나 다시 덮습니다. 탐색은 선택한 토큰이 그곳으로 막 이동한 것처럼 주변을 공개합니다.', + locationsDesc: + '토큰을 선택해 헥스 아래의 위치로 숨기세요. 헥스나 토큰을 선택해 헥스에 이름을 붙이세요.', + toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', + footer: '전체 지침은 "{help}" 유인물을 참조하세요.', + }, + handout: { + versionLabel: '버전', + subtitle: 'Roll20용 헥스 단위 탐험', + footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', + overview: { + heading: '개요', + body: 'Hexploration은 헥스 지도를 불투명한 헥스로 덮습니다. 파티가 이동하면 지나간 헥스(원하면 주변 헥스도)가 제거되어 지도가 한 헥스씩 드러납니다. 숨겨진 위치를 헥스 아래에 둘 수 있으며, 발견되면 알려줍니다. Jumpgate와 Legacy 게임 모두에서, 모든 크기의 Hex (V) 및 Hex (H) 그리드에서 작동합니다.', + demo: '짧은 데모 보기(버전 1부터)', + }, + quickStart: { + heading: '빠른 시작', + steps: [ + '격자가 Hex (V) 또는 Hex (H)로 설정된 페이지를 엽니다.', + '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !hexploration fill 입력). 모양이 헥스로 바뀝니다.', + '선택 사항: 채우기 전에 중요한 장소의 토큰을 선택하고 위치 표시를 클릭하세요. 토큰은 헥스 아래에 숨겨지고 발견되면 알려집니다.', + '플레이어 토큰을 움직입니다. 토큰이 지나가는 모든 헥스와 시야 거리 안의 헥스가 공개됩니다.', + ], + }, + commands: { + heading: '명령', + intro: + 'GM만이 이 명령을 사용할 수 있습니다. 대부분은 선택한 개체에 작용합니다. 나머지는 현재 보고 있는 페이지에서 수행됩니다.', + colCommand: '명령', + colDesc: '기능', + }, + revealing: { + heading: '공개 작동 방식', + points: [ + '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', + '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', + '시야 거리는 그 각 헥스 주변의 헥스를 가까운 것부터 공개합니다. 시선이 켜져 있으면, 헥스와 토큰 사이에 덮인 헥스가 있는 동안에는 그 헥스가 공개되지 않습니다. 보통 가까운 헥스가 먼저 공개되므로 탁 트인 지형에서는 시선이 아무것도 바꾸지 않습니다. 시야 거리가 2 이상이고, 헥스 공개 거리로 채운 지형처럼 계속 덮여 있는 헥스가 있을 때만 의미가 있습니다.', + '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', + 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + ], + }, + locations: { + heading: '명명된 육각형 및 위치', + points: [ + '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', + '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', + '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', + ], + }, + settings: { + heading: '설정', + intro: + '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', + colKey: '열쇠', + colName: '환경', + colDesc: '설명', + perPage: '(페이지별로 설정 가능합니다.)', + }, + jumpgate: { + heading: 'Jumpgate와 Legacy', + points: [ + 'Hexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 어느 편집기에서 그린 도형이든 채울 수 있습니다.', + '헥스 레이어를 자동으로 설정하면 헥스가 토큰 위의 전경 레이어에 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없으면 대신 토큰 레이어를 사용합니다.', + 'Jumpgate는 수학적으로 정확한 정육각형 헥스를 그리므로 Legacy 헥스와 모양이 약간 다릅니다. 헥스가 페이지 격자와 맞지 않으면 토큰 하나를 헥스 중심에 스냅하고 선택한 뒤 보정을 클릭하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 있는 토큰 두 개를 선택하면 헥스 크기까지 보정합니다.', + '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', + ], + }, + upgrading: { + heading: '버전 1에서 업그레이드', + points: [ + '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', + '기존 헥스 지도, 이름, 위치 토큰과 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Hexploration_menu 매크로를 포함한 버전 1 명령은 여전히 작동합니다.', + '버전 1에서는 캐릭터를 나타내는 토큰이면 무엇이든 헥스를 공개할 수 있었습니다. 이 동작을 유지하려면 공개하는 토큰을 캐릭터 토큰으로 설정하세요.', + ], + colV1: '버전 1 명령', + colV2: '버전 2 명령', + }, + troubleshooting: { + heading: '문제 해결', + points: [ + '토큰을 움직여도 아무 일도 일어나지 않음: 토큰이 토큰 레이어에 있고 공개하는 토큰 설정과 일치하는지, 페이지에 헥스가 있는지(!hexploration status) 확인하세요.', + '헥스가 격자에서 어긋남: 보정을 사용한 다음, 지도 곳곳의 몇몇 헥스에 토큰을 놓아 확인하세요.', + '페이지나 게임을 복사한 뒤 헥스가 더 이상 공개되지 않음: 해당 페이지에서 다시 스캔을 실행하세요.', + '채우기에서 영역에 헥스 중심이 없다고 나옴: 모양 안에 적어도 헥스 하나의 중심이 들어 있어야 합니다.', + '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', + ], + }, + languages: { + heading: '언어', + body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', + colLanguage: '언어', + colNative: '현지어 이름', + colCode: '암호', + }, + credits: { + heading: '크레딧', + original: '원본 모드 제작자', + maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', + marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', + support: + '버그를 발견하거나 아이디어가 있는 경우 Roll20 Mod 포럼에 게시하거나 GitHub에서 문제를 열고 API 콘솔 로그의 메시지를 포함하세요.', + }, + }, + }; + + const TRANSLATION$7 = { + titles: { + ready: 'Hexploration jest gotowy.', + settings: 'Ustawienia Hexploration', + languages: 'Wybierz język', + pageSettings: 'Ustawienia strony: {page}', + status: 'Stan Hexploration: {page}', + help: 'Polecenia Hexploration', + confirm: 'Proszę potwierdzić', + }, + discovery: { + title: 'Odkryto lokalizację', + }, + menu: { + draw: 'Rysowanie', + reveal: 'Odkrywanie i ukrywanie', + locations: 'Lokalizacje', + tools: 'Narzędzia', + layerInUse: 'Warstwa, na której rysowane są nowe heksy: {layer}.', + pageSettingsHelp: + 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', + }, + buttons: { + fill: 'Wypełnij', + fillInverse: 'Odwrotne wypełnienie', + undo: 'Cofnij wypełnienie', + reveal: 'Odkryj', + conceal: 'Zakryj', + explore: 'Eksploruj', + revealPage: 'Odkryj stronę', + resetPage: 'Zresetuj stronę', + mark: 'Oznacz lokalizację', + unmark: 'Usuń oznaczenie', + name: 'Nazwij heks', + settings: 'Ustawienia', + pageSettings: 'Ustawienia strony', + status: 'Status', + rescan: 'Skanuj ponownie', + calibrate: 'Kalibruj', + calibrateReset: 'Zresetuj kalibrację', + help: 'Pomoc', + change: 'Zmień', + menu: 'Menu', + clearOverrides: 'Usuń nadpisania', + confirmReset: 'Tak, usuń wszystkie heksy', + }, + prompts: { + name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', + }, + values: { + on: 'Włączone', + off: 'Wyłączone', + none: 'Brak', + hexLayer: { + auto: 'Auto (pierwszy plan, jeśli jest dostępny)', + foreground: 'warstwa pierwszego planu', + objects: 'warstwa żetonów', + }, + revealBy: { + players: 'Żetony graczy', + characters: 'Żetony postaci', + all: 'Wszystkie żetony', + }, + revealMode: { + clear: 'Usuwanie', + glimpse: 'Przebłysk', + }, + announce: { + all: 'Wszyscy', + gm: 'Tylko MG', + off: 'Wyłączone', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Wypełnij', + fillInverse: 'Odwrotne wypełnienie', + conceal: 'Zakryj', + }, + }, + settings: { + language: { + label: 'Język', + desc: 'Język menu, komunikatów i materiałów informacyjnych.', + }, + hexLayer: { + label: 'Warstwa heksagonów', + desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', + }, + fillColor: { + label: 'Kolor wypełnienia', + desc: 'Kolor nowych heksów. Użyj rgba() dla przezroczystych heksów, na przykład rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kolor obramowania', + desc: 'Kolor konturu nowych heksów.', + }, + labelColor: { + label: 'Kolor etykiety', + desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + }, + glimpseColor: { + label: 'Kolor przebłysku', + desc: 'Kolor, jaki przyjmują heksy objęte przebłyskiem (tryb odkrywania Przebłysk). Użyj przezroczystego koloru rgba().', + }, + strokeWidth: { + label: 'Szerokość obramowania', + desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', + }, + maxDistance: { + label: 'Odległość odkrywania heksagonów', + desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', + }, + revealDistance: { + label: 'Zasięg wzroku', + desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', + }, + lineOfSight: { + label: 'Linia wzroku', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', + }, + revealPath: { + label: 'Odkrywaj wzdłuż ścieżki', + desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + }, + revealBy: { + label: 'Żetony odkrywające', + desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', + }, + revealMode: { + label: 'Tryb odkrywania', + desc: 'Usuwanie usuwa heksy w zasięgu wzroku. Przebłysk zamiast tego czyni je przezroczystymi; są usuwane, gdy wejdzie na nie żeton.', + }, + announce: { + label: 'Ogłaszaj odkrycia', + desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', + }, + pingDiscoveries: { + label: 'Pinguj odkrycia', + desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', + }, + hideCoveredTokens: { + label: 'Ukrywaj zakryte żetony', + desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', + }, + }, + status: { + engine: 'Silnik gry', + grid: 'Siatka', + layer: 'Warstwa heksagonów', + hexes: 'Heksy', + named: 'Nazwane heksy', + icons: 'Żetony lokalizacji', + glimpsed: 'Heksy w przebłysku', + pending: 'Lokalizacje czekające na wypełnienie', + calibrated: 'Skalibrowano', + overrides: 'Nadpisania strony', + undo: 'Można cofnąć', + }, + messages: { + filled: + 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + revealed: 'Ujawnione heksy: {count}.', + revealedPage: 'Każdy odkryty heks na stronie ({count}).', + confirmReset: + 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', + resetPage: 'Heksy usunięte ze strony: {count}.', + undone: + 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + named: 'Heksy o nazwie „{name}”: {count}.', + unnamed: 'Nazwy zostały usunięte: {count}.', + marked: + 'Lokalizacje ukryte na istniejących heksach: {attached}. Czekam na następne wypełnienie, które je obejmuje: {pending}.', + unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', + settingChanged: '{setting} ustawiony na {value}.', + rescanned: + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + calibrated: + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + calibrationReset: + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', + migrated: + 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', + pruned: + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom „Skanuj ponownie” na stronie, aby ponownie odnaleźć jej heksy.', + readyHint: + 'Wpisz !hexploration, aby otworzyć menu, lub otwórz materiał informacyjny "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ta gra nie obsługuje rysowania na warstwie pierwszego planu, więc heksy zostały narysowane na warstwie żetonów.', + someFailed: + 'Heksy, których nie można narysować: {count}. Aby uzyskać szczegółowe informacje, sprawdź konsolę API.', + }, + errors: { + noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', + notHex: 'Ta strona nie używa siatki heksowej.', + noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', + emptyArea: 'Zaznaczony obszar nie zawiera żadnych środków heksów.', + tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', + nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', + nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', + noTokens: 'Najpierw wybierz jeden lub więcej tokenów.', + noHexes: 'Najpierw wybierz jeden lub więcej heksów (lub żetonów stojących na heksach).', + nothingToUndo: 'Nie ma wypełnienia, które można cofnąć.', + unknownCommand: 'Nieznane polecenie: {command}', + unknownSetting: 'Nieznane ustawienie: {key}', + unknownPageSetting: 'Ustawienia, które można ustawić na stronie: {keys}', + invalidValue: '„{value}” nie jest prawidłową wartością dla {key}.', + calibrateNeedsTokens: 'Wybierz jeden lub dwa żetony przyciągnięte do środków heksów.', + calibrateFailed: 'Tych tokenów nie można używać do kalibracji.', + unexpected: 'Coś poszło nie tak: {message}', + }, + hints: { + noPage: 'Otwórz stronę, nad którą chcesz pracować, lub wybierz coś na niej.', + notHex: 'Ustaw siatkę strony na Hex (V) lub Hex (H) w Ustawieniach strony.', + noPolygons: + 'Narysuj wielokąt, prostokąt, elipsę lub odręczny kształt wokół obszaru, zaznacz go i spróbuj ponownie.', + emptyArea: 'Narysuj większy kształt lub sprawdź ustawienia siatki strony.', + tooMany: 'Wypełnij mniejszy obszar lub podziel obszar na kilka kształtów.', + noHexes: + 'Heksy znajdują się na pierwszym planie lub w warstwie żetonów; przejdź do tej warstwy, aby je wybrać.', + unknownCommand: 'Wpisz !hexploration help, aby wyświetlić listę poleceń.', + unknownSetting: 'Wpisz !hexploration set, aby zobaczyć wszystkie ustawienia.', + calibrateNeedsTokens: + 'Przyciągnij żeton do środka heksa i wybierz go. Wybierz drugi żeton przyciągnięty do sąsiedniego heksu w tym samym rzędzie (Hex V) lub kolumnie (Hex H), aby również skorygować rozmiar heksa.', + calibrateFailed: + 'Dwa żetony muszą znajdować się w tym samym rzędzie (Hex V) lub w tej samej kolumnie (Hex H), w odległości co najmniej jednego heksa od siebie.', + unexpected: 'Szczegóły znajdują się w dzienniku konsoli API.', + }, + help: { + menu: 'Pokaż menu.', + fill: 'Zakryj wybrane narysowane kształty heksami.', + fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', + undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', + revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', + conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', + explore: 'Odsłoń wokół wybranych żetonów tak, jakby właśnie się tam przesunęły.', + resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', + name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', + mark: 'Zamień wybrane żetony w ukryte lokalizacje.', + unmark: 'Spraw, by zaznaczone żetony przestały być ukrytymi lokalizacjami.', + set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', + pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', + pageClear: 'Usuń zastąpienia bieżącej strony.', + rescan: 'Odbuduj listę heksów strony, na przykład po skopiowaniu strony lub gry.', + calibrate: + 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', + calibrateReset: 'Usuń kalibrację bieżącej strony.', + status: 'Pokaż, co Hexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne „Pomoc” i „Command Deck”.', + help: 'Pokaż tę listę.', + handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', + }, + deck: { + drawDesc: + 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', + revealDesc: + 'Zaznacz heksy, kształty lub żetony, aby je odkryć lub ponownie zakryć. „Eksploruj” odkrywa okolicę zaznaczonych żetonów, jakby właśnie się przesunęły.', + locationsDesc: + 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', + toolsDesc: + 'Ustawienia, nadpisania stron, status, ponowne skanowanie skopiowanych stron i kalibracja siatki.', + footer: 'Pełne instrukcje znajdziesz w ulotce „{help}”.', + }, + handout: { + versionLabel: 'Wersja', + subtitle: 'Eksploracja heks po heksie dla Roll20', + footer: + 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + overview: { + heading: 'Przegląd', + body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (od wersji 1)', + }, + quickStart: { + heading: 'Szybki start', + steps: [ + 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', + 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', + 'Zaznacz kształty i kliknij „Wypełnij” w Command Deck (lub wpisz !hexploration fill). Kształty zostaną zastąpione heksami.', + 'Opcjonalnie: przed wypełnieniem zaznacz żetony ważnych miejsc i kliknij „Oznacz lokalizację”. Zostaną ukryte pod heksami i ogłoszone po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przejdzie, oraz heksy w jego zasięgu wzroku (ustawienie „Zasięg wzroku”) zostaną odkryte.', + ], + }, + commands: { + heading: 'Polecenia', + intro: + 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', + colCommand: 'Polecenie', + colDesc: 'Co to robi', + }, + revealing: { + heading: 'Jak działa odkrywanie', + points: [ + 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', + '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', + 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', + 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', + ], + }, + locations: { + heading: 'Nazwane heksy i lokalizacje', + points: [ + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', + ], + }, + settings: { + heading: 'Ustawienia', + intro: + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + colKey: 'Klucz', + colName: 'Ustawienie', + colDesc: 'Opis', + perPage: '(Można ustawić na stronę.)', + }, + jumpgate: { + heading: 'Jumpgate i Dziedzictwo', + points: [ + 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', + 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', + ], + }, + upgrading: { + heading: 'Aktualizacja z wersji 1', + points: [ + 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', + 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', + 'Polecenia wersji 1, w tym makro Hexploration_menu, nadal działają.', + 'W wersji 1 heksy mógł odkrywać każdy żeton reprezentujący postać. Aby zachować to zachowanie, ustaw „Żetony odkrywające” na „Żetony postaci”.', + ], + colV1: 'Polecenie wersji 1', + colV2: 'Polecenie wersji 2', + }, + troubleshooting: { + heading: 'Rozwiązywanie problemów', + points: [ + 'Nic się nie dzieje, gdy żeton się porusza: sprawdź, czy żeton jest na warstwie żetonów i pasuje do ustawienia „Żetony odkrywające” oraz czy strona ma heksy (!hexploration status).', + 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', + 'Heksy przestały się odkrywać po skopiowaniu strony lub gry: uruchom „Skanuj ponownie” na stronie.', + '„Wypełnij” zgłasza, że obszar nie zawiera środków heksów: kształt musi zawierać środek co najmniej jednego heksu.', + 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', + ], + }, + languages: { + heading: 'Języki', + body: 'Wybierz język poleceniem !hexploration set language. Dostępne języki:', + colLanguage: 'Język', + colNative: 'Nazwa rodzima', + colCode: 'Kod', + }, + credits: { + heading: 'Kredyty', + original: 'Oryginalny mod autorstwa', + maintainer: 'Wersja 2 obsługiwana przez', + marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', + support: + 'Jeśli znajdziesz błąd lub masz pomysł, opublikuj post na forum Roll20 Mod lub otwórz problem w GitHub i dołącz wszelkie komunikaty z dziennika konsoli API.', + }, + }, + }; + + const TRANSLATION$6 = { + titles: { + ready: 'O Hexploration está pronto.', + settings: 'Definições do Hexploration', + languages: 'Escolha um idioma', + pageSettings: 'Definições da página: {page}', + status: 'Estado do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Local descoberto', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Os novos hexágonos estão a ser desenhados na {layer}.', + pageSettingsHelp: + 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar local', + unmark: 'Desmarcar', + name: 'Nomear hexágono', + settings: 'Definições', + pageSettings: 'Definições da página', + status: 'Estado', + rescan: 'Reanalisar', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Alterar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixar em branco para limpar)', + }, + values: { + on: 'Ligado', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de fichas', + }, + revealBy: { + players: 'Fichas de jogador', + characters: 'Fichas de personagem', + all: 'Todas as fichas', + }, + revealMode: { + clear: 'Limpar', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Toda a gente', + gm: 'Apenas o GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada dos hexágonos', + desc: 'Onde são desenhados os novos hexágonos. Automático tenta a camada de primeiro plano (acima das fichas) e recorre à camada de fichas se o jogo não a suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Utilize rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Utilize uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação dos hexágonos', + desc: 'Guardada nos hexágonos quando são preenchidos, por isso defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, este número de hexágonos para os revelar, por mais longe que consiga ver; com 0, só são revelados quando se entra neles. Utilize-a para montanhas ou florestas. Deixe em branco para não haver limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, os hexágonos que continuam cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos que estão por trás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', + }, + revealPath: { + label: 'Revelar ao longo do percurso', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + }, + revealBy: { + label: 'Fichas que revelam', + desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. Vislumbre torna-os transparentes; são removidos quando uma ficha entra neles.', + }, + announce: { + label: 'Anunciar descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Pingar descobertas', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar fichas cobertas', + desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grelha', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos nomeados', + icons: 'Fichas de local', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Locais a aguardar preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições da página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', + unmarked: 'Tokens que já não são locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + calibrated: + 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', + pruned: + 'Hexágonos guardados que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute Reanalisar na página para recuperar os seus hexágonos.', + readyHint: + 'Escreva !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não utiliza uma grelha hexagonal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', + tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione primeiro um ou mais tokens.', + noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', + nothingToUndo: 'Não há enchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', + calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + unexpected: 'Algo correu mal: {message}', + }, + hints: { + noPage: 'Abra a página na qual pretende trabalhar ou selecione algo da mesma.', + notHex: 'Defina a grelha da página para Hex (V) ou Hex (H) nas Definições da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre à volta da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', + tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + unknownCommand: 'Introduza !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as definições.', + calibrateNeedsTokens: + 'Encaixe uma ficha no centro de um hexágono e selecione-a. Selecione uma segunda ficha encaixada num hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + calibrateFailed: + 'As duas fichas têm de estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', + unexpected: 'Os detalhes estão no log da consola da API.', + }, + help: { + menu: 'Mostre o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: + 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma definição ou mostre todas as definições.', + pageSet: 'Substituir uma configuração de revelação apenas na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', + calibrate: + 'Alinhe a grelha hexagonal com uma ou duas fichas selecionadas encaixadas em centros de hexágonos.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + drawDesc: + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para os revelar ou voltar a cobrir. Explorar revela à volta das fichas selecionadas como se se tivessem movido.', + locationsDesc: + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', + toolsDesc: + 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + footer: 'Consulte o folheto "{help}" para obter as instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexágono a hexágono para Roll20', + footer: 'Utilize o folheto "{deck}" para controlos de um clique.', + overview: { + heading: 'Visão geral', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se desloca, os hexágonos por onde passa (e, se quiser, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Podem ser colocados locais escondidos sob os hexágonos, que são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', + 'Selecione as formas e clique em Preencher no Command Deck (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione fichas de locais importantes e clique em Marcar local. Ficam escondidas sob os hexágonos e são anunciadas quando descobertas.', + 'Mova uma ficha de jogador. Cada hexágono por onde passa e os hexágonos dentro da sua Distância de visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Apenas os GMs podem usar estes comandos. A maioria atua sobre os objetos selecionados; o resto atua na página que está a visualizar.', + colCommand: 'Comando', + colDesc: 'O que faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', + 'A Distância de visão revela os hexágonos em torno de cada um destes hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto existir um hexágono coberto entre ele e a ficha. Os hexágonos mais próximos são normalmente revelados primeiro, por isso em terreno aberto a Linha de visão não altera nada: só tem importância com uma Distância de visão de 2 ou mais e hexágonos que continuam cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é guardada em cada hexágono quando este é preenchido, por isso defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, esse número de hexágonos para os revelar, por mais longe que consiga ver, e com 0 só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e depois preencha as terras mais além. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto à sua volta, mas não as montanhas nem o que está por trás delas. Cada hexágono de montanha é revelado quando uma ficha entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', + 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', + 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as definições com !hexploration set (ou com o botão Definições). Camada dos hexágonos, Fichas que revelam e Idioma também podem ser definidos na página de definições do Mod.', + colKey: 'Chave', + colName: 'Definição', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com uma forma ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não ficarem alinhados com a grelha da página, encaixe uma ficha no centro de um hexágono, selecione-a e clique em Calibrar. Selecione duas fichas em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Reanalisar na página para os voltar a apanhar, juntamente com as suas etiquetas de nome e fichas de local.', + ], + }, + upgrading: { + heading: 'Atualização da versão 1', + points: [ + 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', + 'Os mapas de hexágonos, nomes, fichas de localização e definições existentes são atualizados automaticamente no primeiro arranque.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer ficha que representasse uma personagem revelasse hexágonos. Defina Fichas que revelam como Fichas de personagem para manter este comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando uma ficha se move: verifique se a ficha está na camada de fichas e corresponde a Fichas que revelam, e se a página tem hexágonos (!hexploration status).', + 'Os hexágonos estão desalinhados com a grelha: use Calibrar e verifique depois com uma ficha em alguns hexágonos do mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute Reanalisar na página.', + 'Preencher indica que a área não tem centros de hexágonos: a forma tem de conter o centro de pelo menos um hexágono.', + 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Idioma', + colNative: 'Nome original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versão 2 mantida pela', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', + }, + }, + }; + + const TRANSLATION$5 = { + titles: { + ready: 'O Hexploration está pronto.', + settings: 'Configurações do Hexploration', + languages: 'Escolha um idioma', + pageSettings: 'Configurações da página: {page}', + status: 'Status do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Local descoberto', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão sendo desenhados na {layer}.', + pageSettingsHelp: + 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar local', + unmark: 'Desmarcar', + name: 'Nomear hexágono', + settings: 'Configurações', + pageSettings: 'Configurações da página', + status: 'Status', + rescan: 'Reescanear', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Alterar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixe em branco para limpar)', + }, + values: { + on: 'Ligado', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de tokens', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Tokens de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Limpar', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Todos', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada dos hexágonos', + desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Use rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor do rótulo', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Use uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação dos hexágonos', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, os hexágonos que permanecem cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos atrás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', + }, + revealPath: { + label: 'Revelar ao longo do caminho', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. Vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + }, + announce: { + label: 'Anunciar descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Pingar descobertas', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras acima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm seu nome, barras e auras visíveis ao jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grade', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos nomeados', + icons: 'Tokens de local', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Locais aguardando preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições da página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos chamados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + unmarked: 'Tokens que não são mais locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + calibrated: + 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', + pruned: + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute Reescanear na página para recuperar seus hexágonos.', + readyHint: + 'Digite !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não usa uma grade hexagonal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', + tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione um ou mais tokens primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + nothingToUndo: 'Não há preenchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', + calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + unexpected: 'Algo deu errado: {message}', + }, + hints: { + noPage: 'Abra a página na qual deseja trabalhar ou selecione algo nela.', + notHex: 'Defina a grade da página como Hex (V) ou Hex (H) nas Configurações da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre ao redor da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', + tooMany: 'Preencha uma área menor ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + unknownCommand: 'Digite !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as configurações.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token encaixado em um hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + calibrateFailed: + 'Os dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', + unexpected: 'Os detalhes estão no log do console da API.', + }, + help: { + menu: 'Mostrar o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: + 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta antes).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma configuração ou mostre todas as configurações.', + pageSet: 'Substituir uma configuração de revelação somente na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', + calibrate: + 'Alinhe a grade hexagonal com um ou dois tokens selecionados encaixados em centros de hexágonos.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + drawDesc: + 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou tokens para revelá-los ou cobri-los novamente. Explorar revela ao redor dos tokens selecionados como se eles tivessem se movido.', + locationsDesc: + 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + footer: 'Consulte o folheto "{help}" para obter instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexágono a hexágono para Roll20', + footer: 'Use o folheto "{deck}" para controles de um clique.', + overview: { + heading: 'Visão geral', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais ele passa (e, se você quiser, os hexágonos ao redor) são removidos, de modo que o mapa é descoberto um hexágono por vez. Locais ocultos podem ser colocados sob os hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', + 'Selecione as formas e clique em Preencher no Command Deck (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar local. Eles ficam ocultos sob os hexágonos e são anunciados quando descobertos.', + 'Mova um token de jogador. Cada hexágono pelo qual ele passa e os hexágonos dentro da sua Distância de visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Somente GMs podem usar esses comandos. A maioria atua nos objetos selecionados; o resto atua na página que você está visualizando.', + colCommand: 'Comando', + colDesc: 'O que isso faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', + 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', + 'A Distância de visão revela os hexágonos em torno de cada um desses hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto houver um hexágono coberto entre ele e o token. Os hexágonos mais próximos costumam ser revelados primeiro, então em terreno aberto a Linha de visão não muda nada: ela só importa com uma Distância de visão de 2 ou mais e hexágonos que permanecem cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é gravada em cada hexágono quando ele é preenchido, então defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo essa quantidade de hexágonos para revelá-los, por mais longe que consiga ver, e com 0 eles só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e então preencha as terras mais adiante. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto ao seu redor, mas não as montanhas nem o que há atrás delas. Cada hexágono de montanha é revelado quando um token entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', + 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', + 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', + 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as configurações com !hexploration set (ou com o botão Configurações). Camada dos hexágonos, Tokens que revelam e Idioma também podem ser definidos na página de configurações do Mod.', + colKey: 'Chave', + colName: 'Configuração', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com um formato ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não se alinharem com a grade da página, encaixe um token no centro de um hexágono, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Reescanear na página para recuperá-los, junto com seus rótulos de nome e tokens de local.', + ], + }, + upgrading: { + heading: 'Atualizando da versão 1', + points: [ + 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', + 'Os mapas de hexágonos, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que revelam como Tokens de personagem para manter esse comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', + 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', + 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', + 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Linguagem', + colNative: 'Nome original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original por', + maintainer: 'Versão 2 mantida por', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se você encontrar um bug ou tiver uma ideia, poste no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do log do console da API.', + }, + }, + }; + + const TRANSLATION$4 = { + titles: { + ready: 'Hexploration готова.', + settings: 'Настройки Hexploration', + languages: 'Выберите язык', + pageSettings: 'Настройки страницы: {page}', + status: 'Статус Hexploration: {page}', + help: 'Команды Hexploration', + confirm: 'Пожалуйста, подтвердите', + }, + discovery: { + title: 'Локация обнаружена', + }, + menu: { + draw: 'Рисование', + reveal: 'Раскрытие и скрытие', + locations: 'Локации', + tools: 'Инструменты', + layerInUse: 'Новые гексы рисуются на этом слое: {layer}.', + pageSettingsHelp: + 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', + }, + buttons: { + fill: 'Заполнить', + fillInverse: 'Обратная заливка', + undo: 'Отменить заливку', + reveal: 'Раскрыть', + conceal: 'Скрыть', + explore: 'Исследовать', + revealPage: 'Раскрыть страницу', + resetPage: 'Сбросить страницу', + mark: 'Отметить локацию', + unmark: 'Снять отметку', + name: 'Назвать гекс', + settings: 'Настройки', + pageSettings: 'Настройки страницы', + status: 'Статус', + rescan: 'Пересканировать', + calibrate: 'Калибровать', + calibrateReset: 'Сбросить калибровку', + help: 'Справка', + change: 'Изменить', + menu: 'Меню', + clearOverrides: 'Сбросить переопределения', + confirmReset: 'Да, удалить все гексы', + }, + prompts: { + name: 'Название местоположения (оставьте пустым, чтобы очистить)', + }, + values: { + on: 'Вкл.', + off: 'Выкл.', + none: 'Нет', + hexLayer: { + auto: 'Авто (передний план, если доступен)', + foreground: 'слой переднего плана', + objects: 'слой токенов', + }, + revealBy: { + players: 'Токены игроков', + characters: 'Токены персонажей', + all: 'Все токены', + }, + revealMode: { + clear: 'Очистка', + glimpse: 'Проблеск', + }, + announce: { + all: 'Все', + gm: 'Только ГМ', + off: 'Выкл.', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заливка', + fillInverse: 'Обратная заливка', + conceal: 'Скрытие', + }, + }, + settings: { + language: { + label: 'Язык', + desc: 'Язык меню, сообщений и раздаточных материалов.', + }, + hexLayer: { + label: 'Слой шестиугольников', + desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', + }, + fillColor: { + label: 'Цвет заливки', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Цвет границы', + desc: 'Цвет контура новых гексов.', + }, + labelColor: { + label: 'Цвет меток', + desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + }, + glimpseColor: { + label: 'Цвет проблеска', + desc: 'Цвет, который принимают гексы в режиме «Проблеск». Используйте полупрозрачный цвет rgba().', + }, + strokeWidth: { + label: 'Ширина границы', + desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + }, + maxDistance: { + label: 'Дальность раскрытия шестиугольников', + desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', + }, + revealDistance: { + label: 'Расстояние обзора', + desc: 'Сколько гексов вокруг движущегося жетона обнаружено (от 0 до 20). 0 показывает только те гексы, через которые проходит фишка.', + }, + lineOfSight: { + label: 'Линия видимости', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', + }, + revealPath: { + label: 'Раскрывать вдоль пути', + desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', + }, + revealBy: { + label: 'Раскрывающие токены', + desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', + }, + revealMode: { + label: 'Режим раскрытия', + desc: '«Очистка» удаляет гексы в пределах видимости. «Проблеск» вместо этого делает их полупрозрачными; они удаляются, когда в них входит токен.', + }, + announce: { + label: 'Объявлять об открытиях', + desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', + }, + pingDiscoveries: { + label: 'Пинговать находки', + desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + }, + hideCoveredTokens: { + label: 'Скрывать токены под гексами', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + }, + }, + status: { + engine: 'Игровой движок', + grid: 'Сетка', + layer: 'Слой гексов', + hexes: 'Гексы', + named: 'Именованные гексы', + icons: 'Токены локаций', + glimpsed: 'Гексы в проблеске', + pending: 'Локации, ожидающие заливки', + calibrated: 'Откалибровано', + overrides: 'Переопределения страницы', + undo: 'Доступна отмена', + }, + messages: { + filled: + 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', + revealed: 'Обнаружены гексы: {count}.', + revealedPage: 'Все гексы на странице открыты ({count}).', + confirmReset: + 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', + resetPage: 'Со страницы удалены шестигранники: {count}.', + undone: + 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Шестигранники с именем "{name}": {count}.', + unnamed: 'Имена удалены: {count}.', + marked: + 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', + unmarked: 'Токены, которые больше не являются локациями: {count}.', + settingChanged: 'Для {setting} установлено значение {value}.', + rescanned: + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + calibrated: + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + calibrationReset: + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', + migrated: + 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', + pruned: + 'Забыты сохранённые гексы, которых больше нет: {dropped}. Если эта игра или страница была скопирована, выполните «Пересканировать» на странице, чтобы снова найти её гексы.', + readyHint: + 'Введите !hexploration, чтобы открыть меню, или откройте раздаточный материал "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + someFailed: + 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', + }, + errors: { + noPage: 'Не удалось найти страницу для работы.', + notHex: 'На этой странице не используется шестигранная сетка.', + noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', + emptyArea: 'Выбранная область не содержит шестигранных центров.', + tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', + nothingToReveal: + 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + noTokens: 'Сначала выберите один или несколько жетонов.', + noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', + nothingToUndo: 'Нет заливки, которую можно было бы отменить.', + unknownCommand: 'Неизвестная команда: {command}', + unknownSetting: 'Неизвестная настройка: {key}.', + unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', + invalidValue: '«{value}» не является допустимым значением для {key}.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', + unexpected: 'Что-то пошло не так: {message}', + }, + hints: { + noPage: 'Откройте страницу, над которой хотите работать, или выберите что-нибудь на ней.', + notHex: 'Установите сетку страницы на Hex (V) или Hex (H) в настройках страницы.', + noPolygons: + 'Нарисуйте многоугольник, прямоугольник, эллипс или фигуру от руки вокруг области, выберите ее и повторите попытку.', + emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', + tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', + noHexes: + 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', + unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', + calibrateNeedsTokens: + 'Привяжите токен к центру гекса и выделите его. Чтобы заодно исправить размер гекса, выделите второй токен, привязанный к соседнему гексу в той же строке (Hex V) или в том же столбце (Hex H).', + calibrateFailed: + 'Два токена должны находиться в одной строке (Hex V) или в одном столбце (Hex H) на расстоянии не менее одного гекса друг от друга.', + unexpected: 'Подробности в журнале консоли API.', + }, + help: { + menu: 'Покажите меню.', + fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', + undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', + revealPage: 'Раскройте каждый гекс на странице без объявлений.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', + explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', + name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', + mark: 'Превратите выбранные жетоны в скрытые локации.', + unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', + set: 'Измените настройку или отобразите все настройки.', + pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageClear: 'Удалить переопределения текущей страницы.', + rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', + calibrate: + 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + calibrateReset: 'Удалить калибровку текущей страницы.', + status: 'Покажите, что Hexploration знает о текущей странице.', + journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', + help: 'Покажите этот список.', + handout: 'Полные инструкции приведены в раздаточном материале «{name}».', + }, + deck: { + drawDesc: + 'Обведите область фигурами, выделите их и нажмите «Заполнить». «Отменить заливку» отменяет последнюю заливку.', + revealDesc: + 'Выделите гексы, фигуры или токены, чтобы раскрыть их или снова скрыть. «Исследовать» раскрывает гексы вокруг выбранных токенов, как если бы они туда переместились.', + locationsDesc: + 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', + toolsDesc: + 'Настройки, переопределение страниц, статус, повторное сканирование скопированных страниц и калибровка сетки.', + footer: 'Подробные инструкции см. в раздаточном материале «{help}».', + }, + handout: { + versionLabel: 'Версия', + subtitle: 'Исследование гекс за гексом для Roll20', + footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', + overview: { + heading: 'Обзор', + body: 'Hexploration закрывает гексовую карту непрозрачными гексами. По мере продвижения группы гексы, через которые она проходит (и, при желании, гексы вокруг них), удаляются, так что карта открывается гекс за гексом. Под гексами можно разместить скрытые локации — при обнаружении о них будет объявлено. Работает в играх Jumpgate и Legacy, на сетках Hex (V) и Hex (H) любого размера.', + demo: 'Посмотрите короткую демонстрацию (из версии 1)', + }, + quickStart: { + heading: 'Быстрый старт', + steps: [ + 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', + 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', + 'Выделите фигуры и нажмите «Заполнить» в Command Deck (или введите !hexploration fill). Фигуры заменятся гексами.', + 'Необязательно: перед заливкой выделите токены важных мест и нажмите «Отметить локацию». Они будут спрятаны под гексами, а при обнаружении о них будет объявлено.', + 'Переместите токен игрока. Каждый гекс, через который он проходит, и гексы в пределах его «Расстояния обзора» раскрываются.', + ], + }, + commands: { + heading: 'Команды', + intro: + 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + colCommand: 'Команда', + colDesc: 'Что он делает', + }, + revealing: { + heading: 'Как работает выявление', + points: [ + 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', + 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', + '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', + 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', + 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', + ], + }, + locations: { + heading: 'Именованные гексы и локации', + points: [ + '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', + 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', + 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', + ], + }, + settings: { + heading: 'Настройки', + intro: + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', + colKey: 'Ключ', + colName: 'Параметр', + colDesc: 'Описание', + perPage: '(Можно установить для каждой страницы.)', + }, + jumpgate: { + heading: 'Джампгейт и Наследие', + points: [ + 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', + 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', + 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', + ], + }, + upgrading: { + heading: 'Обновление с версии 1', + points: [ + 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', + 'Существующие гексовые карты, имена, токены локаций и настройки обновляются автоматически при первом запуске.', + 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', + 'В версии 1 гексы мог раскрывать любой токен, представляющий персонажа. Чтобы сохранить такое поведение, установите для «Раскрывающие токены» значение «Токены персонажей».', + ], + colV1: 'Команда версии 1', + colV2: 'Команда версии 2', + }, + troubleshooting: { + heading: 'Поиск неисправностей', + points: [ + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токенов и подходит под настройку «Раскрывающие токены», а на странице есть гексы (!hexploration status).', + 'Гексы смещены относительно сетки: нажмите «Калибровать», затем проверьте токеном несколько гексов в разных частях карты.', + 'Гексы перестали раскрываться после копирования страницы или игры: выполните «Пересканировать» на странице.', + '«Заполнить» сообщает, что в области нет центров гексов: фигура должна содержать центр хотя бы одного гекса.', + 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', + ], + }, + languages: { + heading: 'Языки', + body: 'Выберите язык командой !hexploration set language. Доступные языки:', + colLanguage: 'Язык', + colNative: 'Самоназвание', + colCode: 'Код', + }, + credits: { + heading: 'Кредиты', + original: 'Оригинальный мод от', + maintainer: 'Версия 2 поддерживается', + marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', + support: + 'Если вы обнаружили ошибку или у вас есть идея, напишите сообщение на форуме Roll20 Mod или откройте проблему на GitHub и включите все сообщения из журнала консоли API.', + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: 'Hexploration está listo.', + settings: 'Configuración de Hexploration', + languages: 'Elige un idioma', + pageSettings: 'Configuración de página: {page}', + status: 'Estado de Hexploration: {page}', + help: 'Comandos de Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Ubicación descubierta', + }, + menu: { + draw: 'Dibujar', + reveal: 'Revelar y ocultar', + locations: 'Ubicaciones', + tools: 'Herramientas', + layerInUse: 'Se están dibujando nuevos hexágonos en la {layer}.', + pageSettingsHelp: + 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', + }, + buttons: { + fill: 'Rellenar', + fillInverse: 'Relleno inverso', + undo: 'Deshacer relleno', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Restablecer página', + mark: 'Marcar ubicación', + unmark: 'Desmarcar', + name: 'Nombrar hexágono', + settings: 'Configuración', + pageSettings: 'Configuración de página', + status: 'Estado', + rescan: 'Volver a escanear', + calibrate: 'Calibrar', + calibrateReset: 'Restablecer calibración', + help: 'Ayuda', + change: 'Cambiar', + menu: 'Menú', + clearOverrides: 'Borrar anulaciones', + confirmReset: 'Sí, eliminar todos los hexágonos', + }, + prompts: { + name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', + }, + values: { + on: 'Activado', + off: 'Desactivado', + none: 'Ninguno', + hexLayer: { + auto: 'Auto (primer plano si está disponible)', + foreground: 'capa de primer plano', + objects: 'capa de fichas', + }, + revealBy: { + players: 'Fichas de jugador', + characters: 'Fichas de personaje', + all: 'Todas las fichas', + }, + revealMode: { + clear: 'Despejar', + glimpse: 'Vistazo', + }, + announce: { + all: 'Todos', + gm: 'Solo el DJ', + off: 'Desactivado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Rellenar', + fillInverse: 'Relleno inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menús, mensajes y folletos.', + }, + hexLayer: { + label: 'Capa de hexágonos', + desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', + }, + fillColor: { + label: 'Color de relleno', + desc: 'Color de nuevos hexágonos. Utilice rgba() para hexágonos transparentes, por ejemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color del borde', + desc: 'Color del contorno de nuevos hexágonos.', + }, + labelColor: { + label: 'Color de la etiqueta', + desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + }, + glimpseColor: { + label: 'Color de vistazo', + desc: 'Color que toman los hexágonos al vislumbrarse (modo de revelación Vistazo). Use un color rgba() transparente.', + }, + strokeWidth: { + label: 'Ancho del borde', + desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', + }, + maxDistance: { + label: 'Distancia de revelación de hexágonos', + desc: 'Se guarda en los hexágonos cuando se rellenan, así que configúrelo antes de rellenar: cambiarlo después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esta cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver; con 0, sólo se revelan al entrar en ellos. Úselo para montañas o bosques. Déjelo vacío para no tener límite.', + }, + revealDistance: { + label: 'Distancia de visión', + desc: 'Cuántos hexágonos se revelan alrededor de una ficha en movimiento (0 a 20). 0 revela sólo los hexágonos por los que pasa la ficha.', + }, + lineOfSight: { + label: 'Línea de visión', + desc: 'Cuando está activado, los hexágonos que siguen cubiertos, como las montañas rellenadas con una Distancia de revelación de hexágonos, ocultan los hexágonos que hay detrás de ellos. Sólo tiene efecto con una Distancia de visión de 2 o más.', + }, + revealPath: { + label: 'Revelar a lo largo del camino', + desc: 'Cuando está activado, se revela cada hexágono por el que pasa una ficha mientras es arrastrada (incluidos los puntos de ruta), no solo dónde se detiene.', + }, + revealBy: { + label: 'Fichas que revelan', + desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', + }, + revealMode: { + label: 'Modo de revelación', + desc: 'Despejar elimina los hexágonos a la vista. Vistazo, en cambio, los vuelve transparentes; se eliminan cuando una ficha entra en ellos.', + }, + announce: { + label: 'Anunciar descubrimientos', + desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', + }, + pingDiscoveries: { + label: 'Hacer ping a los descubrimientos', + desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', + }, + hideCoveredTokens: { + label: 'Ocultar fichas cubiertas', + desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + }, + }, + status: { + engine: 'Motor de juego', + grid: 'Cuadrícula', + layer: 'Capa de hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos con nombre', + icons: 'Fichas de ubicación', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Ubicaciones pendientes de relleno', + calibrated: 'Calibrado', + overrides: 'Anulaciones de página', + undo: 'Deshacer disponible', + }, + messages: { + filled: + 'Relleno completado. Hexágonos dibujados: {created}. Con nuevo estilo: {restyled}. Ubicaciones ocultas: {icons}.', + revealed: 'Hexágonos revelados: {count}.', + revealedPage: 'Cada hexágono en la página revelado ({count}).', + confirmReset: + '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', + resetPage: 'Hexes eliminados de la página: {count}.', + undone: + 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nombres borrados: {count}.', + marked: + 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', + unmarked: 'Tokens que ya no son ubicaciones: {count}.', + settingChanged: '{setting} establecido en {value}.', + rescanned: + 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + calibrated: + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + calibrationReset: + 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', + migrated: + 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', + pruned: + 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', + readyHint: + 'Escriba !hexploration para ver el menú o abra el folleto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este juego no admite dibujar en la capa de primer plano, por lo que los hexágonos se dibujaron en la capa de fichas.', + someFailed: + 'Hexágonos que no se pudieron dibujar: {count}. Consulte la consola API para obtener más detalles.', + }, + errors: { + noPage: 'No se pudo encontrar la página para trabajar.', + notHex: 'Esta página no utiliza una cuadrícula hexagonal.', + noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', + emptyArea: 'El área seleccionada no contiene ningún centro de hexágono.', + tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', + nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', + nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', + noTokens: 'Seleccione uno o más tokens primero.', + noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', + nothingToUndo: 'No hay ningún relleno que deshacer.', + unknownCommand: 'Comando desconocido: {command}', + unknownSetting: 'Configuración desconocida: {key}', + unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', + invalidValue: '"{value}" no es un valor válido para {key}.', + calibrateNeedsTokens: 'Seleccione una o dos fichas ajustadas a centros de hexágonos.', + calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', + unexpected: 'Algo salió mal: {message}', + }, + hints: { + noPage: 'Abra la página en la que desea trabajar o seleccione algo en ella.', + notHex: + 'Establezca la cuadrícula de la página en Hex (V) o Hex (H) en Configuración de página.', + noPolygons: + 'Dibuja un polígono, un rectángulo, una elipse o una forma a mano alzada alrededor del área, selecciónala y vuelve a intentarlo.', + emptyArea: + 'Dibuja una forma más grande o verifica la configuración de la cuadrícula de la página.', + tooMany: 'Rellene un área más pequeña o divida el área en varias formas.', + noHexes: + 'Los hexágonos están en primer plano o en la capa de fichas; cambie a esa capa para seleccionarlas.', + unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', + unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', + calibrateNeedsTokens: + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + calibrateFailed: + 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + unexpected: 'Los detalles se encuentran en el registro de la consola API.', + }, + help: { + menu: 'Mostrar el menú.', + fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', + fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', + undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + reveal: + 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', + revealPage: 'Revela cada hexágono de la página sin anuncios.', + conceal: + 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', + explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', + name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', + mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', + unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + set: 'Cambie una configuración o muestre todas las configuraciones.', + pageSet: 'Anula una configuración de revelación solo en la página actual.', + pageClear: 'Elimine las anulaciones de la página actual.', + rescan: + 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', + calibrate: + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + calibrateReset: 'Elimina la calibración de la página actual.', + status: 'Muestra lo que Hexploration sabe sobre la página actual.', + journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', + help: 'Muestra esta lista.', + handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', + }, + deck: { + drawDesc: + 'Dibuja formas alrededor de un área, selecciónalas y luego rellena. Deshacer relleno revierte el último relleno.', + revealDesc: + 'Selecciona hexágonos, formas o fichas para revelarlos o volver a cubrirlos. Explorar revela alrededor de las fichas seleccionadas como si se hubieran movido.', + locationsDesc: + 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', + toolsDesc: + 'Configuraciones, anulaciones de páginas, estado, volver a escanear páginas copiadas y calibrar la cuadrícula.', + footer: 'Consulte el folleto "{help}" para obtener instrucciones completas.', + }, + handout: { + versionLabel: 'Versión', + subtitle: 'Exploración hexágono por hexágono para Roll20', + footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', + overview: { + heading: 'Descripción general', + body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + demo: 'Vea una breve demostración (de la versión 1)', + }, + quickStart: { + heading: 'Inicio rápido', + steps: [ + 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', + 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', + 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', + 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Dominio', + colDesc: 'que hace', + }, + revealing: { + heading: 'Cómo funciona la revelación', + points: [ + 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', + 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', + 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', + 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + ], + }, + locations: { + heading: 'Hexágonos y ubicaciones con nombre', + points: [ + 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', + ], + }, + settings: { + heading: 'Ajustes', + intro: + 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', + colKey: 'Llave', + colName: 'Configuración', + colDesc: 'Descripción', + perPage: '(Se puede configurar por página).', + }, + jumpgate: { + heading: 'Jumpgate y legado', + points: [ + 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', + 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, cuya forma es ligeramente distinta de la de los hexágonos de Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha al centro de un hexágono, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos, junto con sus etiquetas de nombre y fichas de ubicación.', + ], + }, + upgrading: { + heading: 'Actualización desde la versión 1', + points: [ + 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', + 'Los mapas de hexágonos, nombres, fichas de ubicación y ajustes existentes se actualizan automáticamente la primera vez que se inicia.', + 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', + 'La versión 1 permitía que cualquier ficha que representara a un personaje revelara hexágonos. Ajuste Fichas que revelan a Fichas de personaje para mantener ese comportamiento.', + ], + colV1: 'Comando versión 1', + colV2: 'Comando versión 2', + }, + troubleshooting: { + heading: 'Solución de problemas', + points: [ + 'No pasa nada cuando una ficha se mueve: compruebe que la ficha está en la capa de fichas y coincide con Fichas que revelan, y que la página tiene hexágonos (!hexploration status).', + 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', + 'Los hexágonos dejaron de revelarse tras copiar una página o un juego: ejecute Volver a escanear en la página.', + 'Rellenar dice que el área no tiene centros de hexágono: la forma debe contener el centro de al menos un hexágono.', + 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + colLanguage: 'Idioma', + colNative: 'Nombre original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versión 2 mantenida por', + marketplace: 'Paquetes de arte de Ada en Roll20 Marketplace', + support: + 'Si encuentra un error o tiene una idea, publíquelo en el foro Roll20 Mod o abra un problema en GitHub e incluya cualquier mensaje del registro de la consola API.', + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'Hexploration är redo.', + settings: 'Hexploration-inställningar', + languages: 'Välj ett språk', + pageSettings: 'Sidinställningar: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandon', + confirm: 'Vänligen bekräfta', + }, + discovery: { + title: 'Plats upptäckt', + }, + menu: { + draw: 'Rita', + reveal: 'Avslöja och dölj', + locations: 'Platser', + tools: 'Verktyg', + layerInUse: 'Nya hexar ritas på {layer}.', + pageSettingsHelp: + 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', + }, + buttons: { + fill: 'Fyll', + fillInverse: 'Omvänd fyllning', + undo: 'Ångra fyllning', + reveal: 'Avslöja', + conceal: 'Dölj', + explore: 'Utforska', + revealPage: 'Avslöja sida', + resetPage: 'Återställ sida', + mark: 'Markera plats', + unmark: 'Avmarkera', + name: 'Namnge hex', + settings: 'Inställningar', + pageSettings: 'Sidinställningar', + status: 'Status', + rescan: 'Skanna igen', + calibrate: 'Kalibrera', + calibrateReset: 'Återställ kalibrering', + help: 'Hjälp', + change: 'Ändra', + menu: 'Meny', + clearOverrides: 'Rensa åsidosättningar', + confirmReset: 'Ja, ta bort alla hexar', + }, + prompts: { + name: 'Platsnamn (låt vara tomt för att rensa)', + }, + values: { + on: 'På', + off: 'Av', + none: 'Ingen', + hexLayer: { + auto: 'Auto (förgrund om tillgängligt)', + foreground: 'förgrundslagret', + objects: 'tokenlagret', + }, + revealBy: { + players: 'Spelartokens', + characters: 'Rollpersonstokens', + all: 'Alla tokens', + }, + revealMode: { + clear: 'Rensa', + glimpse: 'Glimt', + }, + announce: { + all: 'Alla', + gm: 'Endast GM', + off: 'Av', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fyll', + fillInverse: 'Omvänd fyllning', + conceal: 'Dölj', + }, + }, + settings: { + language: { + label: 'Språk', + desc: 'Språk för menyer, meddelanden och åhörarkopior.', + }, + hexLayer: { + label: 'Lager för hexar', + desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + }, + fillColor: { + label: 'Fyllningsfärg', + desc: 'Färg på nya hexar. Använd rgba() för genomskinliga hexar, till exempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfärg', + desc: 'Färg på konturerna av nya sexkanter.', + }, + labelColor: { + label: 'Etikettfärg', + desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + }, + glimpseColor: { + label: 'Glimtfärg', + desc: 'Färgen som hexar byter till när de skymtas (avslöjandeläget Glimt). Använd en genomskinlig rgba()-färg.', + }, + strokeWidth: { + label: 'Kantbredd', + desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + }, + maxDistance: { + label: 'Avslöjandeavstånd för hexar', + desc: 'Lagras på hexarna när de fylls, så ställ in det innan du fyller: att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se; med 0 avslöjas de bara när man går in i dem. Använd det för berg eller skogar. Lämna tomt för ingen gräns.', + }, + revealDistance: { + label: 'Siktavstånd', + desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', + }, + lineOfSight: { + label: 'Siktlinje', + desc: 'När den är på döljer hexar som förblir täckta, till exempel berg som fyllts med ett Avslöjandeavstånd för hexar, hexarna bakom dem. Det gör bara skillnad med ett Siktavstånd på 2 eller mer.', + }, + revealPath: { + label: 'Avslöja längs vägen', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + }, + revealBy: { + label: 'Tokens som avslöjar', + desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + }, + revealMode: { + label: 'Avslöjandeläge', + desc: 'Rensa tar bort hexar inom synhåll. Glimt gör dem i stället genomskinliga; de tas bort när en token går in i dem.', + }, + announce: { + label: 'Tillkännage upptäckter', + desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', + }, + pingDiscoveries: { + label: 'Pinga upptäckter', + desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', + }, + hideCoveredTokens: { + label: 'Dölj täckta tokens', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + }, + }, + status: { + engine: 'Spelmotor', + grid: 'Rutnät', + layer: 'Hexlager', + hexes: 'Hexar', + named: 'Namngivna hexar', + icons: 'Platstokens', + glimpsed: 'Genomskinliga hexar', + pending: 'Platser som väntar på fyllning', + calibrated: 'Kalibrerad', + overrides: 'Sidåsidosättningar', + undo: 'Ångra tillgängligt', + }, + messages: { + filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', + revealed: 'Hexen avslöjade: {count}.', + revealedPage: 'Varje hex på sidan avslöjas ({count}).', + confirmReset: + 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexen har tagits bort från sidan: {count}.', + undone: + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', + named: 'Hex med namnet "{name}": {count}.', + unnamed: 'Namn raderade: {count}.', + marked: + 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + unmarked: 'Tokens som inte längre är platser: {count}.', + settingChanged: '{setting} inställd på {value}.', + rescanned: + 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + calibrated: + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + calibrationReset: + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + journalRebuilt: '"{help}" och "{deck}" har byggts om.', + migrated: + 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', + pruned: + 'Sparade hexar som inte längre finns och har glömts bort: {dropped}. Om det här spelet eller sidan kopierades kör du Skanna igen på sidan för att hitta dess hexar igen.', + readyHint: + 'Skriv !hexploration för menyn, eller öppna handouten "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', + someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + }, + errors: { + noPage: 'Kunde inte hitta sidan att arbeta på.', + notHex: 'Den här sidan använder inte ett hex-rutnät.', + noPolygons: 'Välj en eller flera ritade former att fylla.', + emptyArea: 'Det valda området innehåller inga hexa-center.', + tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', + nothingToConceal: 'Välj ritade former eller tokens att dölja.', + nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + noTokens: 'Välj först en eller flera tokens.', + noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + nothingToUndo: 'Det finns ingen fyllning att ångra.', + unknownCommand: 'Okänt kommando: {command}', + unknownSetting: 'Okänd inställning: {key}', + unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', + invalidValue: '"{value}" är inte ett giltigt värde för {key}.', + calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', + unexpected: 'Något gick fel: {message}', + }, + hints: { + noPage: 'Öppna sidan du vill arbeta på eller välj något på den.', + notHex: 'Ställ in sidrutnätet på Hex (V) eller Hex (H) i Sidinställningar.', + noPolygons: + 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', + emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', + tooMany: 'Fyll ett mindre område, eller dela området i flera former.', + noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + unknownCommand: 'Skriv !hexploration help för att lista kommandona.', + unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', + calibrateNeedsTokens: + 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', + calibrateFailed: + 'Två tokens måste ligga i samma rad (Hex V) eller samma kolumn (Hex H), minst en hex från varandra.', + unexpected: 'Detaljer finns i API-konsolloggen.', + }, + help: { + menu: 'Visa menyn.', + fill: 'Täck de utvalda ritade formerna med hex.', + fillInverse: 'Täck hela sidan utom inuti de valda formerna.', + undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', + reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', + revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', + resetPage: 'Ta bort varje hex på sidan (frågar först).', + name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + mark: 'Förvandla de valda tokens till dolda platser.', + unmark: 'Stoppa de valda tokens från att vara dolda platser.', + set: 'Ändra en inställning eller visa alla inställningar.', + pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', + pageClear: 'Ta bort den aktuella sidans åsidosättningar.', + rescan: + 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', + calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrateReset: 'Ta bort den aktuella sidans kalibrering.', + status: 'Visa vad Hexploration vet om den aktuella sidan.', + journal: 'Bygg om handouterna Help och Command Deck.', + help: 'Visa den här listan.', + handout: 'Fullständiga instruktioner finns i "{name}" handout.', + }, + deck: { + drawDesc: + 'Rita former runt ett område, markera dem och fyll sedan. Ångra fyllning tar bort den senaste fyllningen.', + revealDesc: + 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', + locationsDesc: + 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + toolsDesc: + 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', + footer: 'Se "{help}"-handouten för fullständiga instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-utforskning för Roll20', + footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', + overview: { + heading: 'Översikt', + body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + demo: 'Se en kort demo (från version 1)', + }, + quickStart: { + heading: 'Snabbstart', + steps: [ + 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', + 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', + 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', + ], + }, + commands: { + heading: 'Kommandon', + intro: + 'Endast GM:er kan använda dessa kommandon. De flesta agerar på de valda objekten; resten agerar på sidan du tittar på.', + colCommand: 'Kommando', + colDesc: 'Vad den gör', + }, + revealing: { + heading: 'Hur avslöjande fungerar', + points: [ + 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar, de närmaste först. Med Siktlinje på avslöjas en hex inte så länge en täckt hex ligger mellan den och token. Närmare hexar avslöjas oftast först, så i öppen terräng ändrar Siktlinje ingenting: den spelar bara roll med ett Siktavstånd på 2 eller mer och hexar som förblir täckta, till exempel terräng som fyllts med ett Avslöjandeavstånd för hexar.', + 'Avslöjandeavstånd för hexar lagras på varje hex när den fylls, så ställ in det innan du fyller; att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se, och med 0 avslöjas de bara när man går in i dem. För en bergskedja: ställ in Avslöjandeavstånd för hexar på 0, fyll bergen, återställ det till inget och fyll sedan landet bortom. Med Siktavstånd 3 och Siktlinje på ser gruppen den öppna marken runt sig, men inte bergen eller det som ligger bakom dem. Varje berghex avslöjas när en token går in i den.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem. Genomskinliga Glimt-hexar blockerar inte Siktlinje.', + 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', + 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', + ], + }, + locations: { + heading: 'Namngivna Hex och platser', + points: [ + 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', + 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', + 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', + ], + }, + settings: { + heading: 'Inställningar', + intro: + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', + colKey: 'Nyckel', + colName: 'Miljö', + colDesc: 'Beskrivning', + perPage: '(Kan ställas in per sida.)', + }, + jumpgate: { + heading: 'Jumpgate och Legacy', + points: [ + 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', + 'När Lager för hexar är inställt på Auto ritas hexar på förgrundslagret, ovanför tokens, så att spelarna inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret i stället.', + 'Jumpgate ritar matematiskt regelbundna hexar, som har en något annan form än Legacy-hexar. Om hexarna inte stämmer med en sidas rutnät, fäst en token i mitten av en hex, markera den och klicka på Kalibrera. Markera två tokens i angränsande hexar i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID:n. Kör Skanna igen på sidan för att hitta dem igen, tillsammans med deras namnetiketter och platstokens.', + ], + }, + upgrading: { + heading: 'Uppgraderar från version 1', + points: [ + 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', + 'Befintliga hexkartor, namn, platstokens och inställningar uppgraderas automatiskt vid första starten.', + 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', + 'I version 1 kunde varje token som representerade en rollperson avslöja hexar. Ställ in Tokens som avslöjar på Rollpersonstokens för att behålla det beteendet.', + ], + colV1: 'Kommandot version 1', + colV2: 'Kommandot version 2', + }, + troubleshooting: { + heading: 'Felsökning', + points: [ + 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', + 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', + 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', + 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', + ], + }, + languages: { + heading: 'Språk', + body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + colLanguage: 'Språk', + colNative: 'Eget namn', + colCode: 'Koda', + }, + credits: { + heading: 'Krediter', + original: 'Originalmod av', + maintainer: 'Version 2 underhålls av', + marketplace: 'Adas konstpaket på Roll20 Marketplace', + support: + 'Om du hittar en bugg eller har en idé, posta i Roll20 Mod-forumet eller öppna ett problem på GitHub och inkludera eventuella meddelanden från API-konsolloggen.', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Hexploration hazır.', + settings: 'Hexploration Ayarları', + languages: 'Bir Dil Seçin', + pageSettings: 'Sayfa Ayarları: {page}', + status: 'Hexploration Durumu: {page}', + help: 'Hexploration Komutları', + confirm: 'Lütfen Onaylayın', + }, + discovery: { + title: 'Konum Keşfedildi', + }, + menu: { + draw: 'Çizim', + reveal: 'Açığa Çıkarma ve Gizleme', + locations: 'Konumlar', + tools: 'Araçlar', + layerInUse: 'Yeni altıgenler şu katmana çiziliyor: {layer}.', + pageSettingsHelp: + 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', + }, + buttons: { + fill: 'Doldur', + fillInverse: 'Ters Doldur', + undo: 'Doldurmayı Geri Al', + reveal: 'Açığa Çıkar', + conceal: 'Gizle', + explore: 'Keşfet', + revealPage: 'Sayfayı Açığa Çıkar', + resetPage: 'Sayfayı Sıfırla', + mark: 'Konumu İşaretle', + unmark: 'İşareti Kaldır', + name: 'Altıgeni Adlandır', + settings: 'Ayarlar', + pageSettings: 'Sayfa Ayarları', + status: 'Durum', + rescan: 'Yeniden Tara', + calibrate: 'Kalibre Et', + calibrateReset: 'Kalibrasyonu Sıfırla', + help: 'Yardım', + change: 'Değiştir', + menu: 'Menü', + clearOverrides: 'Geçersiz Kılmaları Temizle', + confirmReset: 'Evet, Tüm Altıgenleri Kaldır', + }, + prompts: { + name: 'Konum adı (temizlemek için boş bırakın)', + }, + values: { + on: 'Açık', + off: 'Kapalı', + none: 'Hiçbiri', + hexLayer: { + auto: 'Otomatik (varsa ön plan)', + foreground: 'ön plan katmanı', + objects: 'jeton katmanı', + }, + revealBy: { + players: 'Oyuncu jetonları', + characters: 'Karakter jetonları', + all: 'Tüm jetonlar', + }, + revealMode: { + clear: 'Temizleme', + glimpse: 'Bakış', + }, + announce: { + all: 'Herkes', + gm: 'Yalnızca GM', + off: 'Kapalı', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Doldurma', + fillInverse: 'Ters Doldurma', + conceal: 'Gizleme', + }, + }, + settings: { + language: { + label: 'Dil', + desc: 'Menüler, mesajlar ve broşürler için dil.', + }, + hexLayer: { + label: 'Altıgen Katmanı', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (jetonların üstünde) dener; oyun bunu desteklemiyorsa jeton katmanına geri döner.', + }, + fillColor: { + label: 'Dolgu Rengi', + desc: 'Yeni altıgenlerin rengi. Şeffaf altıgenler için rgba() kullanın; örneğin rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kenarlık Rengi', + desc: 'Yeni altıgenlerin ana hatlarının rengi.', + }, + labelColor: { + label: 'Etiket Rengi', + desc: 'Adlandırılmış altıgenlerdeki yalnızca GM ad etiketlerinin rengi.', + }, + glimpseColor: { + label: 'Bakış Rengi', + desc: 'Altıgenlerin Bakış modunda aldığı renk. Yarı saydam bir rgba() rengi kullanın.', + }, + strokeWidth: { + label: 'Kenarlık Kalınlığı', + desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', + }, + maxDistance: { + label: 'Altıgen Açığa Çıkarma Mesafesi', + desc: 'Altıgenler doldurulurken onlara kaydedilir, bu yüzden doldurmadan önce ayarlayın: sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için bu kadar altıgen mesafede olmalıdır; 0 ile yalnızca içlerine girilerek açığa çıkarlar. Dağlar veya ormanlar için kullanın. Sınır olmaması için boş bırakın.', + }, + revealDistance: { + label: 'Görüş Mesafesi', + desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + }, + lineOfSight: { + label: 'Görüş Hattı', + desc: 'Açıkken, Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş dağlar gibi örtülü kalan altıgenler, arkalarındaki altıgenleri gizler. Yalnızca 2 veya daha fazla Görüş Mesafesi ile fark yaratır.', + }, + revealPath: { + label: 'Yol Boyunca Açığa Çıkar', + desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + }, + revealBy: { + label: 'Açığa Çıkaran Jetonlar', + desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', + }, + revealMode: { + label: 'Açığa Çıkarma Modu', + desc: 'Temizleme, görüş alanındaki altıgenleri kaldırır. Bakış ise onları yarı saydam yapar; içlerine bir jeton girdiğinde kaldırılırlar.', + }, + announce: { + label: 'Keşifleri Duyur', + desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', + }, + pingDiscoveries: { + label: 'Keşifleri Pingle', + desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + }, + hideCoveredTokens: { + label: 'Örtülü Jetonları Gizle', + desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + }, + }, + status: { + engine: 'Oyun motoru', + grid: 'Izgara', + layer: 'Altıgen katmanı', + hexes: 'Altıgenler', + named: 'Adlandırılmış altıgenler', + icons: 'Konum jetonları', + glimpsed: 'Bakış altındaki altıgenler', + pending: 'Doldurma bekleyen konumlar', + calibrated: 'Kalibre edildi', + overrides: 'Sayfa geçersiz kılmaları', + undo: 'Geri alma mevcut', + }, + messages: { + filled: + 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', + revealed: 'Büyüler ortaya çıktı: {count}.', + revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', + confirmReset: + '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', + undone: + 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', + named: '"{name}" adlı altıgenler: {count}.', + unnamed: 'İsimler temizlendi: {count}.', + marked: + 'Mevcut altıgenlerde gizli konumlar: {attached}. Bunları kapsayan bir sonraki dolgu bekleniyor: {pending}.', + unmarked: 'Artık konum olmayan jetonlar: {count}.', + settingChanged: '{setting}, {value} olarak ayarlandı.', + rescanned: + 'Yeniden tarama tamamlandı. Tutulan: {kept}. Kabul edildi: {adopted}. Yeniden dosyalandı: {moved}. Eksik ve unutulmuş: {dropped}. Etiketler yeniden bağlandı: {labels}. Konum jetonları yeniden bağlandı: {icons}.', + calibrated: + 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + calibrationReset: + 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + journalRebuilt: '"{help}" ve "{deck}" broşürleri yeniden oluşturuldu.', + migrated: + "Hexploration 1.x altıgen haritalarınız yükseltildi. Bu oyun bir Legacy oyunundan kopyalandıysa, her altıgen harita sayfasında Yeniden Tara'yı çalıştırın.", + pruned: + "Artık var olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenlerini yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + readyHint: 'Menü için !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + }, + warnings: { + foregroundUnavailable: + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', + }, + errors: { + noPage: 'Üzerinde çalışılacak sayfa bulunamadı.', + notHex: 'Bu sayfada altıgen ızgara kullanılmamaktadır.', + noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', + emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', + tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', + noTokens: 'Önce bir veya daha fazla jeton seçin.', + noHexes: + 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', + nothingToUndo: 'Geri alınacak bir dolgu yok.', + unknownCommand: 'Bilinmeyen komut: {command}', + unknownSetting: 'Bilinmeyen ayar: {key}', + unknownPageSetting: 'Sayfa başına ayarlanabilen ayarlar: {keys}', + invalidValue: '"{value}", {key} için geçerli bir değer değil.', + calibrateNeedsTokens: 'Altıgen merkezlere tutturulmuş bir veya iki jeton seçin.', + calibrateFailed: 'Bu jetonlar kalibrasyon için kullanılamaz.', + unexpected: 'Bir şeyler ters gitti: {message}', + }, + hints: { + noPage: 'Üzerinde çalışmak istediğiniz sayfayı açın veya üzerinde bir şey seçin.', + notHex: "Sayfa Ayarları'nda sayfa ızgarasını Hex (V) veya Hex (H) olarak ayarlayın.", + noPolygons: + 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', + emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', + tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', + noHexes: + 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + unknownCommand: 'Komutları listelemek için !hexploration help yazın.', + unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', + calibrateNeedsTokens: + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgene tutturulmuş ikinci bir jeton seçin.', + calibrateFailed: + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir altıgen aralıkla olması gerekir.', + unexpected: 'Ayrıntılar API konsolu günlüğündedir.', + }, + help: { + menu: 'Menüyü göster.', + fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', + fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', + undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + reveal: + 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', + conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', + explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', + resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', + name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + mark: 'Seçilen jetonları gizli konumlara dönüştürün.', + unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', + pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', + rescan: + 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', + calibrate: + 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', + calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', + status: "Hexploration'ın geçerli sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Command Deck broşürlerini yeniden oluşturun.', + help: 'Bu listeyi göster.', + handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', + }, + deck: { + drawDesc: + "Bir alanın çevresine şekiller çizin, onları seçin ve Doldur'a tıklayın. Doldurmayı Geri Al, son doldurmayı geri alır.", + revealDesc: + 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', + locationsDesc: + 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + toolsDesc: + 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', + footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', + }, + handout: { + versionLabel: 'Sürüm', + subtitle: 'Roll20 için hex-hex keşif', + footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', + overview: { + heading: 'Genel Bakış', + body: 'Hexploration, bir altıgen haritayı opak altıgenlerle kaplar. Grup ilerledikçe içinden geçtiği altıgenler (ve isterseniz çevresindeki altıgenler) kaldırılır; böylece harita altıgen altıgen ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduklarında duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + demo: "Kısa bir demo izleyin (versiyon 1'den)", + }, + quickStart: { + heading: 'Hızlı Başlangıç', + steps: [ + 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', + 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', + "Şekilleri seçin ve Command Deck'te Doldur'a tıklayın (veya !hexploration fill yazın). Şekiller altıgenlerle değiştirilir.", + "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", + 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', + ], + }, + commands: { + heading: 'Komutlar', + intro: + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", + colCommand: 'Emretmek', + colDesc: 'Ne işe yarar', + }, + revealing: { + heading: 'Açığa Çıkarma Nasıl Çalışır?', + points: [ + 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', + 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri en yakından başlayarak açığa çıkarır. Görüş Hattı açıkken, bir altıgen ile jeton arasında örtülü bir altıgen bulunduğu sürece o altıgen açığa çıkmaz. Yakın altıgenler genellikle önce açığa çıktığından, açık arazide Görüş Hattı hiçbir şeyi değiştirmez: yalnızca 2 veya daha fazla Görüş Mesafesi ve Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş arazi gibi örtülü kalan altıgenler olduğunda önem taşır.', + 'Altıgen Açığa Çıkarma Mesafesi, her altıgen doldurulurken ona kaydedilir, bu yüzden doldurmadan önce ayarlayın; sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için o kadar altıgen mesafede olmalıdır ve 0 ile yalnızca içlerine girilerek açığa çıkarlar. Bir sıradağ için: Altıgen Açığa Çıkarma Mesafesi ayarını 0 yapın, dağları doldurun, ayarı yeniden boşaltın, ardından ötedeki araziyi doldurun. Görüş Mesafesi 3 ve Görüş Hattı açıkken grup çevresindeki açık araziyi görür, ancak dağları ya da arkalarında olanları göremez. Her dağ altıgeni, bir jeton içine girdiğinde açığa çıkar.', + "Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır. Bakış durumundaki altıgenler Görüş Hattı'nı engellemez.", + 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', + "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", + ], + }, + locations: { + heading: 'Adlandırılmış Altıgenler ve Konumlar', + points: [ + 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', + "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", + 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", + ], + }, + settings: { + heading: 'Ayarlar', + intro: + "Ayarları !hexploration set ile (veya Ayarlar düğmesiyle) değiştirin. Altıgen Katmanı, Açığa Çıkaran Jetonlar ve Dil, Mod'un ayarlar sayfasından da ayarlanabilir.", + colKey: 'Anahtar', + colName: 'Ayar', + colDesc: 'Tanım', + perPage: '(Sayfa başına ayarlanabilir.)', + }, + jumpgate: { + heading: 'Jumpgate ve Eski', + points: [ + 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', + 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', + "Jumpgate matematiksel olarak düzgün altıgenler çizer; bunların şekli Legacy altıgenlerinden biraz farklıdır. Altıgenler sayfanın ızgarasıyla hizalı değilse bir altıgenin merkezine bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerde iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Onları ad etiketleri ve konum jetonlarıyla birlikte yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + ], + }, + upgrading: { + heading: "Sürüm 1'den yükseltme", + points: [ + "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", + 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', + "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", + ], + colV1: 'Sürüm 1 komutu', + colV2: 'Sürüm 2 komutu', + }, + troubleshooting: { + heading: 'Sorun giderme', + points: [ + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu ve Açığa Çıkaran Jetonlar ayarına uyduğunu, sayfada da altıgenler bulunduğunu (!hexploration status) kontrol edin.', + "Altıgenler ızgaradan kaymış: Kalibre Et'i kullanın, ardından haritanın farklı yerlerindeki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra altıgenler açığa çıkmıyor: sayfada Yeniden Tara'yı çalıştırın.", + 'Doldur, alanda altıgen merkezi olmadığını söylüyor: şeklin en az bir altıgenin merkezini içermesi gerekir.', + 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', + ], + }, + languages: { + heading: 'Diller', + body: '!hexploration set language ile bir dil seçin. Mevcut diller:', + colLanguage: 'Dil', + colNative: 'Yerel ad', + colCode: 'Kod', + }, + credits: { + heading: 'Kredi', + original: 'Orijinal modun yapımcısı', + maintainer: 'Versiyon 2 tarafından sürdürülen', + marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", + support: + "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration готовий.', + settings: 'Налаштування Hexploration', + languages: 'Виберіть мову', + pageSettings: 'Налаштування сторінки: {page}', + status: 'Статус Hexploration: {page}', + help: 'Команди Hexploration', + confirm: 'Будь ласка, підтвердьте', + }, + discovery: { + title: 'Локацію виявлено', + }, + menu: { + draw: 'Малювання', + reveal: 'Розкриття і приховування', + locations: 'Локації', + tools: 'Інструменти', + layerInUse: 'Нові гекси малюються на цьому шарі: {layer}.', + pageSettingsHelp: + 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', + }, + buttons: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + undo: 'Скасувати заповнення', + reveal: 'Розкрити', + conceal: 'Приховати', + explore: 'Дослідити', + revealPage: 'Розкрити сторінку', + resetPage: 'Скинути сторінку', + mark: 'Позначити локацію', + unmark: 'Зняти позначку', + name: 'Назвати гекс', + settings: 'Налаштування', + pageSettings: 'Налаштування сторінки', + status: 'Статус', + rescan: 'Пересканувати', + calibrate: 'Відкалібрувати', + calibrateReset: 'Скинути калібрування', + help: 'Довідка', + change: 'Змінити', + menu: 'Меню', + clearOverrides: 'Скинути перевизначення', + confirmReset: 'Так, видалити всі гекси', + }, + prompts: { + name: 'Назва місця (залиште порожнім, щоб очистити)', + }, + values: { + on: 'Увімкнено', + off: 'Вимкнено', + none: 'Немає', + hexLayer: { + auto: 'Авто (передній план, якщо доступний)', + foreground: 'шар переднього плану', + objects: 'шар маркерів', + }, + revealBy: { + players: 'Маркери гравців', + characters: 'Маркери персонажів', + all: 'Усі маркери', + }, + revealMode: { + clear: 'Очищення', + glimpse: 'Проблиск', + }, + announce: { + all: 'Всі', + gm: 'Лише GM', + off: 'Вимкнено', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заповнення', + fillInverse: 'Зворотне заповнення', + conceal: 'Приховування', + }, + }, + settings: { + language: { + label: 'Мова', + desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', + }, + hexLayer: { + label: 'Шар шестикутників', + desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', + }, + fillColor: { + label: 'Колір заливки', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Колір контуру', + desc: 'Колір контуру нових гексів.', + }, + labelColor: { + label: 'Колір міток', + desc: 'Колір написів імен лише для GM на іменованих гексах.', + }, + glimpseColor: { + label: 'Колір проблиску', + desc: 'Колір, якого набувають гекси в режимі «Проблиск». Використовуйте напівпрозорий колір rgba().', + }, + strokeWidth: { + label: 'Товщина контуру', + desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', + }, + maxDistance: { + label: 'Відстань розкриття шестикутників', + desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', + }, + revealDistance: { + label: 'Дальність огляду', + desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', + }, + lineOfSight: { + label: 'Лінія видимості', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', + }, + revealPath: { + label: 'Розкривати вздовж шляху', + desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', + }, + revealBy: { + label: 'Маркери, що розкривають', + desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', + }, + revealMode: { + label: 'Режим розкриття', + desc: '«Очищення» видаляє гекси в межах видимості. «Проблиск» натомість робить їх напівпрозорими; вони видаляються, коли на них заходить маркер.', + }, + announce: { + label: 'Оголошувати відкриття', + desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + }, + pingDiscoveries: { + label: 'Пінгувати знахідки', + desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + }, + hideCoveredTokens: { + label: 'Ховати маркери під гексами', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + }, + }, + status: { + engine: 'Ігровий рушій', + grid: 'Сітка', + layer: 'Шар шестикутників', + hexes: 'Гекси', + named: 'Іменовані гекси', + icons: 'Маркери локацій', + glimpsed: 'Гекси в проблиску', + pending: 'Локації, що чекають на заповнення', + calibrated: 'Відкалібровано', + overrides: 'Перевизначення сторінки', + undo: 'Доступне скасування', + }, + messages: { + filled: + 'Заповнення завершено. Намальовані гекси: {created}. Рестайлінг: {restyled}. Приховані місця: {icons}.', + revealed: 'Розкрито гекси: {count}.', + revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', + confirmReset: + 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', + resetPage: 'Зі сторінки видалено шестигранники: {count}.', + undone: + 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', + named: 'Гекси з назвою "{name}": {count}.', + unnamed: 'Імена видалено: {count}.', + marked: + 'Місця, приховані в існуючих гексах: {attached}. Очікування наступного заповнення, яке охопить їх: {pending}.', + unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', + settingChanged: '{setting} встановлено на {value}.', + rescanned: + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + calibrated: + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + calibrationReset: + 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', + migrated: + 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', + pruned: + 'Забуто збережені гекси, яких більше не існує: {dropped}. Якщо цю гру чи сторінку було скопійовано, виконайте «Пересканувати» на сторінці, щоб знову знайти її гекси.', + readyHint: + 'Введіть !hexploration, щоб відкрити меню, або відкрийте роздатковий матеріал "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ця гра не підтримує малювання на передньому шарі, тому гекси були намальовані на шарі жетонів.', + someFailed: + 'Гекси, які не вдалося намалювати: {count}. Перевірте консоль API для отримання деталей.', + }, + errors: { + noPage: 'Не вдалося знайти сторінку для роботи.', + notHex: 'На цій сторінці не використовується гексова сітка.', + noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', + emptyArea: 'Вибрана область не містить шестигранних центрів.', + tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', + nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', + nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + noTokens: 'Спочатку виберіть один або кілька токенів.', + noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', + nothingToUndo: 'Немає заповнення, яке можна скасувати.', + unknownCommand: 'Невідома команда: {command}', + unknownSetting: 'Невідоме налаштування: {key}', + unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', + invalidValue: '"{value}" не є дійсним значенням для {key}.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', + unexpected: 'Щось пішло не так: {message}', + }, + hints: { + noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', + notHex: 'Установіть для сітки сторінки Hex (V) або Hex (H) у налаштуваннях сторінки.', + noPolygons: + 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', + emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', + tooMany: 'Заповніть меншу область або розділіть її на кілька фігур.', + noHexes: + 'Гекси знаходяться на передньому плані або шарі жетонів; перейдіть на цей шар, щоб вибрати їх.', + unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', + unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', + calibrateNeedsTokens: + 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + calibrateFailed: + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + unexpected: 'Подробиці в журналі консолі API.', + }, + help: { + menu: 'Показати меню.', + fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', + undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', + reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', + revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', + resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', + name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', + mark: 'Перетворіть вибрані жетони на приховані місця.', + unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + set: 'Змінити налаштування або показати всі налаштування.', + pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageClear: 'Видаліть перевизначення поточної сторінки.', + rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', + calibrate: + 'Вирівняйте гексову сітку за одним або двома вибраними маркерами, прив’язаними до центрів гексів.', + calibrateReset: 'Видалити калібрування поточної сторінки.', + status: 'Покажіть, що Hexploration знає про поточну сторінку.', + journal: 'Перебудуйте роздаткові матеріали «Довідка» та «Command Deck».', + help: 'Покажіть цей список.', + handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', + }, + deck: { + drawDesc: + 'Обведіть область фігурами, виділіть їх і натисніть «Заповнити». «Скасувати заповнення» скасовує останнє заповнення.', + revealDesc: + 'Виділіть гекси, фігури або маркери, щоб розкрити їх або знову приховати. «Дослідити» розкриває гекси навколо вибраних маркерів, ніби вони туди перемістилися.', + locationsDesc: + 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', + toolsDesc: + 'Налаштування, перевизначення сторінок, статус, повторне сканування скопійованих сторінок і калібрування сітки.', + footer: 'Перегляньте роздатковий матеріал "{help}", щоб отримати повні інструкції.', + }, + handout: { + versionLabel: 'Версія', + subtitle: 'Дослідження гекс за гексом для Roll20', + footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', + overview: { + heading: 'Огляд', + body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + demo: 'Перегляньте коротку демонстрацію (з версії 1)', + }, + quickStart: { + heading: 'Швидкий старт', + steps: [ + 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', + 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', + 'Виберіть фігури та натисніть «Заповнити» в Command Deck (або введіть !hexploration fill). Фігури буде замінено гексами.', + 'Додатково: перед заповненням виділіть маркери важливих місць і натисніть «Позначити локацію». Вони сховаються під гексами, а коли їх виявлять, про це буде оголошено.', + 'Перемістіть маркер гравця. Кожен гекс, через який він проходить, і гекси в межах його «Дальності огляду» розкриваються.', + ], + }, + commands: { + heading: 'Команди', + intro: + "Тільки GM можуть використовувати ці команди. Більшість діють на обрані об'єкти; решта діють на сторінці, яку ви переглядаєте.", + colCommand: 'Команда', + colDesc: 'Що воно робить', + }, + revealing: { + heading: 'Як працює розкриття', + points: [ + 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', + 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', + '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', + "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", + 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', + ], + }, + locations: { + heading: 'Іменовані гекси та локації', + points: [ + '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', + 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', + 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', + ], + }, + settings: { + heading: 'Налаштування', + intro: + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', + colKey: 'ключ', + colName: 'Налаштування', + colDesc: 'опис', + perPage: '(Можна встановити на сторінку.)', + }, + jumpgate: { + heading: 'Jumpgate і Legacy', + points: [ + 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', + 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', + ], + }, + upgrading: { + heading: 'Оновлення з версії 1', + points: [ + 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', + 'Наявні гексові карти, назви, маркери локацій і налаштування оновлюються автоматично під час першого запуску.', + 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', + 'У версії 1 гекси міг розкривати будь-який маркер, що представляв персонажа. Щоб зберегти таку поведінку, встановіть для «Маркери, що розкривають» значення «Маркери персонажів».', + ], + colV1: 'Команда версії 1', + colV2: 'Команда версії 2', + }, + troubleshooting: { + heading: 'Усунення несправностей', + points: [ + 'Коли маркер рухається, нічого не відбувається: перевірте, чи маркер на шарі маркерів і відповідає параметру «Маркери, що розкривають», а на сторінці є гекси (!hexploration status).', + 'Гекси зміщені відносно сітки: натисніть «Відкалібрувати», а потім перевірте маркером кілька гексів у різних частинах карти.', + 'Гекси перестали розкриватися після копіювання сторінки або гри: виконайте «Пересканувати» на сторінці.', + '«Заповнити» повідомляє, що в області немає центрів гексів: фігура має містити центр принаймні одного гекса.', + 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', + ], + }, + languages: { + heading: 'Мови', + body: 'Виберіть мову командою !hexploration set language. Доступні мови:', + colLanguage: 'Мова', + colNative: 'Самоназва', + colCode: 'Код', + }, + credits: { + heading: 'Кредити', + original: 'Оригінальний мод від', + maintainer: 'Версія 2 підтримується', + marketplace: 'Художні набори Ади на Roll20 Marketplace', + support: + 'Якщо ви знайшли помилку або маєте ідею, опублікуйте на форумі Roll20 Mod або відкрийте проблему на GitHub і додайте будь-які повідомлення з журналу консолі API.', + }, + }, + }; + + const DEFAULT_LOCALE = 'en-US'; + + const LOCALE_DEFINITIONS = Object.freeze([ + { + code: 'af', + name: 'Afrikaans', + direction: 'ltr', + translationFile: 'locale/af.js', + flag: '🇿🇦', + flagLabel: 'Flag of South Africa', + }, + { + code: 'ca', + name: 'Catalan', + nativeName: 'Català', + direction: 'ltr', + translationFile: 'locale/ca.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'zh-TW', + name: 'Chinese (Traditional)', + nativeName: '正體中文', + direction: 'ltr', + translationFile: 'locale/zh-TW.js', + aliases: ['zh'], + flag: '🇹🇼', + flagLabel: 'Flag of Taiwan', + }, + { + code: 'cs', + name: 'Czech', + nativeName: 'Čeština', + direction: 'ltr', + translationFile: 'locale/cs.js', + flag: '🇨🇿', + flagLabel: 'Flag of Czechia', + }, + { + code: 'da', + name: 'Danish', + nativeName: 'Dansk', + direction: 'ltr', + translationFile: 'locale/da.js', + flag: '🇩🇰', + flagLabel: 'Flag of Denmark', + }, + { + code: 'nl', + name: 'Dutch', + nativeName: 'Nederlands', + direction: 'ltr', + translationFile: 'locale/nl.js', + flag: '🇳🇱', + flagLabel: 'Flag of the Netherlands', + }, + { + code: 'en-US', + name: 'English', + nativeName: 'English', + direction: 'ltr', + translationFile: 'locale/en-US.js', + aliases: ['en'], + flag: '🇺🇸', + flagLabel: 'Flag of the United States', + }, + { + code: 'fi', + name: 'Finnish', + nativeName: 'Suomeksi', + direction: 'ltr', + translationFile: 'locale/fi.js', + flag: '🇫🇮', + flagLabel: 'Flag of Finland', + }, + { + code: 'fr', + name: 'French', + nativeName: 'Français', + direction: 'ltr', + translationFile: 'locale/fr.js', + flag: '🇫🇷', + flagLabel: 'Flag of France', + }, + { + code: 'de', + name: 'German', + nativeName: 'Deutsch', + direction: 'ltr', + translationFile: 'locale/de.js', + flag: '🇩🇪', + flagLabel: 'Flag of Germany', + }, + { + code: 'el', + name: 'Greek', + nativeName: 'Ελληνικά', + direction: 'ltr', + translationFile: 'locale/el.js', + flag: '🇬🇷', + flagLabel: 'Flag of Greece', + }, + { + code: 'he', + name: 'Hebrew', + nativeName: 'עברית', + direction: 'rtl', + translationFile: 'locale/he.js', + flag: '🇮🇱', + flagLabel: 'Flag of Israel', + }, + { + code: 'hu', + name: 'Hungarian', + nativeName: 'Magyar', + direction: 'ltr', + translationFile: 'locale/hu.js', + flag: '🇭🇺', + flagLabel: 'Flag of Hungary', + }, + { + code: 'it', + name: 'Italian', + nativeName: 'Italiano', + direction: 'ltr', + translationFile: 'locale/it.js', + flag: '🇮🇹', + flagLabel: 'Flag of Italy', + }, + { + code: 'ja', + name: 'Japanese', + nativeName: '日本語', + direction: 'ltr', + translationFile: 'locale/ja.js', + flag: '🇯🇵', + flagLabel: 'Flag of Japan', + }, + { + code: 'ko', + name: 'Korean', + nativeName: '한국어', + direction: 'ltr', + translationFile: 'locale/ko.js', + flag: '🇰🇷', + flagLabel: 'Flag of South Korea', + }, + { + code: 'pl', + name: 'Polish', + nativeName: 'Polski', + direction: 'ltr', + translationFile: 'locale/pl.js', + flag: '🇵🇱', + flagLabel: 'Flag of Poland', + }, + { + code: 'pt-PT', + name: 'Portuguese (Portugal)', + nativeName: 'Português - Portugal', + direction: 'ltr', + translationFile: 'locale/pt-PT.js', + aliases: ['pt'], + flag: '🇵🇹', + flagLabel: 'Flag of Portugal', + }, + { + code: 'pt-BR', + name: 'Portuguese (Brazil)', + nativeName: 'Português - Brasil', + direction: 'ltr', + translationFile: 'locale/pt-BR.js', + flag: '🇧🇷', + flagLabel: 'Flag of Brazil', + }, + { + code: 'ru', + name: 'Russian', + nativeName: 'Русский', + direction: 'ltr', + translationFile: 'locale/ru.js', + flag: '🇷🇺', + flagLabel: 'Flag of Russia', + }, + { + code: 'es', + name: 'Spanish', + nativeName: 'Español', + direction: 'ltr', + translationFile: 'locale/es.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'sv', + name: 'Swedish', + nativeName: 'Svenska', + direction: 'ltr', + translationFile: 'locale/sv.js', + flag: '🇸🇪', + flagLabel: 'Flag of Sweden', + }, + { + code: 'tr', + name: 'Turkish', + nativeName: 'Türkçe', + direction: 'ltr', + translationFile: 'locale/tr.js', + flag: '🇹🇷', + flagLabel: 'Flag of Turkey', + }, + { + code: 'uk', + name: 'Ukrainian', + nativeName: 'Українська', + direction: 'ltr', + translationFile: 'locale/uk.js', + flag: '🇺🇦', + flagLabel: 'Flag of Ukraine', + }, + ]); + + const SUPPORTED_LOCALES = Object.freeze(LOCALE_DEFINITIONS.map(({ code }) => code)); + const VALID_LOCALES = new Set(SUPPORTED_LOCALES); + const LOCALE_ALIASES = Object.freeze( + LOCALE_DEFINITIONS.reduce((aliases, locale) => { + for (const alias of locale.aliases || []) { + aliases[alias] = locale.code; + } + return aliases; + }, {}) + ); + const LOCALE_LABELS = Object.freeze( + LOCALE_DEFINITIONS.reduce((labels, locale) => { + const displayName = locale.nativeName + ? `${locale.code} - ${locale.name} (${locale.nativeName})` + : `${locale.code} - ${locale.name}`; + labels[locale.code] = displayName; + return labels; + }, {}) + ); + SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); + + const TRANSLATIONS = { + af: TRANSLATION$m, + ca: TRANSLATION$l, + 'zh-TW': TRANSLATION$k, + cs: TRANSLATION$j, + da: TRANSLATION$i, + nl: TRANSLATION$h, + 'en-US': localeEnUS, + fi: TRANSLATION$g, + fr: TRANSLATION$f, + de: TRANSLATION$e, + el: TRANSLATION$d, + he: TRANSLATION$c, + hu: TRANSLATION$b, + it: TRANSLATION$a, + ja: TRANSLATION$9, + ko: TRANSLATION$8, + pl: TRANSLATION$7, + 'pt-PT': TRANSLATION$6, + 'pt-BR': TRANSLATION$5, + ru: TRANSLATION$4, + es: TRANSLATION$3, + sv: TRANSLATION$2, + tr: TRANSLATION$1, + uk: TRANSLATION, + }; + + /** + * Returns the canonical locale for a supported locale string or alias. + * Matching is case-insensitive after exact matches are checked. + * + * @param {string} lang Locale string or alias (e.g. 'en', 'fr', 'zh-TW'). + * @returns {string} Canonical locale code, or an empty string when unsupported. + */ + function normalizeLocale(lang) { + const s = typeof lang === 'string' ? lang.trim() : ''; + if (VALID_LOCALES.has(s)) { + return s; + } + if (LOCALE_ALIASES[s]) { + return LOCALE_ALIASES[s]; + } + const normalized = s.toLowerCase(); + const found = Array.from(VALID_LOCALES).find((locale) => locale.toLowerCase() === normalized); + return ( + found || + Object.entries(LOCALE_ALIASES).find(([alias]) => alias.toLowerCase() === normalized)?.[1] || + '' + ); + } + + /** + * Returns a valid canonical locale, falling back to the default when unsupported. + * + * @param {string} lang Locale string to validate. + * @returns {string} Validated canonical locale. + */ + function getLocale(lang) { + return normalizeLocale(lang) || DEFAULT_LOCALE; + } + + /** + * Navigates a nested object following dot-separated key path segments. + * + * @param {object} obj Root object. + * @param {string[]} parts Key path segments. + * @returns {*} Value at the path, or undefined. + */ + function getNestedValue(obj, parts) { + let current = obj; + for (const part of parts) { + if (current == null || typeof current !== 'object') { + return undefined; + } + current = current[part]; + } + return current; + } + + /** + * Returns the raw translated value (string, array or object) for a key, + * falling back to en-US when the key is missing in the requested locale. + * + * @param {string} key Dot-separated translation key. + * @param {string} locale Locale code. + * @returns {*} Raw value, or undefined when not found. + */ + function tRaw(key, locale) { + const lang = getLocale(locale); + const parts = key.split('.'); + const value = getNestedValue(TRANSLATIONS[lang], parts); + return value === undefined && lang !== DEFAULT_LOCALE + ? getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts) + : value; + } + + /** + * Returns the text direction CSS for a locale. + * + * @param {string} locale Locale code. + * @returns {string} CSS declarations, empty for left-to-right locales. + */ + function getDirectionStyle(locale) { + const lang = getLocale(locale); + const def = LOCALE_DEFINITIONS.find((d) => d.code === lang); + return def?.direction === 'rtl' ? 'direction:rtl;text-align:right;' : ''; + } + + /** + * Returns the translated string for a dot-separated key, interpolating {placeholder} vars. + * Falls back to en-US when the key is missing in the requested locale. + * No HTML escaping is performed — callers must pre-escape HTML-unsafe values. + * + * @param {string} key Dot-separated translation key (e.g. 'errors.noTokensSelected'). + * @param {string} locale Locale code. + * @param {object} [vars] Interpolation variables mapped to {placeholder} names. + * @returns {string} Translated and interpolated string. Returns the key when not found. + */ + function t(key, locale, vars = {}) { + const lang = getLocale(locale); + const parts = key.split('.'); + let value = getNestedValue(TRANSLATIONS[lang], parts); + + if (value === undefined && lang !== DEFAULT_LOCALE) { + value = getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts); + } + + if (typeof value !== 'string') { + return key; + } + + return value.replaceAll(/\{(\w+)\}/g, (_, k) => (k in vars ? String(vars[k]) : `{${k}}`)); + } + + // --------------------------------------------------------------------------- + // Config validation (pure) + // --------------------------------------------------------------------------- + + /** + * Validates one configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Result; `value` is the normalised value when valid. + */ + function validateConfigValue(key, raw) { + const ok = (value) => ({ valid: true, value }); + const bad = { valid: false }; + + switch (key) { + case 'language': { + const lang = normalizeLocale(raw); + return lang ? ok(lang) : bad; + } + case 'hexLayer': + return HEX_LAYER_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealBy': + return REVEAL_BY_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealMode': + return REVEAL_MODE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'announce': + return ANNOUNCE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'fillColor': + case 'strokeColor': + case 'labelColor': + case 'glimpseColor': + return isValidColor(raw) ? ok(toText(raw)) : bad; + case 'strokeWidth': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 ? bad : ok(clamp(n, 0, MAX_STROKE_WIDTH)); + } + case 'revealDistance': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'maxDistance': { + if (raw === null || raw === undefined || ['', '-', 'none', 'off'].includes(toText(raw))) { + return ok(null); + } + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'lineOfSight': + case 'revealPath': + case 'pingDiscoveries': + case 'hideCoveredTokens': { + const b = parseBoolean(raw); + return b === null ? bad : ok(b); + } + default: + return bad; + } + } + + /** + * Merges a possibly incomplete or invalid config with defaults. + * + * @param {object} config Config to merge. + * @param {object} [defaults] Defaults to fall back on. + * @returns {object} Complete config. + */ + function mergeConfig(config, defaults = DEFAULT_CONFIG) { + const c = isRecord(config) ? config : {}; + const merged = {}; + for (const key of Object.keys(DEFAULT_CONFIG)) { + const result = key in c ? validateConfigValue(key, c[key]) : { valid: false }; + merged[key] = result.valid ? result.value : defaults[key]; + } + return merged; + } + + /** + * Keeps only valid per-page overrides. + * + * @param {object} settings Raw page settings. + * @returns {object} Clean page settings. + */ + function mergePageSettings(settings) { + const clean = {}; + if (!isRecord(settings)) { + return clean; + } + for (const key of PAGE_SETTING_KEYS) { + if (key in settings) { + const result = validateConfigValue(key, settings[key]); + if (result.valid) { + clean[key] = result.value; + } + } + } + return clean; + } + + // --------------------------------------------------------------------------- + // State shape and migration (pure) + // --------------------------------------------------------------------------- + + /** + * Creates an empty v2 state object. + * + * @returns {object} Fresh state. + */ + function createDefaultState() { + return { + schemaVersion: SCHEMA_VERSION, + version: SCRIPT_VERSION, + config: { ...DEFAULT_CONFIG }, + pages: {}, + pendingLocations: {}, + lastFill: null, + coveredTokens: {}, + notices: {}, + }; + } + + /** + * Normalises one stored hex record. + * + * @param {string} key "row,col" key. + * @param {object} raw Stored record. + * @returns {object|null} Clean hex record, or null when unusable. + */ + function normaliseHex(key, raw) { + const coords = parseHexKey(key); + if (!coords || !isRecord(raw) || !toText(raw.id)) { + return null; + } + const hex = { + id: toText(raw.id), + type: raw.type === 'pathv2' ? 'pathv2' : raw.type === 'path' ? 'path' : null, + row: coords[0], + col: coords[1], + }; + if (toText(raw.name)) { + hex.name = toText(raw.name); + } + if (toText(raw.nameId)) { + hex.nameId = toText(raw.nameId); + } + if (toText(raw.iconId)) { + hex.iconId = toText(raw.iconId); + } + const maxDistance = validateConfigValue('maxDistance', raw.maxDistance); + if (maxDistance.valid && maxDistance.value !== null) { + hex.maxDistance = maxDistance.value; + } + if (raw.glimpsed === true) { + hex.glimpsed = true; + } + return hex; + } + + /** + * Normalises a page's stored data. + * + * @param {object} raw Stored page data. + * @returns {object} Clean page data. + */ + function normalisePage(raw) { + const page = { hexes: {}, settings: {}, calibration: null }; + if (!isRecord(raw)) { + return page; + } + if (isRecord(raw.hexes)) { + for (const [key, value] of Object.entries(raw.hexes)) { + const hex = normaliseHex(key, value); + if (hex) { + page.hexes[`${hex.row},${hex.col}`] = hex; + } + } + } + page.settings = mergePageSettings(raw.settings); + if (isRecord(raw.calibration)) { + const cal = {}; + for (const k of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(raw.calibration[k])) { + cal[k] = raw.calibration[k]; + } + } + page.calibration = Object.keys(cal).length === 4 ? cal : null; + } + return page; + } + + /** + * Converts any stored state (v1, v2 or damaged) into a clean v2 state. + * + * v1 stored hexes in `pageHexes[pageId]["row,col"]` with a parallel `hexIdMap`, + * and a flat config. Its defaults differed (no reveal distance), so missing + * v1 values fall back to v1 behaviour rather than the new defaults. + * + * @param {*} raw Stored state. + * @returns {{state: object, migratedFrom: number|null}} Clean state and the + * schema it was migrated from (null when no migration was needed). + */ + function migrateState(raw) { + const fresh = createDefaultState(); + if (!isRecord(raw)) { + return { state: fresh, migratedFrom: null }; + } + + if (isRecord(raw.pageHexes) && !isRecord(raw.pages)) { + const v1Defaults = { ...DEFAULT_CONFIG, revealDistance: 0, strokeWidth: 0 }; + fresh.config = mergeConfig(raw.config, v1Defaults); + for (const [pageId, hexes] of Object.entries(raw.pageHexes)) { + const page = normalisePage({ hexes }); + if (Object.keys(page.hexes).length > 0) { + fresh.pages[pageId] = page; + } + } + return { state: fresh, migratedFrom: 1 }; + } + + fresh.config = mergeConfig(raw.config); + if (isRecord(raw.pages)) { + for (const [pageId, page] of Object.entries(raw.pages)) { + fresh.pages[pageId] = normalisePage(page); + } + } + if (isRecord(raw.pendingLocations)) { + for (const [tokenId, pageId] of Object.entries(raw.pendingLocations)) { + if (toText(pageId)) { + fresh.pendingLocations[tokenId] = toText(pageId); + } + } + } + if (isRecord(raw.lastFill)) { + fresh.lastFill = raw.lastFill; + } + if (isRecord(raw.coveredTokens)) { + for (const [tokenId, entry] of Object.entries(raw.coveredTokens)) { + if (isRecord(entry) && toText(entry.pageId) && isRecord(entry.saved)) { + fresh.coveredTokens[tokenId] = { + pageId: toText(entry.pageId), + saved: { ...entry.saved }, + }; + } + } + } + if (isRecord(raw.notices)) { + fresh.notices = { ...raw.notices }; + } + return { state: fresh, migratedFrom: null }; + } + + // --------------------------------------------------------------------------- + // Persistent state access (Roll20) + // --------------------------------------------------------------------------- + + let pathIndex = null; + + /** + * Loads, migrates and validates the persistent state. Call once on ready. + * + * @returns {number|null} The schema migrated from, or null. + */ + function initialiseState() { + const { state: clean, migratedFrom } = migrateState(state[STATE_KEY]); + clean.version = SCRIPT_VERSION; + state[STATE_KEY] = clean; + pathIndex = null; + return migratedFrom; + } + + /** + * Returns the persistent state, creating it when missing. + * + * @returns {object} State branch. + */ + function getState() { + if (!isRecord(state[STATE_KEY]) || state[STATE_KEY].schemaVersion !== SCHEMA_VERSION) { + initialiseState(); + } + return state[STATE_KEY]; + } + + /** + * Returns the global configuration. + * + * @returns {object} Config. + */ + function getConfig() { + return getState().config; + } + + /** + * Sets one global configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setConfigValue(key, raw) { + if (!(key in DEFAULT_CONFIG)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getState().config[key] = result.value; + } + return result; + } + + /** + * Imports Roll20 One-Click useroptions into the persisted config. + * + * @returns {void} + */ + function applyGlobalConfig() { + if (typeof globalconfig === 'undefined' || !isRecord(globalconfig)) { + return; + } + const branch = globalconfig[STATE_KEY.toLowerCase()] || globalconfig[STATE_KEY]; + if (!isRecord(branch)) { + return; + } + const options = isRecord(branch.useroptions) ? branch.useroptions : branch; + const s = getState(); + // useroptions only change when the GM edits them, so remember what was last + // applied and only re-apply on change; otherwise chat changes would be + // overwritten on every restart. + const applied = isRecord(s.notices.useroptions) ? s.notices.useroptions : {}; + for (const key of ['hexLayer', 'revealBy', 'language']) { + if (key in options && options[key] !== applied[key]) { + setConfigValue(key, options[key]); + applied[key] = options[key]; + } + } + s.notices.useroptions = applied; + } + + /** + * Returns a page's stored data. + * + * @param {string} pageId Page ID. + * @param {boolean} [create=false] Create the record when missing. + * @returns {object|null} Page data. + */ + function getPageData(pageId, create = false) { + const s = getState(); + if (!s.pages[pageId] && create) { + s.pages[pageId] = { hexes: {}, settings: {}, calibration: null }; + } + return s.pages[pageId] || null; + } + + /** + * Returns the IDs of every page with stored data. + * + * @returns {string[]} Page IDs. + */ + function getPageIds() { + return Object.keys(getState().pages); + } + + /** + * Removes a page's stored data entirely. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function deletePageData(pageId) { + const s = getState(); + const page = s.pages[pageId]; + if (page && pathIndex) { + for (const hex of Object.values(page.hexes)) { + pathIndex.delete(hex.id); + } + } + delete s.pages[pageId]; + } + + /** + * Returns the settings in force on a page: global config plus page overrides. + * + * @param {string} pageId Page ID. + * @returns {object} Effective settings. + */ + function getPageSettings(pageId) { + const page = getPageData(pageId); + return { ...getConfig(), ...(page ? page.settings : {}) }; + } + + /** + * Sets a per-page override. + * + * @param {string} pageId Page ID. + * @param {string} key Setting key (must be in PAGE_SETTING_KEYS). + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setPageSetting(pageId, key, raw) { + if (!PAGE_SETTING_KEYS.includes(key)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getPageData(pageId, true).settings[key] = result.value; + } + return result; + } + + /** + * Clears all per-page overrides. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function clearPageSettings(pageId) { + const page = getPageData(pageId); + if (page) { + page.settings = {}; + } + } + + /** + * Stores or clears a page's grid calibration. + * + * @param {string} pageId Page ID. + * @param {object|null} calibration Calibration, or null to clear. + * @returns {void} + */ + function setCalibration(pageId, calibration) { + getPageData(pageId, true).calibration = calibration ? { ...calibration } : null; + } + + // --------------------------------------------------------------------------- + // Hex records + // --------------------------------------------------------------------------- + + /** + * Builds the in-memory path ID index on first use. + * + * @returns {Map} Map of path ID to [pageId, key]. + */ + function getIndex() { + if (!pathIndex) { + pathIndex = new Map(); + for (const [pageId, page] of Object.entries(getState().pages)) { + for (const [key, hex] of Object.entries(page.hexes)) { + pathIndex.set(hex.id, [pageId, key]); + } + } + } + return pathIndex; + } + + /** + * Returns a hex record. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} Hex record. + */ + function getHex(pageId, key) { + return getPageData(pageId)?.hexes[key] || null; + } + + /** + * Returns every hex record on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Hex records. + */ + function getPageHexes(pageId) { + const page = getPageData(pageId); + return page ? Object.values(page.hexes) : []; + } + + /** + * Returns the hex record drawn by a path, with its page. + * + * @param {string} pathId Path object ID. + * @returns {{pageId: string, key: string, hex: object}|null} Lookup result. + */ + function getHexByPathId(pathId) { + const entry = getIndex().get(pathId); + if (!entry) { + return null; + } + const [pageId, key] = entry; + const hex = getHex(pageId, key); + return hex ? { pageId, key, hex } : null; + } + + /** + * Stores a hex record, replacing any record at the same cell. + * + * @param {string} pageId Page ID. + * @param {object} hex Hex record with row and col. + * @returns {object} The stored record. + */ + function putHex(pageId, hex) { + const key = `${hex.row},${hex.col}`; + const page = getPageData(pageId, true); + const old = page.hexes[key]; + if (old && old.id !== hex.id) { + getIndex().delete(old.id); + } + page.hexes[key] = hex; + getIndex().set(hex.id, [pageId, key]); + return hex; + } + + /** + * Removes a hex record (not its Roll20 objects). + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} The removed record. + */ + function deleteHexRecord(pageId, key) { + const page = getPageData(pageId); + const hex = page?.hexes[key]; + if (!hex) { + return null; + } + delete page.hexes[key]; + getIndex().delete(hex.id); + return hex; + } + + // --------------------------------------------------------------------------- + // Pending locations and undo + // --------------------------------------------------------------------------- + + /** + * Returns pending location token IDs on a page (tokens marked as locations + * before the area under them was filled). + * + * @param {string} pageId Page ID. + * @returns {string[]} Token IDs. + */ + function getPendingLocations(pageId) { + return Object.entries(getState().pendingLocations) + .filter(([, page]) => page === pageId) + .map(([tokenId]) => tokenId); + } + + /** + * Adds or removes a pending location. + * + * @param {string} tokenId Token ID. + * @param {string|null} pageId Page ID, or null to remove. + * @returns {void} + */ + function setPendingLocation(tokenId, pageId) { + const pending = getState().pendingLocations; + if (pageId) { + pending[tokenId] = pageId; + } else { + delete pending[tokenId]; + } + } + + /** + * Returns the record of the last fill, used by undo. + * + * @returns {object|null} Last fill record. + */ + function getLastFill() { + return getState().lastFill; + } + + /** + * Stores or clears the record of the last fill. + * + * @param {object|null} record Fill record. + * @returns {void} + */ + function setLastFill(record) { + getState().lastFill = record; + } + + /** + * Returns the saved player-visible properties of tokens hidden under hexes. + * + * @returns {object} Map of token ID to { pageId, saved }. + */ + function getCoveredTokens() { + return getState().coveredTokens; + } + + /** + * Builds the hex grid for a page, including any calibration. + * + * @param {object} page Roll20 page. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function buildPageGrid(page) { + const pageId = page.get('_id'); + return createGrid({ + gridType: page.get('grid_type'), + // snapping_increment is 0 when snapping is off; the grid is still drawn at 1 unit. + scale: Number(page.get('snapping_increment')) || 1, + jumpgate: isJumpgate(), + // Set by Jumpgate's map alignment tool. + offsetX: Number(page.get('grid_offset_x')) || 0, + offsetY: Number(page.get('grid_offset_y')) || 0, + calibration: getPageData(pageId)?.calibration || null, + }); + } + + /** + * Returns everything needed to work on a page's hexes. + * + * @param {string} pageId Page ID. + * @returns {{ok: true, pageId: string, page: object, grid: object}|{ok: false, reason: string}} + * Context, or the reason it is unavailable ('noPage' or 'notHex'). + */ + function getPageContext(pageId) { + const page = pageId ? getObj('page', pageId) : null; + if (!page) { + return { ok: false, reason: 'noPage' }; + } + const grid = buildPageGrid(page); + if (!grid) { + return { ok: false, reason: 'notHex' }; + } + return { ok: true, pageId, page, grid }; + } + + // Hiding tokens' player-visible details while they are under a hex. + // + // Hexes hide the token image, but Roll20 draws nameplates, bars and auras + // above the foreground layer, so a monster under a hex would still give its + // position away. While a token's centre is under a covered (not glimpsed) hex, + // its player-visible flags are switched off; the saved values are restored + // when it is uncovered, moved out, or the setting is turned off. + + /** + * Returns true when a token's centre is under a covered hex. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @returns {boolean} True when covered. + */ + function isCovered(ctx, token) { + if (token.get('layer') !== LAYER_TOKEN || token.get('_subtype') !== 'token') { + return false; + } + const [row, col] = pixelToHex(ctx.grid, Number(token.get('left')), Number(token.get('top'))); + const hex = getHex(ctx.pageId, hexKey(row, col)); + return !!hex && !hex.glimpsed; + } + + /** + * Switches a token's player-visible details off, saving their values. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function hideDetails(token) { + const covered = getCoveredTokens(); + const id = token.get('_id'); + if (covered[id]) { + return; + } + const saved = {}; + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + saved[prop] = token.get(prop) === true; + updates[prop] = false; + } + covered[id] = { pageId: token.get('_pageid'), saved }; + token.set(updates); + } + + /** + * Restores a token's saved player-visible details. + * + * @param {string} tokenId Token ID. + * @returns {void} + */ + function restoreDetails(tokenId) { + const covered = getCoveredTokens(); + const entry = covered[tokenId]; + if (!entry) { + return; + } + delete covered[tokenId]; + const token = getObj('graphic', tokenId); + if (token) { + token.set({ ...entry.saved }); + } + } + + /** + * Keeps a covered token's details hidden when the GM switches one on while it + * is covered: the new value is saved for when the token is uncovered. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleCoveredChange(token, prev) { + const entry = getCoveredTokens()[token.get('_id')]; + if (!entry || !prev) { + return; + } + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + if (token.get(prop) === true && prev[prop] !== true) { + entry.saved[prop] = true; + updates[prop] = false; + } + } + if (Object.keys(updates).length > 0) { + token.set(updates); + } + } + + /** + * Hides or restores one token's details to match whether it is covered. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function refreshToken(token) { + const ctx = getPageContext(token.get('_pageid')); + if (getConfig().hideCoveredTokens && ctx.ok && isCovered(ctx, token)) { + hideDetails(token); + } else { + restoreDetails(token.get('_id')); + } + } + + /** + * Hides or restores the details of every token on a page. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function refreshPage(pageId) { + const ctx = getPageContext(pageId); + const enabled = getConfig().hideCoveredTokens && ctx.ok; + const covered = getCoveredTokens(); + for (const token of findObjs({ _type: 'graphic', _pageid: pageId, _subtype: 'token' })) { + if (enabled && isCovered(ctx, token)) { + hideDetails(token); + } else if (covered[token.get('_id')]) { + restoreDetails(token.get('_id')); + } + } + // Forget tokens that were deleted while hidden. + for (const [tokenId, entry] of Object.entries(covered)) { + if (entry.pageId === pageId && !getObj('graphic', tokenId)) { + delete covered[tokenId]; + } + } + } + + /** + * Restores every hidden token in the game (used when the setting is turned off). + * + * @returns {void} + */ + function restoreAll() { + for (const tokenId of Object.keys(getCoveredTokens())) { + restoreDetails(tokenId); + } + } + + // Named hexes and hidden location tokens. + // + // A hex can carry a name (shown to the GM as a label on the GM layer) and an + // icon (a token hidden on the GM layer). Both are announced when the hex is + // revealed, and the icon is moved back to the token layer. + + /** + * Returns the token attached to a hex as its icon, if it still exists. + * + * @param {object} hex Hex record. + * @returns {object|null} Roll20 graphic. + */ + function getHexIcon(hex) { + return hex.iconId ? getObj('graphic', hex.iconId) || null : null; + } + + /** + * Returns the name announced when a hex is discovered: the icon's name, or + * the hex's own name. + * + * @param {object} hex Hex record. + * @returns {string} Discovery name (empty when the hex is unnamed). + */ + function getDiscoveryName(hex) { + const icon = getHexIcon(hex); + return toText(icon?.get('name')) || toText(hex.name); + } + + /** + * Removes a hex's GM-layer name label. + * + * @param {object} hex Hex record. + * @returns {void} + */ + function removeLabel(hex) { + if (hex.nameId) { + getObj('text', hex.nameId)?.remove(); + delete hex.nameId; + } + } + + /** + * Sets or clears a hex's name and redraws its GM-layer label. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record. + * @param {string} name New name (empty to clear). + * @returns {void} + */ + function setHexName(ctx, hex, name) { + removeLabel(hex); + const clean = toText(name).slice(0, MAX_NAME_LENGTH); + if (!clean) { + delete hex.name; + return; + } + hex.name = clean; + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + const label = createObj('text', { + _pageid: ctx.pageId, + layer: LAYER_GM, + left: x, + top: y, + text: clean, + color: getConfig().labelColor, + }); + if (label) { + hex.nameId = label.get('_id'); + } + } + + /** + * Attaches a token to a hex as its hidden icon. + * + * @param {object} hex Hex record. + * @param {object} token Roll20 graphic. + * @returns {string} The token's layer before it was hidden (for undo). + */ + function attachIcon(hex, token) { + const previousLayer = token.get('layer'); + hex.iconId = token.get('_id'); + token.set('layer', LAYER_GM); + setPendingLocation(hex.iconId, null); + return previousLayer; + } + + /** + * Detaches a hex's icon and returns it to the token layer. + * + * @param {object} hex Hex record. + * @param {boolean} [show=true] Move the icon back to the token layer. + * @returns {void} + */ + function detachIcon(hex, show = true) { + const icon = getHexIcon(hex); + if (icon && show) { + icon.set('layer', LAYER_TOKEN); + } + delete hex.iconId; + } + + /** + * Returns the hex records on a page keyed by the ID of their icon. + * + * @param {string} pageId Page ID. + * @returns {Map} Map of icon ID to hex record. + */ + function hexesByIcon(pageId) { + const map = new Map(); + for (const hex of getPageHexes(pageId)) { + if (hex.iconId) { + map.set(hex.iconId, hex); + } + } + return map; + } + + /** + * Returns location tokens waiting for a hex on a page, keyed by hex cell: + * tokens marked with `mark`, plus (as in v1) tokens with the white-tower + * status marker. Tokens already attached to a hex are ignored. + * + * @param {object} ctx Page context. + * @returns {Map} Map of "row,col" to Roll20 graphic. + */ + function findLocationTokens(ctx) { + const attached = hexesByIcon(ctx.pageId); + const tokens = new Map(); + const consider = (token) => { + if (!token || attached.has(token.get('_id'))) { + return; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + tokens.set(hexKey(row, col), token); + }; + + for (const tokenId of getPendingLocations(ctx.pageId)) { + const token = getObj('graphic', tokenId); + if (token) { + consider(token); + } else { + setPendingLocation(tokenId, null); + } + } + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId })) { + if (tokenHasMarker(token, LOCATION_MARKER)) { + consider(token); + } + } + return tokens; + } + + /** + * Marks tokens as hidden locations. A token already under a hex is attached + * immediately; otherwise it waits for the next fill that covers it. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {{attached: number, pending: number}} Counts. + */ + function markLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + let attachedCount = 0; + let pendingCount = 0; + for (const token of tokens) { + if (attached.has(token.get('_id'))) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + attachIcon(hex, token); + attachedCount++; + } else { + setPendingLocation(token.get('_id'), ctx.pageId); + pendingCount++; + } + } + return { attached: attachedCount, pending: pendingCount }; + } + + /** + * Stops tokens being hidden locations. Attached tokens return to the token layer. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number} Number of tokens unmarked. + */ + function unmarkLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + const pending = new Set(getPendingLocations(ctx.pageId)); + let count = 0; + for (const token of tokens) { + const id = token.get('_id'); + const hex = attached.get(id); + if (hex) { + detachIcon(hex); + count++; + } else if (pending.has(id)) { + setPendingLocation(id, null); + count++; + } + } + return count; + } + + // Polygon maths for Roll20 drawn shapes. Pure functions only: callers pass + // plain property objects, so the module can be unit tested in Node. + // + // Both kinds of Roll20 path store points relative to their own bounding box + // and are placed by their centre: + // - Legacy `path`: `_path` is a JSON list of SVG-like commands (M, L, Q, C), + // placed by left/top, sized by width/height, scaled by scaleX/scaleY. + // - Jumpgate `pathv2`: `points` is a JSON list of [x, y] pairs interpreted by + // `shape` (pol, free, rec, eli) and placed by x/y. It has no scale. + // Both can be rotated by `rotation` degrees about their centre. + + const UNIT_PX = 70; + const ELLIPSE_SEGMENTS = 32; + const CURVE_SEGMENTS = 8; + + /** + * Returns the bounding box of a list of points. + * + * @param {number[][]} points Array of [x, y]. + * @returns {{left: number, top: number, right: number, bottom: number}} Bounding box. + */ + function boundingBox(points) { + let left = Infinity; + let top = Infinity; + let right = -Infinity; + let bottom = -Infinity; + for (const [x, y] of points) { + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x); + bottom = Math.max(bottom, y); + } + return { left, top, right, bottom }; + } + + /** + * Tests whether a point lies inside a polygon ring (even-odd rule). The ring + * is treated as closed whether or not its last point repeats the first. + * + * @param {number[]} point [x, y]. + * @param {number[][]} ring Array of [x, y]. + * @returns {boolean} True when inside. + */ + function pointInRing(point, ring) { + const [x, y] = point; + let inside = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const [xi, yi] = ring[i]; + const [xj, yj] = ring[j]; + const crosses = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi; + if (crosses) { + inside = !inside; + } + } + return inside; + } + + /** + * Tests whether a point lies inside any of a shape's rings (even-odd across + * rings, so a ring drawn inside another makes a hole). + * + * @param {number[]} point [x, y]. + * @param {number[][][]} rings Array of rings. + * @returns {boolean} True when inside. + */ + function pointInShape(point, rings) { + let inside = false; + for (const ring of rings) { + if (ring.length >= 3 && pointInRing(point, ring)) { + inside = !inside; + } + } + return inside; + } + + /** + * Builds a transform from path-local coordinates to page pixels. + * + * @param {object} t Transform values. + * @returns {(x: number, y: number) => number[]} Point transform. + */ + function makeTransform({ width, height, cx, cy, scaleX = 1, scaleY = 1, rotation = 0 }) { + const angle = ((Number(rotation) || 0) * Math.PI) / 180; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + return (x, y) => { + const lx = (x - width / 2) * scaleX; + const ly = (y - height / 2) * scaleY; + return [cx + lx * cos - ly * sin, cy + lx * sin + ly * cos]; + }; + } + + /** + * Samples a quadratic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 Control point. + * @param {number[]} p2 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleQuadratic(p0, p1, p2) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + points.push([ + u * u * p0[0] + 2 * u * t * p1[0] + t * t * p2[0], + u * u * p0[1] + 2 * u * t * p1[1] + t * t * p2[1], + ]); + } + return points; + } + + /** + * Samples a cubic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 First control point. + * @param {number[]} p2 Second control point. + * @param {number[]} p3 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleCubic(p0, p1, p2, p3) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + const a = u * u * u; + const b = 3 * u * u * t; + const c = 3 * u * t * t; + const d = t * t * t; + points.push([ + a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], + a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1], + ]); + } + return points; + } + + /** + * Converts a Legacy path's command list into rings in path-local coordinates. + * + * @param {Array[]} commands Parsed `_path` commands. + * @returns {number[][][]} Rings. + */ + function legacyCommandsToRings(commands) { + const rings = []; + let ring = []; + let prevType = null; + for (const cmd of commands) { + if (!Array.isArray(cmd)) { + continue; + } + const [type, ...args] = cmd; + const nums = args.map(Number); + const prev = ring.at(-1); + if (type === 'M' && prevType !== 'M') { + if (ring.length > 0) { + rings.push(ring); + } + ring = [[nums[0], nums[1]]]; + } else if (type === 'L' || type === 'M') { + // Two consecutive Ms are drawn by Roll20 as a line, so treat the second as L. + ring.push([nums[0], nums[1]]); + } else if (type === 'Q' && prev) { + ring.push(...sampleQuadratic(prev, [nums[0], nums[1]], [nums[2], nums[3]])); + } else if (type === 'C' && prev) { + ring.push(...sampleCubic(prev, [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]])); + } + prevType = type; + } + if (ring.length > 0) { + rings.push(ring); + } + return rings; + } + + /** + * Returns points approximating an ellipse inside a box. + * + * @param {number} width Box width. + * @param {number} height Box height. + * @returns {number[][]} Points in box-local coordinates. + */ + function ellipsePoints(width, height) { + const points = []; + for (let i = 0; i < ELLIPSE_SEGMENTS; i++) { + const angle = (i / ELLIPSE_SEGMENTS) * Math.PI * 2; + points.push([ + width / 2 + (Math.cos(angle) * width) / 2, + height / 2 + (Math.sin(angle) * height) / 2, + ]); + } + return points; + } + + /** + * Parses a JSON string, returning null on failure. + * + * @param {string} text JSON text. + * @returns {*} Parsed value, or null. + */ + function safeJson(text) { + try { + return JSON.parse(text); + } catch { + return null; + } + } + + /** + * Converts a Legacy path's properties into page-space rings. + * + * @param {object} props Path properties (_path, left, top, width, height, scaleX, scaleY, rotation). + * @param {object} [page] Page size in units ({ width, height }) for mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function legacyPathToRings(props, page = {}) { + const raw = String(props._path || props.path || '') + .replaceAll('mapWidth', String((Number(page.width) || 0) * UNIT_PX)) + .replaceAll('mapHeight', String((Number(page.height) || 0) * UNIT_PX)); + const commands = safeJson(raw); + if (!Array.isArray(commands)) { + return []; + } + const transform = makeTransform({ + width: Number(props.width) || 0, + height: Number(props.height) || 0, + cx: Number(props.left) || 0, + cy: Number(props.top) || 0, + scaleX: Number(props.scaleX) || 1, + scaleY: Number(props.scaleY) || 1, + rotation: props.rotation, + }); + return legacyCommandsToRings(commands).map((ring) => ring.map(([x, y]) => transform(x, y))); + } + + /** + * Converts a Jumpgate pathv2's properties into page-space rings. + * + * @param {object} props Path properties (points, shape, x, y, rotation). + * @returns {number[][][]} Rings in page pixels. + */ + function pathV2ToRings(props) { + const parsed = safeJson(props.points); + if (!Array.isArray(parsed) || parsed.length === 0) { + return []; + } + const raw = parsed + .filter((p) => Array.isArray(p) && p.length >= 2) + .map(([x, y]) => [Number(x), Number(y)]) + .filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)); + if (raw.length === 0) { + return []; + } + + // Points are normalised so the bounding box starts at 0,0. + const box = boundingBox(raw); + const local = raw.map(([x, y]) => [x - box.left, y - box.top]); + const width = box.right - box.left; + const height = box.bottom - box.top; + + let ring; + if (props.shape === 'rec') { + ring = [ + [0, 0], + [width, 0], + [width, height], + [0, height], + ]; + } else if (props.shape === 'eli') { + ring = ellipsePoints(width, height); + } else { + ring = local; + } + + const transform = makeTransform({ + width, + height, + cx: Number(props.x) || 0, + cy: Number(props.y) || 0, + rotation: props.rotation, + }); + return [ring.map(([x, y]) => transform(x, y))]; + } + + /** + * Converts either kind of path into page-space rings. + * + * @param {object} props Path properties including `type` ('path' or 'pathv2'). + * @param {object} [page] Page size in units, for Legacy mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function pathToRings(props, page) { + if (props.type === 'pathv2') { + return pathV2ToRings(props); + } + return legacyPathToRings(props, page); + } + + /** + * Builds the properties for a closed polygon as either kind of path. + * Points are made relative to their bounding box, and the path is placed by + * its centre, matching how Roll20 stores both path types. + * + * @param {number[][]} points Polygon corners in page pixels. + * @param {boolean} jumpgate True to build a pathv2, false for a Legacy path. + * @returns {object} Geometry properties for createObj. + */ + function polygonPathProps(points, jumpgate) { + const box = boundingBox(points); + const width = box.right - box.left; + const height = box.bottom - box.top; + const cx = box.left + width / 2; + const cy = box.top + height / 2; + const round = (n) => Math.round(n * 1000) / 1000; + const local = points.map(([x, y]) => [round(x - box.left), round(y - box.top)]); + const closed = [...local, local[0]]; + + if (jumpgate) { + return { + shape: 'pol', + points: JSON.stringify(closed), + x: cx, + y: cy, + }; + } + + const commands = closed.map(([x, y], i) => [i === 0 ? 'M' : 'L', x, y]); + return { + _path: JSON.stringify(commands), + left: cx, + top: cy, + width, + height, + }; + } + + /** + * Returns the centroid of a ring's distinct vertices. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[]} [x, y]. + */ + function ringCentre(ring) { + const pts = distinctVertices(ring); + const sum = pts.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [0, 0]); + return [sum[0] / pts.length, sum[1] / pts.length]; + } + + /** + * Returns a ring's vertices with a repeated closing point removed. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[][]} Distinct vertices. + */ + function distinctVertices(ring) { + if (ring.length > 1) { + const first = ring[0]; + const last = ring.at(-1); + if (Math.abs(first[0] - last[0]) < 0.01 && Math.abs(first[1] - last[1]) < 0.01) { + return ring.slice(0, -1); + } + } + return ring; + } + + // Roll20 object access for drawn shapes. Jumpgate games draw `pathv2` + // objects; Legacy games draw `path` objects. Everything that reads or writes a + // path goes through this module so the rest of the mod never cares which. + + // Set when the foreground layer turns out to be unavailable, so later hexes + // go straight to the token layer instead of failing one by one. + let foregroundUnavailable = false; + + /** + * Returns a path object of either type by ID. + * + * @param {string} id Object ID. + * @param {string|null} [type] Known type, checked first. + * @returns {object|null} Roll20 path or pathv2 object. + */ + function getPathObject(id, type = null) { + if (!id) { + return null; + } + const types = activePathTypes(); + const order = type && types.includes(type) ? [type, ...types.filter((t) => t !== type)] : types; + for (const t of order) { + const obj = getObj(t, id); + if (obj) { + return obj; + } + } + return null; + } + + /** + * Returns true when a Roll20 object is a path of either type. + * + * @param {object} obj Roll20 object. + * @returns {boolean} True for path and pathv2. + */ + function isPathObject(obj) { + return !!obj && PATH_TYPES.includes(obj.get('_type')); + } + + /** + * Returns a colour in a form the given path type accepts. + * + * @param {string} color Colour from the settings. + * @param {string} type Path type. + * @returns {string} Colour to write. + */ + function pathColor(color, type) { + return type === PATH_TYPE_V2 ? toPathV2Color(color) : color; + } + + /** + * Sets a path's colours, converting them for Jumpgate pathv2 objects. + * + * @param {object} obj Roll20 path or pathv2. + * @param {object} attrs Attributes to set; `fill` and `stroke` are converted. + * @returns {void} + */ + function setPathStyle(obj, attrs) { + const type = obj.get('_type'); + const converted = { ...attrs }; + for (const key of ['fill', 'stroke']) { + if (key in converted) { + converted[key] = pathColor(converted[key], type); + } + } + obj.set(converted); + } + + /** + * Copies the properties the polygon module needs from a path. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {object} Plain properties including `type`. + */ + function readPathProps(obj) { + const type = obj.get('_type'); + const base = { + type, + pageId: obj.get('_pageid'), + layer: obj.get('layer'), + rotation: obj.get('rotation'), + fill: obj.get('fill'), + stroke: obj.get('stroke'), + stroke_width: obj.get('stroke_width'), + }; + if (type === PATH_TYPE_V2) { + return { + ...base, + shape: obj.get('shape'), + points: obj.get('points'), + x: obj.get('x'), + y: obj.get('y'), + }; + } + return { + ...base, + _path: obj.get('_path'), + left: obj.get('left'), + top: obj.get('top'), + width: obj.get('width'), + height: obj.get('height'), + scaleX: obj.get('scaleX'), + scaleY: obj.get('scaleY'), + }; + } + + /** + * Returns a path's outline as page-space rings. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {number[][][]} Rings. + */ + function getPathRings(obj) { + const props = readPathProps(obj); + const page = getObj('page', props.pageId); + return pathToRings(props, page ? { width: page.get('width'), height: page.get('height') } : {}); + } + + /** + * Recreates a path from properties saved by readPathProps (used by undo). + * + * @param {object} props Saved properties. + * @returns {object|null} New Roll20 object. + */ + function recreatePath(props) { + const { type, pageId, ...rest } = props; + const attrs = { _pageid: pageId }; + for (const [key, value] of Object.entries(rest)) { + if (value !== undefined && value !== null) { + attrs[key] = value; + } + } + // A Legacy game cannot create pathv2 objects, and vice versa. + const createType = type === PATH_TYPE_V2 && !isJumpgate() ? PATH_TYPE_LEGACY : type; + return createObj(createType, attrs) || null; + } + + /** + * Returns the layer new hexes should be drawn on. + * + * @returns {string} Roll20 layer. + */ + function getHexLayer() { + const setting = getConfig().hexLayer; + if (setting === 'objects' || foregroundUnavailable) { + return LAYER_TOKEN; + } + return LAYER_FOREGROUND; + } + + /** + * Draws a hex outline as a path. + * + * The foreground layer is tried first (unless the GM chose the token layer); + * if the game rejects it, the hex is drawn on the token layer instead and the + * fallback is remembered for the rest of the session. + * + * @param {string} pageId Page ID. + * @param {number[][]} corners Hex corners in page pixels. + * @param {object} style Style with fill, stroke and strokeWidth. + * @returns {{obj: object, fellBack: boolean}|null} New path, or null when it could not be created. + */ + function createHexPath(pageId, corners, style) { + const jumpgate = isJumpgate(); + const type = jumpgate ? PATH_TYPE_V2 : PATH_TYPE_LEGACY; + const geometry = polygonPathProps(corners, jumpgate); + const attrs = { + ...geometry, + _pageid: pageId, + fill: pathColor(style.fill, type), + stroke: pathColor(style.stroke, type), + stroke_width: style.strokeWidth, + controlledby: '', + }; + + const layer = getHexLayer(); + let obj = createObj(type, { ...attrs, layer }); + if (obj && obj.get('layer') === layer) { + return { obj, fellBack: false }; + } + + if (layer === LAYER_FOREGROUND) { + if (obj) { + obj.remove(); + } + foregroundUnavailable = true; + obj = createObj(type, { ...attrs, layer: LAYER_TOKEN }); + return obj ? { obj, fellBack: true } : null; + } + return obj ? { obj, fellBack: false } : null; + } + + /** + * Removes a Roll20 object if it still exists. + * + * @param {object|null} obj Roll20 object. + * @returns {void} + */ + function safeRemove(obj) { + if (obj) { + try { + obj.remove(); + } catch (err) { + log(`Hexploration: could not remove object: ${err?.message || err}`); + } + } + } + + /** + * Returns every path of either type on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Roll20 path objects. + */ + function getPagePaths(pageId) { + return activePathTypes().flatMap((type) => findObjs({ _type: type, _pageid: pageId })); + } + + /** + * Returns the path types that can exist in this game. Jumpgate games can + * hold both (old API-made paths survive); Legacy games only have `path`. + * + * @returns {string[]} Path types. + */ + function activePathTypes() { + return isJumpgate() ? PATH_TYPES : [PATH_TYPE_LEGACY]; + } + + // Creating, removing and maintaining hexes on a page: fill, inverse fill, + // conceal, reset, rescan, calibrate and undo. + + /** + * Returns the hex style from the current config. + * + * @returns {{fill: string, stroke: string, strokeWidth: number, maxDistance: number|null}} Style. + */ + function currentStyle() { + const config = getConfig(); + return { + fill: config.fillColor, + stroke: config.strokeColor, + strokeWidth: config.strokeWidth, + maxDistance: config.maxDistance, + }; + } + + /** + * Draws one hex and stores its record. + * + * @param {object} ctx Page context. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {object} style Hex style. + * @param {object} [extra] Extra record fields (name, iconId…). + * @returns {{hex: object, fellBack: boolean}|null} New record, or null on failure. + */ + function drawHex(ctx, row, col, style, extra = {}) { + const created = createHexPath(ctx.pageId, hexCorners(ctx.grid, row, col), style); + if (!created) { + return null; + } + const hex = { id: created.obj.get('_id'), type: created.obj.get('_type'), row, col, ...extra }; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } + putHex(ctx.pageId, hex); + return { hex, fellBack: created.fellBack }; + } + + /** + * Removes a hex: its record, its path and its name label. Its icon is moved + * back to the token layer when `showIcon` is true, otherwise left hidden. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @param {boolean} [showIcon=false] Return the icon to the token layer. + * @returns {object|null} The removed record. + */ + function removeHex(pageId, key, showIcon = false) { + const hex = deleteHexRecord(pageId, key); + if (!hex) { + return null; + } + removeLabel(hex); + if (showIcon) { + detachIcon(hex); + } + safeRemove(getPathObject(hex.id, hex.type)); + return hex; + } + + /** + * Returns the cells whose centres lie inside any of the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects on the page. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function cellsInPaths(ctx, paths) { + const seen = new Set(); + const cells = []; + for (const path of paths) { + const rings = getPathRings(path); + if (rings.length === 0) { + continue; + } + const box = boundingBox(rings.flat()); + for (const [row, col] of hexesInBox(ctx.grid, box)) { + const key = hexKey(row, col); + if (!seen.has(key) && pointInShape(hexToPixel(ctx.grid, row, col), rings)) { + seen.add(key); + cells.push([row, col]); + } + } + } + return cells; + } + + /** + * Returns every cell on the page except those inside the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects to leave uncovered. + * @returns {number[][]} Array of [row, col]. + */ + function cellsOutsidePaths(ctx, paths) { + const omit = new Set(cellsInPaths(ctx, paths).map(([r, c]) => hexKey(r, c))); + const width = Number(ctx.page.get('width')) * 70; + const height = Number(ctx.page.get('height')) * 70; + return hexesCoveringPage(ctx.grid, width, height).filter(([r, c]) => !omit.has(hexKey(r, c))); + } + + /** + * Covers cells with hexes. Existing hexes are restyled rather than replaced, + * so their names and icons are kept. Location tokens in a covered cell are + * attached as icons. Work is batched; `onDone` receives a summary. + * + * @param {object} ctx Page context. + * @param {number[][]} cells Cells to cover. + * @param {object} options Fill options. + * @param {object[]} [options.sources] Saved properties of the polygons used (for undo). + * @param {string} options.kind Fill kind for undo ('fill', 'fillInverse', 'conceal'). + * @param {(summary: object) => void} options.onDone Completion callback. + * @returns {{started: boolean, reason?: string}} Whether the fill started. + */ + function fillCells(ctx, cells, { sources = [], kind, onDone }) { + if (cells.length > MAX_FILL_HEXES) { + return { started: false, reason: 'tooMany' }; + } + + const style = currentStyle(); + const locations = findLocationTokens(ctx); + const record = { + pageId: ctx.pageId, + kind, + time: Date.now(), + created: [], + restyled: [], + icons: [], + sources, + }; + const summary = { created: 0, restyled: 0, icons: 0, failed: 0, fellBack: false }; + + runInBatches( + cells, + BATCH_SIZE, + ([row, col]) => { + const key = hexKey(row, col); + let hex = getHex(ctx.pageId, key); + const existingPath = hex ? getPathObject(hex.id, hex.type) : null; + + if (hex && existingPath) { + record.restyled.push({ + key, + fill: existingPath.get('fill'), + stroke: existingPath.get('stroke'), + strokeWidth: existingPath.get('stroke_width'), + maxDistance: hex.maxDistance ?? null, + glimpsed: hex.glimpsed === true, + }); + setPathStyle(existingPath, { + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + }); + delete hex.glimpsed; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } else { + delete hex.maxDistance; + } + summary.restyled++; + } else { + if (hex) { + // The record outlived its path (deleted while the API was off). + deleteHexRecord(ctx.pageId, key); + } + const drawn = drawHex(ctx, row, col, style); + if (!drawn) { + summary.failed++; + return; + } + hex = drawn.hex; + summary.fellBack = summary.fellBack || drawn.fellBack; + record.created.push({ key, id: hex.id }); + summary.created++; + } + + const token = locations.get(key); + if (token && !hex.iconId) { + record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + attachIcon(hex, token); + summary.icons++; + } + }, + (errors) => { + summary.failed += errors; + setLastFill(record); + onDone(summary); + } + ); + + return { started: true }; + } + + /** + * Removes every hex on a page, returning icons to the token layer. Page + * settings and calibration are kept. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function clearPage(ctx, onDone) { + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + for (const tokenId of getPendingLocations(ctx.pageId)) { + setPendingLocation(tokenId, null); + } + const last = getLastFill(); + if (last?.pageId === ctx.pageId) { + setLastFill(null); + } + runInBatches( + keys, + BATCH_SIZE, + (key) => removeHex(ctx.pageId, key, true), + () => onDone(keys.length) + ); + } + + /** + * Reverses the last fill: removes the hexes it created, restores the style + * of hexes it restyled, returns icons it hid, and redraws the polygons it used. + * + * @returns {{ok: boolean, reason?: string, removed?: number, restored?: number, pageId?: string}} Result. + */ + function undoLastFill() { + const record = getLastFill(); + if (!record) { + return { ok: false, reason: 'nothingToUndo' }; + } + setLastFill(null); + const page = getObj('page', record.pageId); + if (!page) { + return { ok: false, reason: 'noPage' }; + } + + let removed = 0; + for (const { key, id } of record.created || []) { + const hex = getHex(record.pageId, key); + if (hex && hex.id === id) { + removeHex(record.pageId, key, false); + removed++; + } + } + + let restored = 0; + for (const prev of record.restyled || []) { + const hex = getHex(record.pageId, prev.key); + const path = hex ? getPathObject(hex.id, hex.type) : null; + if (path) { + setPathStyle(path, { + fill: prev.fill, + stroke: prev.stroke, + stroke_width: prev.strokeWidth, + }); + if (Number.isInteger(prev.maxDistance)) { + hex.maxDistance = prev.maxDistance; + } else { + delete hex.maxDistance; + } + if (prev.glimpsed) { + hex.glimpsed = true; + } + restored++; + } + } + + for (const { id, layer } of record.icons || []) { + const token = getObj('graphic', id); + if (token) { + for (const hex of getPageHexes(record.pageId)) { + if (hex.iconId === id) { + delete hex.iconId; + } + } + token.set('layer', layer || LAYER_TOKEN); + } + } + + for (const props of record.sources || []) { + recreatePath(props); + } + + return { ok: true, removed, restored, pageId: record.pageId }; + } + + /** + * Captures the polygons used for a fill so undo can redraw them, then deletes them. + * + * @param {object[]} paths Roll20 path objects. + * @returns {object[]} Saved properties. + */ + function consumeSourcePaths(paths) { + // A selected path may itself be a hex; only plain drawings are consumed. + const drawings = paths.filter((path) => !getHexByPathId(path.get('_id'))); + const sources = drawings.map(readPathProps); + for (const path of drawings) { + safeRemove(path); + } + return sources; + } + + /** + * Returns the hex a path draws, judged by its shape: a six-cornered polygon + * centred on a hex cell and roughly the size of a hex. + * + * @param {object} ctx Page context. + * @param {object} path Roll20 path object. + * @returns {number[]|null} [row, col], or null when the path is not a hex. + */ + function matchHexShape(ctx, path) { + const rings = getPathRings(path); + if (rings.length !== 1) { + return null; + } + const vertices = distinctVertices(rings[0]); + if (vertices.length !== 6) { + return null; + } + const [x, y] = ringCentre(vertices); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + if (Math.hypot(x - cx, y - cy) > ctx.grid.colStep * RESCAN_CENTRE_TOLERANCE) { + return null; + } + const actual = boundingBox(vertices); + const expected = boundingBox(hexCorners(ctx.grid, row, col)); + const ratioW = (actual.right - actual.left) / (expected.right - expected.left); + const ratioH = (actual.bottom - actual.top) / (expected.bottom - expected.top); + if (ratioW < 0.75 || ratioW > 1.25 || ratioH < 0.75 || ratioH > 1.25) { + return null; + } + return [row, col]; + } + + /** + * Rebuilds a page's hex list from what is actually on the page: + * - drops records whose path is gone, and label/icon links that are broken; + * - re-files hexes whose cell changed (after calibration); + * - adopts hex-shaped paths the mod does not know about (duplicated pages, + * Legacy games copied to Jumpgate); + * - re-links GM-layer labels and white-tower icons sitting on hexes. + * + * @param {object} ctx Page context. + * @returns {{kept: number, dropped: number, moved: number, adopted: number, labels: number, icons: number}} Counts. + */ + function rescanPage(ctx) { + const counts = { kept: 0, dropped: 0, moved: 0, adopted: 0, labels: 0, icons: 0 }; + const pageData = getPageData(ctx.pageId, true); + + // 1. Check existing records. + for (const hex of Object.values(pageData.hexes)) { + const key = hexKey(hex.row, hex.col); + const path = getPathObject(hex.id, hex.type); + if (!path) { + removeLabel(hex); + deleteHexRecord(ctx.pageId, key); + counts.dropped++; + continue; + } + hex.type = path.get('_type'); + if (hex.nameId && !getObj('text', hex.nameId)) { + delete hex.nameId; + } + if (hex.iconId && !getHexIcon(hex)) { + delete hex.iconId; + } + const cell = matchHexShape(ctx, path); + if ( + cell && + hexKey(cell[0], cell[1]) !== key && + !getHex(ctx.pageId, hexKey(cell[0], cell[1])) + ) { + deleteHexRecord(ctx.pageId, key); + putHex(ctx.pageId, { ...hex, row: cell[0], col: cell[1] }); + counts.moved++; + } else { + counts.kept++; + } + } + + // 2. Adopt unknown hex-shaped paths. + for (const path of getPagePaths(ctx.pageId)) { + const id = path.get('_id'); + if (getHexByPathId(id)) { + continue; + } + const cell = matchHexShape(ctx, path); + if (!cell || getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + continue; + } + putHex(ctx.pageId, { id, type: path.get('_type'), row: cell[0], col: cell[1] }); + counts.adopted++; + } + + // 3. Re-link GM-layer labels sitting on hex centres. + const linkedLabels = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.nameId) + .filter(Boolean) + ); + for (const text of findObjs({ _type: 'text', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedLabels.has(text.get('_id'))) { + continue; + } + const x = Number(text.get('left')); + const y = Number(text.get('top')); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + hex.nameId = text.get('_id'); + hex.name = String(text.get('text') || '').trim() || hex.name; + counts.labels++; + } + } + + // 4. Re-link hidden white-tower icons. + const linkedIcons = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.iconId) + .filter(Boolean) + ); + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedIcons.has(token.get('_id')) || !tokenHasMarker(token, LOCATION_MARKER)) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + hex.iconId = token.get('_id'); + counts.icons++; + } + } + + return counts; + } + + /** + * Calibrates a page's grid from tokens snapped to hex centres, then rescans + * so existing hexes are filed under their corrected cells. + * + * @param {object} ctx Page context. + * @param {object[]} tokens One or two Roll20 graphics. + * @returns {{ok: boolean, calibration?: object, counts?: object}} Result. + */ + function calibratePage(ctx, tokens) { + const points = tokens.slice(0, 2).map((t) => [Number(t.get('left')), Number(t.get('top'))]); + // Calibrate against the uncalibrated profile so repeated calibration does not drift. + setCalibration(ctx.pageId, null); + const base = buildPageGrid(ctx.page); + const calibration = calibrateGrid(base, points); + if (!calibration) { + return { ok: false }; + } + setCalibration(ctx.pageId, calibration); + const fresh = { ...ctx, grid: buildPageGrid(ctx.page) }; + return { ok: true, calibration, counts: rescanPage(fresh) }; + } + + /** + * Clears a page's calibration and rescans. + * + * @param {object} ctx Page context. + * @returns {object} Rescan counts. + */ + function resetCalibration(ctx) { + setCalibration(ctx.pageId, null); + return rescanPage({ ...ctx, grid: buildPageGrid(ctx.page) }); + } + + /** + * Removes stored hexes whose paths no longer exist, on every page. Run on + * startup, since paths deleted while the API was off fire no events. + * + * @returns {{dropped: number, pages: number}} Counts. + */ + function pruneMissingHexes() { + let dropped = 0; + let pages = 0; + for (const pageId of getPageIds()) { + if (!getObj('page', pageId)) { + dropped += getPageHexes(pageId).length; + deletePageData(pageId); + pages++; + continue; + } + for (const hex of getPageHexes(pageId)) { + if (!getPathObject(hex.id, hex.type)) { + deleteHexRecord(pageId, hexKey(hex.row, hex.col)); + dropped++; + } + } + } + return { dropped, pages }; + } + + // Journal handouts: the Help handout and the Command Deck. + + const STYLE = { + outer: `background:${COLOR_CARD_BG_BOTTOM};color:${COLOR_TEXT};padding:14px 18px;border:1px solid ${COLOR_BORDER};border-radius:6px;font-family:Arial,sans-serif;line-height:1.5;`, + header: `background:${COLOR_HEADER_BG};padding:12px;border-radius:4px;text-align:center;border-bottom:3px solid ${COLOR_ACCENT};margin-bottom:12px;`, + h1: `color:${COLOR_HEADER_TEXT};margin:0;font-size:1.8em;letter-spacing:0.05em;`, + subtitle: `color:${COLOR_MUTED};margin:4px 0 0 0;font-size:0.9em;`, + h2: `color:${COLOR_ACCENT};border-bottom:1px solid ${COLOR_BORDER};padding-bottom:3px;margin:18px 0 8px 0;font-size:1.25em;`, + p: `color:${COLOR_TEXT};margin:6px 0;`, + li: `color:${COLOR_TEXT};margin:3px 0;`, + table: 'width:100%;border-collapse:collapse;margin:6px 0;font-size:0.92em;', + th: `background:${COLOR_HEADER_BG};color:${COLOR_HEADER_TEXT};padding:5px 8px;text-align:left;border:1px solid ${COLOR_BORDER};`, + td: `padding:5px 8px;border:1px solid ${COLOR_BORDER};vertical-align:top;color:${COLOR_TEXT};`, + code: 'font-family:monospace;color:#f3d48b;white-space:nowrap;', + link: `color:${COLOR_ACCENT};`, + footer: `color:${COLOR_MUTED};font-size:0.85em;text-align:center;margin-top:16px;border-top:1px solid ${COLOR_BORDER};padding-top:8px;`, + btn: `background:${COLOR_BUTTON_BG};color:${COLOR_BUTTON_TEXT};padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;font-weight:bold;`, + btnDark: `background:#2c4034;color:${COLOR_TEXT};border:1px solid #4d6b56;padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;`, + section: `background:${COLOR_HEADER_BG};color:${COLOR_ACCENT};padding:4px 8px;font-variant:small-caps;font-weight:bold;letter-spacing:0.05em;border-left:3px solid ${COLOR_ACCENT};margin:12px 0 4px 0;`, + desc: `color:${COLOR_MUTED};font-size:0.85em;margin:0 0 4px 8px;`, + }; + + /** + * Builds a table. + * + * @param {string[]} headings Column headings (escaped). + * @param {string[][]} rows Row cells (trusted HTML). + * @returns {string} HTML string. + */ + function table(headings, rows) { + const head = headings.map((h) => `${escapeHtml(h)}`).join(''); + const body = rows + .map((cells) => `${cells.map((c) => `${c}`).join('')}`) + .join(''); + return `${head}${body}
    `; + } + + /** + * Builds a paragraph list from a translated array. + * + * @param {*} items Translated value (array of strings expected). + * @param {boolean} [ordered=false] Use a numbered list. + * @returns {string} HTML string. + */ + function list(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const lis = (Array.isArray(items) ? items : []) + .map((item) => `
  • ${escapeHtml(item)}
    • `) + .join(''); + return `<${tag}>${lis}`; + } + + /** + * Builds a link. + * + * @param {string} url URL. + * @param {string} label Link text. + * @returns {string} HTML anchor. + */ + function link(url, label) { + return `${escapeHtml(label)}`; + } + + /** + * Builds the Help handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildHelpHtml(locale) { + const lang = getLocale(locale); + const h = (key, vars) => escapeHtml(t(`handout.${key}`, lang, vars)); + const raw = (key) => tRaw(`handout.${key}`, lang); + const code = (text) => `${escapeHtml(text)}`; + const section = (key, body) => `

    ${h(`${key}.heading`)}

    ${body}`; + + const commands = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ].map(([cmd, key]) => [code(`${COMMAND} ${cmd}`.trim()), escapeHtml(t(`help.${key}`, lang))]); + + const settings = Object.keys(DEFAULT_CONFIG).map((key) => [ + code(key), + escapeHtml(t(`settings.${key}.label`, lang)), + escapeHtml(t(`settings.${key}.desc`, lang)) + + (PAGE_SETTING_KEYS.includes(key) ? ` ${h('settings.perPage')}` : ''), + ]); + + const legacyCommands = [ + ['!hexploration_showMenuMain', `${COMMAND}`], + ['!hexploration_fillPoly', `${COMMAND} fill`], + ['!hexploration_fillInversePoly', `${COMMAND} fill inverse`], + ['!hexploration_hexModifyProperty name&&…', `${COMMAND} name …`], + ['!hexploration_configModifyProperty …', `${COMMAND} set …`], + ].map(([v1, v2]) => [code(v1), code(v2)]); + + const locales = LOCALE_DEFINITIONS.map((locale) => [ + escapeHtml(locale.name), + escapeHtml(locale.nativeName || locale.name), + `${buildLocaleFlag(locale)}${code(locale.code)}`, + ]); + const { original, maintainer } = AUTHOR_LINKS; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${h('versionLabel')} ${SCRIPT_VERSION} • ${h('subtitle')}

    +
    + ${section('overview', `

    ${h('overview.body')}

    ${link(DEMO_GIF_URL, t('handout.overview.demo', lang))}

    `)} + ${section('quickStart', list(raw('quickStart.steps'), true))} + ${section('commands', `

    ${h('commands.intro')}

    ${table([t('handout.commands.colCommand', lang), t('handout.commands.colDesc', lang)], commands)}`)} + ${section('revealing', list(raw('revealing.points')))} + ${section('locations', list(raw('locations.points')))} + ${section('settings', `

    ${h('settings.intro')}

    ${table([t('handout.settings.colKey', lang), t('handout.settings.colName', lang), t('handout.settings.colDesc', lang)], settings)}`)} + ${section('jumpgate', list(raw('jumpgate.points')))} + ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} + ${section('troubleshooting', list(raw('troubleshooting.points')))} + ${section('languages', `

    ${h('languages.body')}

    ${table([t('handout.languages.colLanguage', lang), t('handout.languages.colNative', lang), t('handout.languages.colCode', lang)], locales)}`)} + ${section( + 'credits', + `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    +

    ${h('credits.maintainer')} ${link(maintainer.profile, maintainer.name)} • ${link(maintainer.github, 'GitHub')}

    +

    ${h('credits.support')}

    ` + )} +
    ${SCRIPT_NAME} ${SCRIPT_VERSION} • ${h('footer', { deck: HANDOUT_DECK_NAME })}
    +
    `; + } + + /** + * Builds the Command Deck handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildDeckHtml(locale) { + const lang = getLocale(locale); + const tr = (key, vars) => t(key, lang, vars); + const btn = (key, cmd, dark = false) => + `${escapeHtml(tr(`buttons.${key}`))}`; + const group = (titleKey, descKey, buttons) => + `
    ${escapeHtml(tr(titleKey))}
    ${escapeHtml(tr(descKey))}
    ${buttons.join('')}
    `; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${DECK_TITLE} • v${SCRIPT_VERSION}

    +
    + ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} + ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} + ${group('menu.locations', 'deck.locationsDesc', [btn('mark', 'mark'), btn('unmark', 'unmark', true), btn('name', `name ?{${tr('prompts.name')}}`)])} + ${group('menu.tools', 'deck.toolsDesc', [btn('settings', 'set', true), btn('pageSettings', 'page', true), btn('status', 'status', true), btn('rescan', 'rescan', true), btn('calibrate', 'calibrate', true), btn('calibrateReset', 'calibrate reset', true), btn('help', 'help', true), btn('menu', '', true)])} +
    ${escapeHtml(tr('deck.footer', { help: HANDOUT_HELP_NAME }))}
    +
    `; + } + + /** + * Creates or updates a handout, removing duplicates with the same name. + * + * @param {string} name Handout name. + * @param {string} html Handout notes HTML. + * @returns {void} + */ + function upsertHandout(name, html) { + const existing = findObjs({ _type: 'handout', name }); + const [primary, ...duplicates] = existing; + const handout = primary || createObj('handout', { name }); + if (!handout) { + return; + } + handout.set({ inplayerjournals: '', controlledby: '' }); + handout.set('notes', html); + for (const dup of duplicates) { + dup.remove(); + } + } + + /** + * Creates or refreshes the Help and Command Deck handouts in the current language. + * + * @returns {void} + */ + function installHandouts() { + const lang = getConfig().language; + upsertHandout(HANDOUT_HELP_NAME, buildHelpHtml(lang)); + upsertHandout(HANDOUT_DECK_NAME, buildDeckHtml(lang)); + } + + // Revealing hexes: when tokens move, from GM commands, and through the public API. + + /** + * Returns true when a token should reveal hexes under the page's settings. + * + * @param {object} token Roll20 graphic. + * @param {object} settings Effective page settings. + * @returns {boolean} True when the token reveals. + */ + function tokenReveals(token, settings) { + if (!token || token.get('_subtype') !== 'token' || token.get('layer') !== LAYER_TOKEN) { + return false; + } + switch (settings.revealBy) { + case 'all': + return true; + case 'characters': + return !!token.get('represents'); + default: + return getTokenControllers(token).some((id) => id === 'all' || !playerIsGM(id)); + } + } + + /** + * Announces a discovered location. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record (before removal). + * @param {string} name Location name. + * @param {string} imgsrc Icon image URL (may be empty). + * @param {object} settings Effective page settings. + * @returns {void} + */ + function announceDiscovery(ctx, hex, name, imgsrc, settings) { + if (name && settings.announce !== 'off') { + const lang = getConfig().language; + const img = imgsrc + ? `
    ` + : ''; + const html = buildCard( + t('discovery.title', lang), + `${img}
    ${escapeHtml(name)}
    ` + ); + const prefix = settings.announce === 'gm' ? '/w gm ' : ''; + sendChat(SCRIPT_NAME, `${prefix}${html}`); + } + if (name && settings.pingDiscoveries) { + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + sendPing(x, y, ctx.pageId, null, true); + } + } + + /** + * Reveals one hex: removes it and its label, shows its icon, and announces + * it when named. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {object} settings Effective page settings. + * @param {object} [options] Options. + * @param {number} [options.distance=0] Distance from the revealing token (for maxDistance). + * @param {boolean} [options.announce=true] Announce named discoveries. + * @returns {boolean} True when a hex was revealed. + */ + function revealHex(ctx, key, settings, { distance = 0, announce = true } = {}) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + if (distance > 0 && Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + + const name = getDiscoveryName(hex); + const icon = getHexIcon(hex); + const imgsrc = icon ? toText(icon.get('imgsrc')) : ''; + removeHex(ctx.pageId, key, false); + if (icon) { + icon.set({ layer: LAYER_TOKEN, showname: true }); + } + if (announce) { + announceDiscovery(ctx, hex, name, imgsrc, settings); + } + return true; + } + + /** + * Turns a hex see-through (glimpse mode) without revealing it. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {number} distance Distance from the revealing token. + * @returns {boolean} True when the hex changed. + */ + function glimpseHex(ctx, key, distance) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + const path = getPathObject(hex.id, hex.type); + if (!path) { + return false; + } + const fill = pathColor(getConfig().glimpseColor, path.get('_type')); + if (hex.glimpsed) { + // Versions before this fix marked Jumpgate hexes as glimpsed without + // changing their colour; repaint them when they are seen again. + if (path.get('fill') !== fill) { + path.set('fill', fill); + } + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + path.set('fill', fill); + hex.glimpsed = true; + return true; + } + + /** + * Returns true when line of sight from one hex to another is blocked by a + * covered hex. Glimpsed hexes have been seen through, so they do not block. + * + * @param {object} ctx Page context. + * @param {number[]} from [row, col]. + * @param {number[]} to [row, col]. + * @returns {boolean} True when blocked. + */ + function isBlocked(ctx, from, to) { + return hexesBetween(ctx.grid, from, to).some(([r, c]) => { + const hex = getHex(ctx.pageId, hexKey(r, c)); + return hex && !hex.glimpsed; + }); + } + + /** + * Parses a token's lastmove into points. + * + * @param {string} lastmove Roll20 lastmove ("x1,y1,x2,y2,…"). + * @returns {number[][]} Array of [x, y]. + */ + function parseLastMove(lastmove) { + const nums = toText(lastmove) + .split(',') + .map(Number) + .filter((n) => Number.isFinite(n)); + const points = []; + for (let i = 0; i + 1 < nums.length; i += 2) { + points.push([nums[i], nums[i + 1]]); + } + return points; + } + + /** + * Returns the cells a token passed through on its last move, in order, plus + * every cell it now covers. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @param {object|null} prev Previous token properties, when known. + * @param {boolean} followPath Include the route travelled. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function travelledCells(ctx, token, prev, followPath) { + const current = [Number(token.get('left')), Number(token.get('top'))]; + const cells = []; + + if ( + followPath && + prev && + Number.isFinite(Number(prev.left)) && + Number.isFinite(Number(prev.top)) + ) { + const start = [Number(prev.left), Number(prev.top)]; + // lastmove holds the start point and any waypoints of the latest drag. It + // is only trusted when it starts where the token was; moves made by other + // mods leave a stale lastmove behind. + const waypoints = parseLastMove(token.get('lastmove')); + const startsHere = + waypoints.length > 0 && + Math.abs(waypoints[0][0] - start[0]) < 1 && + Math.abs(waypoints[0][1] - start[1]) < 1; + const route = startsHere ? [...waypoints, current] : [start, current]; + for (let i = 1; i < route.length; i++) { + cells.push(...hexesAlongSegment(ctx.grid, route[i - 1], route[i])); + } + } + + cells.push( + ...hexesUnderToken( + ctx.grid, + current[0], + current[1], + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + + const seen = new Set(); + return cells.filter(([r, c]) => { + const key = hexKey(r, c); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); + } + + /** + * Reveals around a list of origin cells using the page's settings. + * + * @param {object} ctx Page context. + * @param {number[][]} origins Cells the token occupied, in order. + * @param {object} settings Effective page settings. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealFromCells(ctx, origins, settings) { + let changed = 0; + for (const origin of origins) { + if (revealHex(ctx, hexKey(origin[0], origin[1]), settings)) { + changed++; + } + for (const cell of hexesWithin(ctx.grid, origin[0], origin[1], settings.revealDistance)) { + const key = hexKey(cell[0], cell[1]); + if (!getHex(ctx.pageId, key)) { + continue; + } + if (settings.lineOfSight && isBlocked(ctx, origin, cell)) { + continue; + } + const distance = hexDistance(ctx.grid, origin, cell); + const done = + settings.revealMode === 'glimpse' + ? glimpseHex(ctx, key, distance) + : revealHex(ctx, key, settings, { distance }); + if (done) { + changed++; + } + } + } + return changed; + } + + /** + * Reveals the hexes a token has moved through and can now see. + * + * @param {object} token Roll20 graphic. + * @param {object|null} [prev] Previous token properties from a change event. + * @param {boolean} [force=false] Skip the "which tokens reveal" check. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealAroundToken(token, prev = null, force = false) { + const pageId = token?.get('_pageid'); + if (!pageId || getPageHexes(pageId).length === 0) { + return 0; + } + const ctx = getPageContext(pageId); + if (!ctx.ok) { + return 0; + } + const settings = getPageSettings(pageId); + if (!force && !tokenReveals(token, settings)) { + return 0; + } + return revealFromCells(ctx, travelledCells(ctx, token, prev, settings.revealPath), settings); + } + + /** + * Handles a graphic change event: reveals when a token moves or arrives on + * the token layer. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleTokenChange(token, prev) { + const moved = prev && (prev.left !== token.get('left') || prev.top !== token.get('top')); + const surfaced = + prev && prev.layer !== token.get('layer') && token.get('layer') === LAYER_TOKEN; + const resized = + prev && (prev.width !== token.get('width') || prev.height !== token.get('height')); + handleCoveredChange(token, prev); + const layerChanged = prev && prev.layer !== token.get('layer'); + if (moved || surfaced || resized) { + if (revealAroundToken(token, moved ? prev : null) > 0) { + // Reveals may uncover other tokens as well as this one. + refreshPage(token.get('_pageid')); + return; + } + } + if (moved || layerChanged) { + refreshToken(token); + } + } + + /** + * Reveals every hex on a page without announcements. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function revealPage(ctx, onDone) { + const settings = getPageSettings(ctx.pageId); + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + let count = 0; + runInBatches( + keys, + BATCH_SIZE, + (key) => { + if (revealHex(ctx, key, settings, { announce: false })) { + count++; + } + }, + () => { + refreshPage(ctx.pageId); + onDone(count); + } + ); + } + + // Settings shown in the menu, in order, with how to prompt for them. + const SETTING_ROWS = [ + { key: 'hexLayer', options: HEX_LAYER_OPTIONS }, + { key: 'fillColor', color: true }, + { key: 'strokeColor', color: true }, + { key: 'labelColor', color: true }, + { key: 'glimpseColor', color: true }, + { key: 'strokeWidth' }, + { key: 'maxDistance' }, + { key: 'revealDistance' }, + { key: 'lineOfSight', options: ['on', 'off'] }, + { key: 'revealPath', options: ['on', 'off'] }, + { key: 'revealBy', options: REVEAL_BY_OPTIONS }, + { key: 'revealMode', options: REVEAL_MODE_OPTIONS }, + { key: 'announce', options: ANNOUNCE_OPTIONS }, + { key: 'pingDiscoveries', options: ['on', 'off'] }, + { key: 'hideCoveredTokens', options: ['on', 'off'] }, + { key: 'language' }, + ]; + + /** + * Returns the active locale. + * + * @returns {string} Locale code. + */ + function lang() { + return getConfig().language; + } + + /** + * Translates a key in the active locale. + * + * @param {string} key Translation key. + * @param {object} [vars] Interpolation variables. + * @returns {string} Translated text. + */ + function tr(key, vars) { + return t(key, lang(), vars); + } + + /** + * Whispers a translated error with its hint. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `errors.` (the hint lives under `hints.`). + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function fail(playerId, key, vars) { + const hint = t(`hints.${key}`, lang(), vars); + whisperError(playerId, tr(`errors.${key}`, vars), hint === `hints.${key}` ? '' : hint); + } + + /** + * Whispers a short translated confirmation. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `messages.`. + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function done(playerId, key, vars) { + whisper(playerId, SCRIPT_NAME, `
    ${escapeHtml(tr(`messages.${key}`, vars))}
    `); + } + + /** + * Formats a setting value for display. + * + * @param {string} key Setting key. + * @param {*} value Setting value. + * @returns {string} Display text. + */ + function formatValue(key, value) { + if (typeof value === 'boolean') { + return tr(value ? 'values.on' : 'values.off'); + } + if (value === null || value === undefined) { + return tr('values.none'); + } + if (key === 'language') { + return LOCALE_LABELS[value] || value; + } + if (['hexLayer', 'revealBy', 'revealMode', 'announce'].includes(key)) { + return tr(`values.${key}.${value}`); + } + return String(value); + } + + /** + * Builds a Roll20 query prompting for a setting's new value. + * + * @param {object} row Setting row definition. + * @param {*} current Current value. + * @returns {string} Query text. + */ + function settingQuery(row, current) { + const label = tr(`settings.${row.key}.label`).replaceAll(/[|}]/g, ''); + if (row.options) { + return `?{${label}|${row.options.join('|')}}`; + } + if (row.key === 'language') { + return `?{${label}|${SUPPORTED_LOCALES.join('|')}}`; + } + const shown = current === null || current === undefined ? '' : String(current); + return `?{${label}|${shown.replaceAll(/[|}]/g, '')}}`; + } + + // --------------------------------------------------------------------------- + // Selection and page helpers + // --------------------------------------------------------------------------- + + /** + * Sorts the selection into drawn shapes, hexes and tokens. + * + * @param {object} msg Chat message. + * @returns {{paths: object[], hexes: object[], tokens: object[], pageId: string|null}} Selection. + */ + function readSelection(msg) { + const selection = { paths: [], hexes: [], tokens: [], pageId: null }; + for (const sel of msg.selected || []) { + const obj = getObj(sel._type, sel._id); + if (!obj) { + continue; + } + selection.pageId = selection.pageId || obj.get('_pageid'); + if (isPathObject(obj)) { + const found = getHexByPathId(sel._id); + if (found) { + selection.hexes.push(found); + } else { + selection.paths.push(obj); + } + } else if (sel._type === 'graphic' && obj.get('_subtype') === 'token') { + selection.tokens.push(obj); + } + } + return selection; + } + + /** + * Returns the context for the selection's page, or the GM's current page. + * Whispers an error when the page cannot be used. + * + * @param {object} msg Chat message. + * @param {object} selection Selection from readSelection. + * @returns {object|null} Page context. + */ + function pageContextFor(msg, selection) { + const ctx = getPageContext(selection.pageId || getPlayerPageId(msg.playerid)); + if (!ctx.ok) { + fail(msg.playerid, ctx.reason); + return null; + } + return ctx; + } + + /** + * Returns the cells under the selected tokens. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number[][]} Array of [row, col]. + */ + function cellsUnderTokens(ctx, tokens) { + return tokens.flatMap((token) => + hexesUnderToken( + ctx.grid, + Number(token.get('left')), + Number(token.get('top')), + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + } + + /** + * Reports the end of a fill. + * + * @param {string} playerId Player ID. + * @param {object} summary Fill summary. + * @returns {void} + */ + function reportFill(playerId, summary) { + done(playerId, 'filled', summary); + if (summary.fellBack) { + whisperWarning(playerId, tr('warnings.foregroundUnavailable')); + } + if (summary.failed > 0) { + whisperWarning(playerId, tr('warnings.someFailed', { count: summary.failed })); + } + } + + /** + * Starts a fill and reports its outcome. + * + * @param {object} msg Chat message. + * @param {object} ctx Page context. + * @param {number[][]} allCells Cells to cover (duplicates are ignored). + * @param {object[]} sources Saved source polygons. + * @param {string} kind Fill kind. + * @returns {void} + */ + function startFill(msg, ctx, allCells, sources, kind) { + const seen = new Set(); + const cells = allCells.filter(([r, c]) => { + const key = hexKey(r, c); + return seen.has(key) ? false : seen.add(key); + }); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const result = fillCells(ctx, cells, { + sources, + kind, + onDone: (summary) => { + refreshPage(ctx.pageId); + reportFill(msg.playerid, summary); + }, + }); + if (!result.started) { + fail(msg.playerid, result.reason, { count: cells.length }); + } + } + + // --------------------------------------------------------------------------- + // Command handlers + // --------------------------------------------------------------------------- + + /** + * `fill` and `fill inverse`: cover the selected polygons (or everything + * outside them) with hexes. + * + * @param {object} msg Chat message. + * @param {boolean} inverse Fill outside the polygons. + * @returns {void} + */ + function commandFill(msg, inverse) { + const selection = readSelection(msg); + if (selection.paths.length === 0) { + fail(msg.playerid, 'noPolygons'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = inverse + ? cellsOutsidePaths(ctx, selection.paths) + : cellsInPaths(ctx, selection.paths); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, inverse ? 'fillInverse' : 'fill'); + } + + /** + * `conceal`: cover the cells under the selected polygons and tokens again. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandConceal(msg) { + const selection = readSelection(msg); + if (selection.paths.length === 0 && selection.tokens.length === 0) { + fail(msg.playerid, 'nothingToConceal'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]; + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, 'conceal'); + } + + /** + * `reveal`: reveal the selected hexes and the hexes under selected polygons + * and tokens. `reveal page` reveals everything on the page silently. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReveal(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + + if (args[0] === 'page') { + revealPage(ctx, (count) => done(msg.playerid, 'revealedPage', { count })); + return; + } + + const keys = new Set(selection.hexes.filter((h) => h.pageId === ctx.pageId).map((h) => h.key)); + for (const [r, c] of [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]) { + keys.add(hexKey(r, c)); + } + if (keys.size === 0) { + fail(msg.playerid, 'nothingToReveal'); + return; + } + consumeSourcePaths(selection.paths); + const settings = getPageSettings(ctx.pageId); + let count = 0; + for (const key of keys) { + if (revealHex(ctx, key, settings)) { + count++; + } + } + refreshPage(ctx.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `explore`: reveal around the selected tokens as if they had just moved + * there. Useful after moving tokens with other mods. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandExplore(msg) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const count = selection.tokens.reduce( + (sum, token) => sum + revealAroundToken(token, null, true), + 0 + ); + refreshPage(selection.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `reset page [confirm]`: remove every hex on the page. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReset(msg, args) { + if (args[0] !== 'page') { + fail(msg.playerid, 'unknownCommand', { command: `reset ${args.join(' ')}` }); + return; + } + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const count = getPageHexes(ctx.pageId).length; + if (args[1] !== 'confirm') { + whisper(msg.playerid, tr('titles.confirm'), [ + `
    ${escapeHtml(tr('messages.confirmReset', { count, page: ctx.page.get('name') }))}
    `, + `
    ${buildButton(tr('buttons.confirmReset'), `${COMMAND} reset page confirm`)}
    `, + ]); + return; + } + clearPage(ctx, (removed) => { + refreshPage(ctx.pageId); + done(msg.playerid, 'resetPage', { count: removed }); + }); + } + + /** + * `undo`: reverse the last fill. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandUndo(msg) { + const result = undoLastFill(); + if (!result.ok) { + fail(msg.playerid, result.reason); + return; + } + refreshPage(result.pageId); + done(msg.playerid, 'undone', result); + } + + /** + * `name `: name the selected hexes (or the hexes under selected tokens). + * An empty name clears it. + * + * @param {object} msg Chat message. + * @param {string} rawName Name text. + * @returns {void} + */ + function commandName(msg, rawName) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const keys = new Set(selection.hexes.map((h) => h.key)); + for (const token of selection.tokens) { + const [r, c] = cellsUnderTokens(ctx, [token])[0]; + keys.add(hexKey(r, c)); + } + const hexes = [...keys].map((key) => getHex(ctx.pageId, key)).filter(Boolean); + if (hexes.length === 0) { + fail(msg.playerid, 'noHexes'); + return; + } + for (const hex of hexes) { + setHexName(ctx, hex, rawName); + } + done(msg.playerid, toText(rawName) ? 'named' : 'unnamed', { + count: hexes.length, + name: toText(rawName), + }); + } + + /** + * `mark` / `unmark`: turn the selected tokens into hidden locations, or back. + * + * @param {object} msg Chat message. + * @param {boolean} mark True to mark, false to unmark. + * @returns {void} + */ + function commandMark(msg, mark) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (mark) { + done(msg.playerid, 'marked', markLocations(ctx, selection.tokens)); + } else { + done(msg.playerid, 'unmarked', { count: unmarkLocations(ctx, selection.tokens) }); + } + } + + /** + * `set [key] [value]`: change a global setting, or show the settings card. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandSet(msg, args) { + const [key, ...rest] = args; + if (!key) { + showSettings(msg.playerid); + return; + } + if (!(key in DEFAULT_CONFIG)) { + fail(msg.playerid, 'unknownSetting', { key }); + return; + } + const raw = rest.join(' '); + if (key === 'language' && !raw) { + showLanguages(msg.playerid); + return; + } + const result = setConfigValue(key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + if (key === 'language') { + installHandouts(); + } + if (key === 'hideCoveredTokens') { + if (result.value) { + getPageIds().forEach(refreshPage); + } else { + restoreAll(); + } + } + done(msg.playerid, 'settingChanged', { + setting: tr(`settings.${key}.label`), + value: formatValue(key, result.value), + }); + showSettings(msg.playerid); + } + + /** + * `page [set | clear]`: per-page overrides. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandPage(msg, args) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const [action, key, ...rest] = args; + if (action === 'set') { + if (!PAGE_SETTING_KEYS.includes(key)) { + fail(msg.playerid, 'unknownPageSetting', { + key: key || '', + keys: PAGE_SETTING_KEYS.join(', '), + }); + return; + } + const raw = rest.join(' '); + const result = setPageSetting(ctx.pageId, key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + } else if (action === 'clear') { + clearPageSettings(ctx.pageId); + } else if (action) { + fail(msg.playerid, 'unknownCommand', { command: `page ${args.join(' ')}` }); + return; + } + showPageSettings(msg.playerid, ctx); + } + + /** + * `rescan`: rebuild the page's hex list from the objects on it. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandRescan(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (ctx) { + const counts = rescanPage(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'rescanned', counts); + } + } + + /** + * `calibrate [reset]`: line the grid up with tokens snapped to hex centres. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandCalibrate(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (args[0] === 'reset') { + const counts = resetCalibration(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrationReset', counts); + return; + } + if (selection.tokens.length === 0) { + fail(msg.playerid, 'calibrateNeedsTokens'); + return; + } + const result = calibratePage(ctx, selection.tokens); + if (!result.ok) { + fail(msg.playerid, 'calibrateFailed'); + return; + } + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrated', { + ...result.counts, + colStep: result.calibration.colStep.toFixed(2), + rowStep: result.calibration.rowStep.toFixed(2), + }); + } + + /** + * `journal rebuild`: recreate the help and Command Deck handouts. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandJournal(msg) { + installHandouts(); + done(msg.playerid, 'journalRebuilt', { help: HANDOUT_HELP_NAME, deck: HANDOUT_DECK_NAME }); + } + + // --------------------------------------------------------------------------- + // Cards + // --------------------------------------------------------------------------- + + /** + * Whispers the main menu. + * + * @param {string|null} playerId Player ID (null for every GM). + * @returns {void} + */ + function showMainMenu(playerId) { + const b = (key, cmd) => buildButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + const s = (key, cmd) => buildSecondaryButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + whisper(playerId, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, [ + buildSectionLabel(tr('menu.draw')), + `
    ${b('fill', 'fill')}${b('fillInverse', 'fill inverse')}${s('undo', 'undo')}
    `, + buildSectionLabel(tr('menu.reveal')), + `
    ${b('reveal', 'reveal')}${b('conceal', 'conceal')}${b('explore', 'explore')}
    `, + `
    ${s('revealPage', 'reveal page')}${s('resetPage', 'reset page')}
    `, + buildSectionLabel(tr('menu.locations')), + `
    ${b('mark', 'mark')}${s('unmark', 'unmark')}${b('name', `name ?{${tr('prompts.name')}}`)}
    `, + buildSectionLabel(tr('menu.tools')), + `
    ${s('settings', 'set')}${s('pageSettings', 'page')}${s('status', 'status')}
    `, + `
    ${s('rescan', 'rescan')}${s('calibrate', 'calibrate')}${s('help', 'help')}
    `, + ]); + } + + /** + * Whispers the global settings card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showSettings(playerId) { + const config = getConfig(); + const rows = SETTING_ROWS.map((row) => { + const value = config[row.key]; + const flag = + row.key === 'language' + ? buildLocaleFlag(LOCALE_DEFINITIONS.find(({ code }) => code === value)) + : ''; + const shown = row.color ? buildSwatch(value) : flag + escapeHtml(formatValue(row.key, value)); + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} set ${row.key} ${settingQuery(row, value)}` + ); + return buildRow(tr(`settings.${row.key}.label`), `${shown} ${button}`); + }); + whisper(playerId, tr('titles.settings'), [ + ...rows, + buildDivider(), + `
    ${escapeHtml(tr('menu.layerInUse', { layer: tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) }))}
    `, + `
    ${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the list of languages. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showLanguages(playerId) { + const buttons = LOCALE_DEFINITIONS.map((locale) => + buildSecondaryButton( + LOCALE_LABELS[locale.code], + `${COMMAND} set language ${locale.code}`, + buildLocaleFlag(locale) + ) + ); + whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); + } + + /** + * Whispers a page's settings and overrides. + * + * @param {string} playerId Player ID. + * @param {object} ctx Page context. + * @returns {void} + */ + function showPageSettings(playerId, ctx) { + const overrides = getPageData(ctx.pageId)?.settings || {}; + const effective = getPageSettings(ctx.pageId); + const rows = PAGE_SETTING_KEYS.map((key) => { + const row = SETTING_ROWS.find((r) => r.key === key); + const marker = key in overrides ? ' ★' : ''; + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} page set ${key} ${settingQuery(row, effective[key])}` + ); + return buildRow( + `${tr(`settings.${key}.label`)}${marker}`, + `${escapeHtml(formatValue(key, effective[key]))} ${button}` + ); + }); + whisper(playerId, tr('titles.pageSettings', { page: ctx.page.get('name') }), [ + `
    ${escapeHtml(tr('menu.pageSettingsHelp'))}
    `, + ...rows, + `
    ${buildSecondaryButton(tr('buttons.clearOverrides'), `${COMMAND} page clear`)}${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the status of the current page. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function showStatus(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const hexes = getPageHexes(ctx.pageId); + const data = getPageData(ctx.pageId); + const last = getLastFill(); + const row = (key, value) => buildRow(tr(`status.${key}`), escapeHtml(String(value))); + whisper(msg.playerid, tr('titles.status', { page: ctx.page.get('name') }), [ + row('engine', isJumpgate() ? 'Jumpgate' : 'Legacy'), + row('grid', tr(`values.orientation.${ctx.grid.orientation}`)), + row( + 'layer', + tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) + ), + row('hexes', hexes.length), + row('named', hexes.filter((h) => h.name).length), + row('icons', hexes.filter((h) => h.iconId).length), + row('glimpsed', hexes.filter((h) => h.glimpsed).length), + row('pending', getPendingLocations(ctx.pageId).length), + row('calibrated', tr(data?.calibration ? 'values.on' : 'values.off')), + row('overrides', Object.keys(data?.settings || {}).length), + row('undo', last ? tr(`values.fillKind.${last.kind}`) : tr('values.none')), + ]); + } + + /** + * Whispers the help card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showHelp(playerId) { + const lines = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ]; + const html = lines + .map( + ([cmd, key]) => + `
    ${escapeHtml(`${COMMAND} ${cmd}`.trim())}
    ${escapeHtml(tr(`help.${key}`))}
    ` + ) + .join(''); + whisper(playerId, tr('titles.help'), [ + html, + buildDivider(), + `
    ${escapeHtml(tr('help.handout', { name: HANDOUT_HELP_NAME }))}
    `, + ]); + } + + // --------------------------------------------------------------------------- + // Routing + // --------------------------------------------------------------------------- + + /** + * Routes a parsed command. + * + * @param {object} msg Chat message. + * @param {string} sub Subcommand. + * @param {string[]} args Arguments. + * @param {string} rest Raw text after the subcommand. + * @returns {void} + */ + function routeCommand(msg, sub, args, rest) { + switch (sub) { + case '': + case 'menu': + showMainMenu(msg.playerid); + return; + case 'help': + showHelp(msg.playerid); + return; + case 'fill': + commandFill(msg, args[0] === 'inverse'); + return; + case 'conceal': + case 'hide': + commandConceal(msg); + return; + case 'reveal': + commandReveal(msg, args); + return; + case 'explore': + commandExplore(msg); + return; + case 'reset': + commandReset(msg, args); + return; + case 'undo': + commandUndo(msg); + return; + case 'name': + commandName(msg, rest); + return; + case 'mark': + commandMark(msg, true); + return; + case 'unmark': + commandMark(msg, false); + return; + case 'set': + case 'config': + commandSet(msg, args); + return; + case 'page': + commandPage(msg, args); + return; + case 'rescan': + commandRescan(msg); + return; + case 'calibrate': + commandCalibrate(msg, args); + return; + case 'status': + showStatus(msg); + return; + case 'journal': + commandJournal(msg); + return; + default: + fail(msg.playerid, 'unknownCommand', { command: sub }); + } + } + + /** + * Maps a v1 command to the v2 handlers. + * + * @param {object} msg Chat message. + * @param {string} action Legacy action from LEGACY_COMMANDS. + * @param {string} rest Raw text after the command. + * @returns {void} + */ + function routeLegacy(msg, action, rest) { + const params = rest.split(LEGACY_ARG_SEPARATOR).map((p) => p.trim()); + switch (action) { + case 'fill': + commandFill(msg, false); + return; + case 'fillInverse': + commandFill(msg, true); + return; + case 'menu': + showMainMenu(msg.playerid); + return; + case 'legacyHex': + if (params[0] === 'name') { + commandName(msg, params.slice(1).join(LEGACY_ARG_SEPARATOR)); + } + return; + case 'legacyConfig': { + const [prop, ...values] = params; + // v1 defaults when a colour prompt is left empty. + const updates = { + color: () => ({ + fillColor: values[0] || 'black', + strokeColor: values[1] || 'transparent', + labelColor: values[2] || 'white', + }), + strokeWidth: () => ({ strokeWidth: values[0] || '0' }), + maxDistance: () => ({ maxDistance: values[0] || '' }), + revealDistance: () => ({ revealDistance: values[0] || '0' }), + }[prop]; + if (!updates) { + fail(msg.playerid, 'unknownSetting', { key: prop || '' }); + return; + } + for (const [key, value] of Object.entries(updates())) { + if (!setConfigValue(key, value).valid) { + fail(msg.playerid, 'invalidValue', { key, value }); + } + } + showSettings(msg.playerid); + return; + } + } + } + + /** + * Handles chat input: `!hexploration …` and the v1 commands. GM only. + * + * @param {object} msg Roll20 chat message. + * @returns {void} + */ + function handleInput(msg) { + if (msg.type !== 'api') { + return; + } + const content = toText(msg.content); + const [first] = content.split(/\s+/, 1); + const isMain = first === COMMAND; + const legacy = LEGACY_COMMANDS[first]; + if (!isMain && !legacy) { + return; + } + if (!playerIsGM(msg.playerid)) { + return; + } + + try { + const rest = content.slice(first.length).trim(); + if (legacy) { + routeLegacy(msg, legacy, rest); + return; + } + const [sub = '', ...args] = rest.split(/\s+/).filter(Boolean); + const afterSub = rest.slice(sub.length).trim(); + routeCommand(msg, sub.toLowerCase(), args, afterSub); + } catch (err) { + log(`${SCRIPT_NAME} ERROR: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + fail(msg.playerid, 'unexpected', { message: err?.message || String(err) }); + } + } + + let ready = false; + + /** + * Runs a handler, logging instead of crashing the sandbox on errors. + * + * @param {string} label Handler name for the log. + * @param {Function} fn Handler. + * @returns {Function} Wrapped handler. + */ + function guarded(label, fn) { + return (...args) => { + if (!ready) { + return; + } + try { + fn(...args); + } catch (err) { + log(`${SCRIPT_NAME} ERROR in ${label}: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }; + } + + /** + * Forgets a hex whose path was deleted by hand. + * + * @param {object} path Deleted Roll20 path. + * @returns {void} + */ + function handlePathDestroyed(path) { + const found = getHexByPathId(path.get('_id')); + if (found) { + removeLabel(found.hex); + deleteHexRecord(found.pageId, found.key); + refreshPage(found.pageId); + } + } + + /** + * Forgets a deleted token as a pending location or hidden token. + * + * @param {object} token Deleted Roll20 graphic. + * @returns {void} + */ + function handleGraphicDestroyed(token) { + setPendingLocation(token.get('_id'), null); + delete getCoveredTokens()[token.get('_id')]; + } + + /** + * Forgets a deleted page's hexes. + * + * @param {object} page Deleted Roll20 page. + * @returns {void} + */ + function handlePageDestroyed(page) { + const pageId = page.get('_id'); + if (getPageIds().includes(pageId)) { + deletePageData(pageId); + } + } + + /** + * Registers with TokenMod (if installed) so tokens it moves reveal hexes; + * the API does not raise change events for moves made by other mods. + * + * @returns {void} + */ + function observeOtherMods() { + if (typeof TokenMod !== 'undefined' && typeof TokenMod?.ObserveTokenChange === 'function') { + TokenMod.ObserveTokenChange(guarded('TokenMod observer', handleTokenChange)); + } + } + + /** + * Publishes the API other mods can call. + * + * @returns {void} + */ + function publishApi() { + globalThis.Hexploration = Object.freeze({ + version: SCRIPT_VERSION, + /** + * Reveals around a token as if it had just moved, for mods that move tokens. + * + * @param {object|string} tokenOrId Roll20 graphic or its ID. + * @param {object} [prev] Previous left/top, to reveal along the route. + * @returns {number} Number of hexes revealed or glimpsed. + */ + revealAround(tokenOrId, prev = null) { + const token = typeof tokenOrId === 'string' ? getObj('graphic', tokenOrId) : tokenOrId; + if (!ready || !token) { + return 0; + } + try { + const changed = revealAroundToken(token, prev); + refreshPage(token.get('_pageid')); + return changed; + } catch (err) { + log(`${SCRIPT_NAME} ERROR in revealAround: ${err?.message || err}`); + return 0; + } + }, + }); + } + + /** + * Startup: migrate state, clean up, install handouts and greet the GM. + * + * @returns {void} + */ + function checkInstall() { + const migratedFrom = initialiseState(); + applyGlobalConfig(); + const pruned = pruneMissingHexes(); + for (const pageId of new Set([ + ...getPageIds(), + ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), + ])) { + refreshPage(pageId); + } + installHandouts(); + registerEngineHandlers(); + observeOtherMods(); + publishApi(); + ready = true; + + log( + `-=> ${SCRIPT_NAME} v${SCRIPT_VERSION} [Updated: ${SCRIPT_LAST_UPDATED}] (${isJumpgate() ? 'Jumpgate' : 'Legacy'}) <=-` + ); + + const lang = getConfig().language; + const lines = [`
    ${escapeHtml(t('titles.ready', lang))}
    `]; + if (migratedFrom === 1) { + lines.push(`
    ${escapeHtml(t('messages.migrated', lang))}
    `); + } + if (pruned.dropped > 0) { + lines.push( + `
    ${escapeHtml(t('messages.pruned', lang, pruned))}
    ` + ); + } + lines.push( + `
    ${escapeHtml(t('messages.readyHint', lang))}
    ` + ); + whisper(null, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, lines); + if (migratedFrom === 1 || pruned.dropped > 0) { + showMainMenu(null); + } + } + + /** + * Registers all Roll20 event handlers. + * + * @returns {void} + */ + function registerEventHandlers() { + on('ready', () => { + try { + checkInstall(); + } catch (err) { + log(`${SCRIPT_NAME} ERROR during startup: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }); + on('chat:message', (msg) => { + if (ready) { + handleInput(msg); + } + }); + on('change:graphic', guarded('change:graphic', handleTokenChange)); + on('add:graphic', guarded('add:graphic', refreshToken)); + on('destroy:graphic', guarded('destroy:graphic', handleGraphicDestroyed)); + on('destroy:page', guarded('destroy:page', handlePageDestroyed)); + on(`destroy:${PATH_TYPE_LEGACY}`, guarded('destroy:path', handlePathDestroyed)); + } + + /** + * Registers handlers that depend on the game engine. pathv2 objects only + * exist in Jumpgate, and the engine is only known once the game has loaded. + * + * @returns {void} + */ + function registerEngineHandlers() { + if (isJumpgate()) { + on(`destroy:${PATH_TYPE_V2}`, guarded('destroy:pathv2', handlePathDestroyed)); + } + } + + registerEventHandlers(); +})(); diff --git a/Hexploration/CHANGELOG.md b/Hexploration/CHANGELOG.md index 9a7940a393..156a8106f2 100644 --- a/Hexploration/CHANGELOG.md +++ b/Hexploration/CHANGELOG.md @@ -1,5 +1,17 @@ # Changelog +## 2.0.1 - 2026-10-30 + +### Fixed + +- Glimpse works in Jumpgate. Jumpgate ignores `rgb()` and `rgba()` colours on drawn shapes, so glimpsed hexes kept their solid fill. Fill, border and glimpse colours are now converted to `#rrggbb` or `#rrggbbaa` for Jumpgate hexes, so `rgba()` fill colours make see-through hexes too. Hexes left solid by 2.0.0 are repainted the next time a token sees them. +- The colour swatches on the settings card show colours with transparency. Roll20 chat dropped `#rrggbbaa` colours and `rgb()` colours with a fourth value, leaving the swatch empty. + +### Changed + +- The README lists the colour formats the settings accept and explains how they are used in Jumpgate. +- The help handout, settings descriptions and README explain how Hex Reveal Distance and Line of Sight work together, with a mountain range example. Neither makes a difference with the default Sight Distance of 1, and Hex Reveal Distance only applies to hexes filled after it is set. + ## 2.0.0 - 2026-10-29 A full rewrite by MidNiteShadow7 of Ada Lindberg's Hexploration, which no longer worked in Jumpgate games. diff --git a/Hexploration/DEVELOPERS.md b/Hexploration/DEVELOPERS.md index 22fee2fddf..46dc817c8c 100644 --- a/Hexploration/DEVELOPERS.md +++ b/Hexploration/DEVELOPERS.md @@ -43,7 +43,7 @@ ```js { schemaVersion: 2, - version: '2.0.0', + version: '2.0.1', config: { language, hexLayer, fillColor, strokeColor, labelColor, glimpseColor, strokeWidth, maxDistance, revealDistance, lineOfSight, revealPath, revealBy, revealMode, announce, pingDiscoveries }, diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index cff78e3990..d5c6ee8fcb 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -4,16 +4,16 @@ * ------------------------------------------------ * Name: Hexploration * Script: Hexploration.js - * Version: 2.0.0 - * Built: 2026-10-29T19:48:15.389Z + * Version: 2.0.1 + * Built: 2026-10-30T15:35:23.371Z */ const HexplorationMod = (() => { 'use strict'; // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; - const SCRIPT_VERSION = '2.0.0'; - const SCRIPT_LAST_UPDATED = '2026-10-29T19:48:15.389Z'; + const SCRIPT_VERSION = '2.0.1'; + const SCRIPT_LAST_UPDATED = '2026-10-30T15:35:23.371Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -234,6 +234,74 @@ const HexplorationMod = (() => { ); } + /** + * Parses a hex, rgb() or rgba() colour into its channels. + * + * @param {*} raw Colour text. + * @returns {{r: number, g: number, b: number, a: number}|null} Channels 0–255 and alpha 0–1, or null for other colours such as names. + */ + function parseColor(raw) { + const text = toText(raw); + + const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(text); + if (hex) { + const digits = hex[1].length <= 4 ? [...hex[1]].map((c) => c + c).join('') : hex[1]; + const [r, g, b, a = 255] = digits.match(/../g).map((pair) => parseInt(pair, 16)); + return { r, g, b, a: a / 255 }; + } + + const fn = + /^rgba?\(\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i.exec( + text + ); + if (!fn) { + return null; + } + const channel = (v) => + clamp(v.endsWith('%') ? (parseFloat(v) * 255) / 100 : parseFloat(v), 0, 255); + const alpha = + fn[4] === undefined ? 1 : fn[4].endsWith('%') ? parseFloat(fn[4]) / 100 : parseFloat(fn[4]); + return { r: channel(fn[1]), g: channel(fn[2]), b: channel(fn[3]), a: clamp(alpha, 0, 1) }; + } + + /** + * Converts a colour to the #rrggbb or #rrggbbaa form Jumpgate's pathv2 objects + * accept. Jumpgate silently ignores rgb(), rgba() and short hex colours, so a + * hex keeps its old colour. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for a pathv2 fill or stroke. + */ + function toPathV2Color(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + const hex = (n) => Math.round(n).toString(16).padStart(2, '0'); + const rgb = `#${hex(color.r)}${hex(color.g)}${hex(color.b)}`; + return color.a >= 1 ? rgb : `${rgb}${hex(color.a * 255)}`; + } + + /** + * Converts a colour to a form Roll20 chat keeps in inline styles. Chat drops + * #rrggbbaa colours and rgb() with an alpha value, leaving the style empty; + * #rrggbb and rgba() survive. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for chat HTML. + */ + function toChatColor(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + if (color.a >= 1) { + return toPathV2Color(raw); + } + const [r, g, b] = [color.r, color.g, color.b].map(Math.round); + return `rgba(${r},${g},${b},${Math.round(color.a * 100) / 100})`; + } + /** * Clamps a number into a range. * @@ -612,7 +680,7 @@ const HexplorationMod = (() => { */ function buildSwatch(color) { const safe = escapeHtml(color); - return ` ${safe}`; + return ` ${safe}`; } // Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, @@ -1249,7 +1317,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Seshoek-onthullingsafstand', - desc: "Word op seshoeke toegepas wanneer hulle geteken word: 'n token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien. Laat leeg vir geen beperking nie.", + desc: "Word op seshoeke gestoor wanneer hulle gevul word, so stel dit in voordat jy vul: om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien; met 0 word hulle slegs onthul deur hulle binne te gaan. Gebruik dit vir berge of woude. Laat leeg vir geen beperking nie.", }, revealDistance: { label: 'Sigafstand', @@ -1257,7 +1325,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Siglyn', - desc: "Wanneer dit aan is, word 'n seshoek slegs onthul as geen bedekte seshoek tussen dit en die token lê nie.", + desc: "Wanneer dit aan is, versteek seshoeke wat bedek bly, soos berge wat met 'n Seshoek-onthullingsafstand gevul is, die seshoeke agter hulle. Dit maak slegs 'n verskil met 'n Sigafstand van 2 of meer.", }, revealPath: { label: 'Onthul langs pad', @@ -1438,9 +1506,9 @@ const HexplorationMod = (() => { points: [ 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", - "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke. Met Siglyn aan, word 'n seshoek slegs onthul as geen bedekte seshoek tussenin lê nie.", - "Seshoek-onthullingsafstand word op seshoeke gestoor wanneer hulle geteken word. Daardie seshoeke word slegs van binne soveel seshoeke onthul, hoe ver 'n token ook al kan sien. Gebruik dit vir berge of woude wat versteek wat agter hulle lê.", - "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke, die naaste eerste. Met Siglyn aan word 'n seshoek nie onthul solank 'n bedekte seshoek tussen dit en die token lê nie. Nader seshoeke word gewoonlik eerste onthul, so in oop terrein verander Siglyn niks nie: dit maak slegs saak met 'n Sigafstand van 2 of meer en seshoeke wat bedek bly, soos terrein wat met 'n Seshoek-onthullingsafstand gevul is.", + "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', ], @@ -1625,7 +1693,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distància de revelació dels hexàgons', - desc: "S'aplica als hexàgons a mesura que es dibuixen: una fitxa ha d'estar dins d'aquests hexagones per revelar-los, per molt lluny que pugui veure. Deixeu buit sense límit.", + desc: "Es desa als hexàgons quan s'omplen, així que configureu-la abans d'omplir: canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure; amb 0, només es revelen quan s'hi entra. Utilitzeu-la per a muntanyes o boscos. Deixeu-ho buit perquè no hi hagi límit.", }, revealDistance: { label: 'Distància de visió', @@ -1633,7 +1701,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Línia de visió', - desc: 'Quan està activat, un hexàgon només es revela si no hi ha cap hexagonal cobert entre ell i la fitxa.', + desc: 'Quan està activat, els hexàgons que continuen coberts, com ara muntanyes omplertes amb una Distància de revelació dels hexàgons, amaguen els hexàgons que hi ha darrere. Només té efecte amb una Distància de visió de 2 o més.', }, revealPath: { label: 'Revela al llarg del camí', @@ -1816,9 +1884,9 @@ const HexplorationMod = (() => { points: [ 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", - "La distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons. Amb Línia de visió activada, un hexàgon només es revela si no hi ha cap hexàgon cobert entremig.", - "La distància de revelació dels hexàgons s'emmagatzema als hexàgons quan es dibuixen. Aquests hexàgons només es revelen des d'un màxim d'aquest nombre d'hexàgons, per lluny que pugui veure una fitxa. Utilitzeu-la per a muntanyes o boscos que amaguen el que hi ha darrere.", - "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa.", + "La Distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons, començant pels més propers. Amb la Línia de visió activada, un hexàgon no es revela mentre hi hagi un hexàgon cobert entre ell i la fitxa. Normalment els hexàgons més propers es revelen primer, de manera que en terreny obert la Línia de visió no canvia res: només importa amb una Distància de visió de 2 o més i hexàgons que continuen coberts, com ara terreny omplert amb una Distància de revelació dels hexàgons.", + "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", ], @@ -2002,7 +2070,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: '六角格揭示距離', - desc: '應用於繪製的六角形：令牌必須位於這麼多六角形內才能顯示它們，無論它能看到多遠。留空則無限制。', + desc: '六角格在填充時會儲存此值，因此請在填充前設定：之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於這麼多格以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。可用於山脈或森林。留空則無限制。', }, revealDistance: { label: '視距', @@ -2010,7 +2078,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: '視線', - desc: '啟用後，僅當六角形與令牌之間沒有被覆蓋的六角形時，該六角形才會顯示。', + desc: '啟用後，持續被覆蓋的六角格（例如以「六角格揭示距離」填充的山脈）會遮住其後方的六角格。只有在「視距」為 2 或以上時才會有差別。', }, revealPath: { label: '沿路徑顯示', @@ -2175,9 +2243,9 @@ const HexplorationMod = (() => { points: [ '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', - '視距顯示每個六角形周圍的六角形。當視線打開時，只有當中間沒有被覆蓋的六角形時才會顯示六角形。', - '「六角格揭示距離」會在六角格繪製時儲存在六角格上。無論令牌能看多遠，這些六角格都只會在該格數範圍內被揭示。可用於遮擋後方景物的山脈或森林。', - '在「瞥見」模式中，視線內的六角格會變為半透明而非消失，並在令牌進入時被移除。', + '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', + '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', + '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', ], @@ -2362,7 +2430,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Vzdálenost odhalení šestiúhelníků', - desc: 'Aplikuje se na hexy, když jsou taženy: žeton musí být v tomto počtu hexů, aby je odhalil, ať už vidí jakkoli daleko. Nechte prázdné bez omezení.', + desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', }, revealDistance: { label: 'Vzdálenost dohledu', @@ -2370,7 +2438,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Přímá viditelnost', - desc: 'Když je zapnuto, hex je odhalen pouze v případě, že mezi ním a žetonem není žádný krytý hex.', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', }, revealPath: { label: 'Odhalovat po cestě', @@ -2548,9 +2616,9 @@ const HexplorationMod = (() => { points: [ 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', - 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů. Se zapnutou Přímou viditelností je hex odhalen pouze tehdy, když mezi ním a žetonem neleží žádný zakrytý hex.', - 'Vzdálenost odhalení šestiúhelníků se ukládá do hexů při jejich kreslení. Tyto hexy lze odhalit jen ze vzdálenosti nejvýše tolika hexů, ať žeton vidí jakkoli daleko. Použijte ji pro hory nebo lesy, které zakrývají, co je za nimi.', - 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', ], @@ -2735,7 +2803,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Afsløringsafstand for hexfelter', - desc: 'Anvendes på hexes, efterhånden som de tegnes: Et symbol skal være inden for så mange hexes for at afsløre dem, uanset hvor langt det kan se. Lad være tomt uden grænse.', + desc: 'Gemmes på hexfelterne, når de udfyldes, så indstil den før udfyldning: Ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se; med 0 afsløres de kun ved at gå ind i dem. Brug den til bjerge eller skove. Lad feltet stå tomt for ingen grænse.', }, revealDistance: { label: 'Synsafstand', @@ -2743,7 +2811,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Synslinje', - desc: 'Når den er aktiveret, afsløres en hex kun, hvis der ikke er nogen dækket hex mellem den og tokenet.', + desc: 'Når den er slået til, skjuler hexfelter, der forbliver dækket, såsom bjerge udfyldt med en Afsløringsafstand for hexfelter, hexfelterne bag dem. Den gør kun en forskel med en Synsafstand på 2 eller mere.', }, revealPath: { label: 'Afslør langs ruten', @@ -2921,9 +2989,9 @@ const HexplorationMod = (() => { points: [ 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', - 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter. Med Synslinje slået til afsløres et hexfelt kun, hvis der ikke ligger noget dækket hexfelt imellem.', - 'Afsløringsafstand for hexfelter gemmes på hexfelterne, når de tegnes. Disse hexfelter afsløres kun inden for så mange hexfelters afstand, uanset hvor langt et token kan se. Brug det til bjerge eller skove, der skjuler, hvad der ligger bag dem.', - 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter, de nærmeste først. Med Synslinje slået til afsløres et hexfelt ikke, så længe der ligger et dækket hexfelt mellem det og tokenet. Nærmere hexfelter afsløres som regel først, så i åbent terræn ændrer Synslinje intet: Den har kun betydning med en Synsafstand på 2 eller mere og hexfelter, der forbliver dækket, såsom terræn udfyldt med en Afsløringsafstand for hexfelter.', + 'Afsløringsafstand for hexfelter gemmes på hvert hexfelt, når det udfyldes, så indstil den før udfyldning; ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se, og med 0 afsløres de kun ved at gå ind i dem. Til en bjergkæde: Sæt Afsløringsafstand for hexfelter til 0, udfyld bjergene, sæt den tilbage til ingen, og udfyld derefter landet bagved. Med Synsafstand 3 og Synslinje slået til ser gruppen det åbne terræn omkring sig, men ikke bjergene eller det, der ligger bag dem. Hvert bjerghexfelt afsløres, når et token går ind i det.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem. Gennemsigtige Glimt-hexfelter blokerer ikke Synslinje.', 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', ], @@ -3108,7 +3176,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Onthullingsafstand van zeshoeken', - desc: 'Toegepast op velden zoals ze worden getrokken: een token moet zich binnen zoveel velden bevinden om ze te onthullen, hoe ver hij ook kan kijken. Laat leeg voor geen limiet.', + desc: 'Wordt bij het vullen in de zeshoeken opgeslagen, dus stel dit in vóór het vullen: later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken; bij 0 worden ze alleen onthuld door ze te betreden. Gebruik dit voor bergen of bossen. Laat leeg voor geen limiet.', }, revealDistance: { label: 'Zichtafstand', @@ -3116,7 +3184,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Zichtlijn', - desc: 'Wanneer deze optie is ingeschakeld, wordt een vakje alleen onthuld als er geen afgedekt vakje tussen het vakje en het fiche ligt.', + desc: 'Wanneer deze optie aan staat, verbergen zeshoeken die bedekt blijven, zoals bergen die zijn gevuld met een Onthullingsafstand van zeshoeken, de zeshoeken erachter. Het maakt alleen verschil bij een Zichtafstand van 2 of meer.', }, revealPath: { label: 'Onthullen langs pad', @@ -3298,9 +3366,9 @@ const HexplorationMod = (() => { points: [ 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', - 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken. Als Zichtlijn aan staat, wordt een zeshoek alleen onthuld als er geen bedekte zeshoek tussen ligt.', - 'Onthullingsafstand van zeshoeken wordt bij het tekenen in de zeshoeken opgeslagen. Die zeshoeken worden alleen onthuld vanaf hooguit zoveel zeshoeken afstand, hoe ver een token ook kan kijken. Gebruik dit voor bergen of bossen die verbergen wat erachter ligt.', - 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken, de dichtstbijzijnde eerst. Als Zichtlijn aan staat, wordt een zeshoek niet onthuld zolang er een bedekte zeshoek tussen die zeshoek en het token ligt. Dichterbij gelegen zeshoeken worden meestal eerst onthuld, dus in open terrein verandert Zichtlijn niets: het telt alleen bij een Zichtafstand van 2 of meer en zeshoeken die bedekt blijven, zoals terrein dat is gevuld met een Onthullingsafstand van zeshoeken.', + 'Onthullingsafstand van zeshoeken wordt bij het vullen in elke zeshoek opgeslagen, dus stel dit in vóór het vullen; later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken, en bij 0 worden ze alleen onthuld door ze te betreden. Voor een bergketen: stel Onthullingsafstand van zeshoeken in op 0, vul de bergen, zet de waarde terug op geen en vul daarna het land erachter. Met Zichtafstand 3 en Zichtlijn aan ziet de groep het open terrein om zich heen, maar niet de bergen of wat erachter ligt. Elke bergzeshoek wordt onthuld wanneer een token erin stapt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt. Doorzichtige Glimp-zeshoeken blokkeren de Zichtlijn niet.', 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', ], @@ -3485,7 +3553,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Hex Reveal Distance', - desc: 'Applied to hexes as they are drawn: a token must be within this many hexes to reveal them, however far it can see. Leave empty for no limit.', + desc: 'Stored on hexes when they are filled, so set it before filling: changing it later does not affect hexes already on the map. A token must be within this many hexes to reveal them, however far it can see; with 0 they are only revealed by entering them. Use it for mountains or forests. Leave empty for no limit.', }, revealDistance: { label: 'Sight Distance', @@ -3493,7 +3561,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Line of Sight', - desc: 'When on, a hex is only revealed if no covered hex lies between it and the token.', + desc: 'When on, hexes that stay covered, such as mountains filled with a Hex Reveal Distance, hide the hexes behind them. It only makes a difference with a Sight Distance of 2 or more.', }, revealPath: { label: 'Reveal Along Path', @@ -3667,9 +3735,9 @@ const HexplorationMod = (() => { points: [ 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', - 'Sight Distance reveals the hexes around each of those hexes. With Line of Sight on, a hex is only revealed if no covered hex lies in between.', - 'Hex Reveal Distance is stored on hexes as they are drawn. Those hexes are only revealed from within that many hexes, however far a token can see. Use it for mountains or forests that hide what is behind them.', - 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them.', + 'Sight Distance reveals the hexes around each of those hexes, nearest first. With Line of Sight on, a hex is not revealed while a covered hex lies between it and the token. Nearer hexes are usually revealed first, so in open country Line of Sight changes nothing: it only matters with a Sight Distance of 2 or more and hexes that stay covered, such as terrain filled with a Hex Reveal Distance.', + 'Hex Reveal Distance is stored on each hex when it is filled, so set it before filling; changing it later does not affect hexes already on the map. A token must be within that many hexes to reveal them, however far it can see, and with 0 they are only revealed by entering them. For a mountain range: set Hex Reveal Distance to 0, fill the mountains, set it back to none, then fill the land beyond. With Sight Distance 3 and Line of Sight on, the party sees the open ground around them, but not the mountains or what lies behind them. Each mountain hex is revealed when a token walks into it.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them. Glimpsed hexes do not block Line of Sight.', 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', ], @@ -3854,7 +3922,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Heksojen paljastusetäisyys', - desc: 'Soveltuu heksaan, kun ne on piirretty: merkki on oltava tämän monen heksan sisällä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee. Jätä tyhjäksi ilman rajoituksia.', + desc: 'Tallennetaan heksoihin, kun ne täytetään, joten aseta se ennen täyttämistä: myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee; arvolla 0 ne paljastuvat vain, kun niihin astutaan. Käytä sitä vuorille tai metsille. Jätä tyhjäksi, jos rajaa ei haluta.', }, revealDistance: { label: 'Näköetäisyys', @@ -3862,7 +3930,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Näköyhteys', - desc: 'Kun heksa on päällä, se paljastuu vain, jos sen ja merkin välissä ei ole peitettyä heksaa.', + desc: 'Kun asetus on päällä, peitettyinä pysyvät heksat, kuten Heksojen paljastusetäisyys -asetuksella täytetyt vuoret, kätkevät takanaan olevat heksat. Sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän.', }, revealPath: { label: 'Paljasta reitin varrelta', @@ -4042,9 +4110,9 @@ const HexplorationMod = (() => { points: [ 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', - 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat. Kun Näköyhteys on päällä, heksa paljastetaan vain, jos välissä ei ole peitettyä heksaa.', - 'Heksojen paljastusetäisyys tallennetaan heksoihin niitä piirrettäessä. Nämä heksat paljastuvat vain enintään näin monen heksan päästä, vaikka merkki näkisi kauemmas. Käytä sitä vuorille tai metsille, jotka kätkevät taakseen jäävän.', - 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat, lähimmät ensin. Kun Näköyhteys on päällä, heksaa ei paljasteta niin kauan kuin sen ja merkin välissä on peitetty heksa. Lähemmät heksat paljastuvat yleensä ensin, joten avoimessa maastossa Näköyhteys ei muuta mitään: sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän ja jotkin heksat pysyvät peitettyinä, kuten Heksojen paljastusetäisyys -asetuksella täytetty maasto.', + 'Heksojen paljastusetäisyys tallennetaan jokaiseen heksaan, kun se täytetään, joten aseta se ennen täyttämistä; myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, vaikka se näkisi kauemmas, ja arvolla 0 ne paljastuvat vain, kun niihin astutaan. Vuorijonoa varten: aseta Heksojen paljastusetäisyys arvoon 0, täytä vuoret, palauta asetus tyhjäksi ja täytä sitten takana oleva maa. Kun Näköetäisyys on 3 ja Näköyhteys on päällä, seurue näkee ympärillään olevan avoimen maaston mutta ei vuoria eikä sitä, mitä niiden takana on. Kukin vuoriheksa paljastuu, kun merkki astuu siihen.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin. Vilkaisun läpikuultavat heksat eivät estä näkyvyyttä Näköyhteys-asetuksessa.', 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', ], @@ -4229,7 +4297,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distance de révélation des hexagones', - desc: "Appliqué aux hexagones au fur et à mesure qu'ils sont dessinés : un jeton doit se trouver dans ce nombre d'hexagones pour les révéler, aussi loin qu'il puisse voir. Laissez vide sans limite.", + desc: "Enregistrée sur les hexagones au moment où ils sont remplis, donc réglez-la avant de remplir : la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir ; avec 0, ils ne sont révélés qu'en y entrant. Utilisez-la pour des montagnes ou des forêts. Laissez vide pour ne fixer aucune limite.", }, revealDistance: { label: 'Distance de vue', @@ -4237,7 +4305,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Ligne de vue', - desc: "Lorsque cette option est activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre lui et le jeton.", + desc: "Lorsque cette option est activée, les hexagones qui restent couverts, comme des montagnes remplies avec une Distance de révélation des hexagones, cachent les hexagones situés derrière eux. Elle n'a d'effet qu'avec une Distance de vue de 2 ou plus.", }, revealPath: { label: 'Révéler le long du chemin', @@ -4422,9 +4490,9 @@ const HexplorationMod = (() => { points: [ 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", - "La distance de vue révèle les hexagones autour de chacun de ces hexagones. Avec Ligne de vue activée, un hexagone n'est révélé que si aucun hexagone couvert ne se trouve entre les deux.", - "La distance de révélation des hexagones est enregistrée sur les hexagones au moment où ils sont dessinés. Ces hexagones ne sont révélés que depuis ce nombre d'hexagones au plus, quelle que soit la distance à laquelle un jeton peut voir. Utilisez-la pour des montagnes ou des forêts qui cachent ce qui se trouve derrière elles.", - "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre.", + "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", + "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", ], @@ -4609,7 +4677,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Aufdeckungsdistanz für Hexfelder', - desc: 'Wird auf Hexfelder angewendet, wenn sie gezogen werden: Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann. Für keine Begrenzung leer lassen.', + desc: 'Wird beim Füllen in den Hexfeldern gespeichert, also vor dem Füllen festlegen: Spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann; bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für Berge oder Wälder verwenden. Für keine Begrenzung leer lassen.', }, revealDistance: { label: 'Sichtweite', @@ -4617,7 +4685,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Sichtlinie', - desc: 'Wenn diese Option aktiviert ist, wird ein Hexfeld nur dann aufgedeckt, wenn kein abgedecktes Hexfeld zwischen ihm und dem Spielstein liegt.', + desc: 'Wenn diese Option aktiviert ist, verbergen Hexfelder, die verdeckt bleiben, etwa Berge, die mit einer Aufdeckungsdistanz für Hexfelder gefüllt wurden, die Hexfelder dahinter. Das macht nur bei einer Sichtweite von 2 oder mehr einen Unterschied.', }, revealPath: { label: 'Entlang des Wegs aufdecken', @@ -4808,9 +4876,9 @@ const HexplorationMod = (() => { points: [ 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', - '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nur aufgedeckt, wenn kein verdecktes Hexfeld dazwischen liegt.', - '„Aufdeckungsdistanz für Hexfelder“ wird beim Zeichnen in den Hexfeldern gespeichert. Diese Hexfelder werden nur aus höchstens so vielen Hexfeldern Entfernung aufgedeckt, egal wie weit ein Token sehen kann. Nutzen Sie dies für Berge oder Wälder, die verbergen, was dahinter liegt.', - 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf, die nächstgelegenen zuerst. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nicht aufgedeckt, solange ein verdecktes Hexfeld zwischen ihm und dem Token liegt. Nähere Hexfelder werden meist zuerst aufgedeckt, daher ändert „Sichtlinie“ in offenem Gelände nichts: Sie spielt nur bei einer „Sichtweite“ von 2 oder mehr und bei Hexfeldern eine Rolle, die verdeckt bleiben, etwa Gelände, das mit einer „Aufdeckungsdistanz für Hexfelder“ gefüllt wurde.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Füllen in jedem Hexfeld gespeichert, legen Sie sie also vor dem Füllen fest; spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Token muss sich innerhalb so vieler Hexfelder befinden, um sie aufzudecken, egal wie weit es sehen kann, und bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für eine Bergkette: Setzen Sie „Aufdeckungsdistanz für Hexfelder“ auf 0, füllen Sie die Berge, setzen Sie den Wert wieder auf „keine“ zurück und füllen Sie dann das Land dahinter. Mit „Sichtweite“ 3 und aktivierter „Sichtlinie“ sieht die Gruppe das offene Gelände um sich herum, aber weder die Berge noch das, was dahinter liegt. Jedes Berg-Hexfeld wird aufgedeckt, wenn ein Token es betritt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt. Durchsichtige Hexfelder blockieren die „Sichtlinie“ nicht.', 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', ], @@ -4995,7 +5063,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Απόσταση αποκάλυψης εξαγώνων', - desc: 'Εφαρμόζεται στα εξάγωνα καθώς σχεδιάζονται: ένα διακριτικό πρέπει να βρίσκεται μέσα σε τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά μπορεί να δει. Αφήστε κενό χωρίς όριο.', + desc: 'Αποθηκεύεται στα εξάγωνα όταν γεμίζονται, οπότε ορίστε το πριν από το γέμισμα: αν το αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει· με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Χρησιμοποιήστε το για βουνά ή δάση. Αφήστε το κενό για να μην υπάρχει όριο.', }, revealDistance: { label: 'Απόσταση όρασης', @@ -5003,7 +5071,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Γραμμή όρασης', - desc: 'Όταν είναι ενεργοποιημένο, ένα εξάγωνο αποκαλύπτεται μόνο εάν δεν υπάρχει καλυμμένο εξάγωνο μεταξύ αυτού και του διακριτικού.', + desc: 'Όταν είναι ενεργοποιημένο, τα εξάγωνα που παραμένουν καλυμμένα, όπως βουνά που γεμίστηκαν με «Απόσταση αποκάλυψης εξαγώνων», κρύβουν τα εξάγωνα πίσω τους. Κάνει διαφορά μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη.', }, revealPath: { label: 'Αποκάλυψη κατά μήκος της διαδρομής', @@ -5184,9 +5252,9 @@ const HexplorationMod = (() => { points: [ 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', - 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο αποκαλύπτεται μόνο αν δεν παρεμβάλλεται καλυμμένο εξάγωνο.', - 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται στα εξάγωνα καθώς σχεδιάζονται. Αυτά τα εξάγωνα αποκαλύπτονται μόνο από απόσταση έως τόσα εξάγωνα, όσο μακριά κι αν βλέπει ένα διακριτικό. Χρησιμοποιήστε την για βουνά ή δάση που κρύβουν ό,τι βρίσκεται πίσω τους.', - 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα, ξεκινώντας από τα πλησιέστερα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο δεν αποκαλύπτεται όσο παρεμβάλλεται καλυμμένο εξάγωνο ανάμεσα σε αυτό και στο διακριτικό. Τα πλησιέστερα εξάγωνα συνήθως αποκαλύπτονται πρώτα, οπότε σε ανοιχτό έδαφος η «Γραμμή όρασης» δεν αλλάζει τίποτα: έχει σημασία μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη και εξάγωνα που παραμένουν καλυμμένα, όπως έδαφος που γεμίστηκε με «Απόσταση αποκάλυψης εξαγώνων».', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται σε κάθε εξάγωνο όταν γεμίζεται, οπότε ορίστε την πριν από το γέμισμα· αν την αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει, και με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Για μια οροσειρά: ορίστε την «Απόσταση αποκάλυψης εξαγώνων» σε 0, γεμίστε τα βουνά, επαναφέρετέ την σε καμία τιμή και μετά γεμίστε τη γη πέρα από αυτά. Με «Απόσταση όρασης» 3 και ενεργή τη «Γραμμή όρασης», η ομάδα βλέπει το ανοιχτό έδαφος γύρω της, αλλά όχι τα βουνά ή ό,τι βρίσκεται πίσω τους. Κάθε ορεινό εξάγωνο αποκαλύπτεται όταν ένα διακριτικό μπει σε αυτό.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό. Τα εξάγωνα σε κατάσταση «Ματιά» δεν εμποδίζουν τη «Γραμμή όρασης».', 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', ], @@ -5371,7 +5439,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'מרחק חשיפת משושים', - desc: 'מיושם על משושים כשהם מצוירים: אסימון חייב להיות בתוך כל כך הרבה משושות כדי לחשוף אותם, כמה רחוק שהוא יכול לראות. השאר ריק ללא הגבלה.', + desc: 'נשמר על המשושים בעת מילוים, לכן הגדר אותו לפני המילוי: שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות; עם 0 הם נחשפים רק כשנכנסים אליהם. השתמש בו להרים או ליערות. השאר ריק ללא הגבלה.', }, revealDistance: { label: 'מרחק ראייה', @@ -5379,7 +5447,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'קו ראייה', - desc: 'כאשר מופעל, משושה מתגלה רק אם אין משושה מכוסה בינו לבין האסימון.', + desc: 'כאשר מופעל, משושים שנשארים מכוסים, כמו הרים שמולאו עם מרחק חשיפת משושים, מסתירים את המשושים שמאחוריהם. יש לכך השפעה רק עם מרחק ראייה של 2 ומעלה.', }, revealPath: { label: 'חשיפה לאורך המסלול', @@ -5551,9 +5619,9 @@ const HexplorationMod = (() => { points: [ 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', - 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושות. כשקו הראייה פועל, משושה מתגלה רק אם אין שום משושה מכוסה באמצע.', - 'מרחק חשיפת משושים נשמר על המשושים בזמן שהם מצוירים. משושים אלה נחשפים רק מטווח של מספר המשושים הזה, לא משנה כמה רחוק אסימון יכול לראות. השתמש בו להרים או ליערות שמסתירים את מה שמאחוריהם.', - 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושים, מהקרוב ביותר תחילה. כשקו ראייה מופעל, משושה אינו נחשף כל עוד יש משושה מכוסה בינו לבין האסימון. משושים קרובים יותר נחשפים בדרך כלל ראשונים, ולכן בשטח פתוח קו ראייה אינו משנה דבר: יש לו השפעה רק עם מרחק ראייה של 2 ומעלה ומשושים שנשארים מכוסים, כמו שטח שמולא עם מרחק חשיפת משושים.', + 'מרחק חשיפת משושים נשמר על כל משושה בעת מילויו, לכן הגדר אותו לפני המילוי; שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות, ועם 0 הם נחשפים רק כשנכנסים אליהם. לרכס הרים: הגדר את מרחק חשיפת משושים ל-0, מלא את ההרים, החזר אותו ל"ללא", ואז מלא את השטח שמעבר להם. עם מרחק ראייה 3 וקו ראייה מופעל, החבורה רואה את השטח הפתוח סביבה, אך לא את ההרים או את מה שמאחוריהם. כל משושה הר נחשף כאשר אסימון נכנס אליו.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם. משושים במצב הצצה אינם חוסמים קו ראייה.', 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', ], @@ -5738,7 +5806,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Hatszögek felfedési távolsága', - desc: 'A húzott hatszögekre alkalmazva: egy jelzőnek ezen a sok hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire is lásson. Hagyja üresen korlátozás nélkül.', + desc: 'A hatszögek kitöltésekor kerül tárolásra rajtuk, ezért a kitöltés előtt állítsa be: a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is; 0 esetén csak akkor fedődnek fel, ha belépnek beléjük. Hegyekhez vagy erdőkhöz használja. Hagyja üresen, ha nem kíván korlátozást.', }, revealDistance: { label: 'Látótávolság', @@ -5746,7 +5814,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Látóvonal', - desc: 'Ha be van kapcsolva, egy hatszög csak akkor derül ki, ha nincs fedett hatszög közte és a token között.', + desc: 'Ha be van kapcsolva, a fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött hegyek, eltakarják a mögöttük lévő hatszögeket. Csak akkor számít, ha a Látótávolság legalább 2.', }, revealPath: { label: 'Felfedés az útvonal mentén', @@ -5927,9 +5995,9 @@ const HexplorationMod = (() => { points: [ 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', - 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel. Ha a Látóvonal be van kapcsolva, egy hatszög csak akkor fedődik fel, ha nincs közte és a token között lefedett hatszög.', - 'A Hatszögek felfedési távolsága a hatszögek megrajzolásakor kerül tárolásra rajtuk. Ezek a hatszögek csak ennyi hatszögnyi távolságon belülről fedhetők fel, bármilyen messzire lát is egy token. Hegyekhez vagy erdőkhöz használja, amelyek eltakarják, ami mögöttük van.', - 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és akkor tűnnek el, amikor egy token belép beléjük.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel, a legközelebbiekkel kezdve. Ha a Látóvonal be van kapcsolva, egy hatszög nem fedődik fel, amíg közte és a token között lefedett hatszög van. A közelebbi hatszögek általában előbb fedődnek fel, így nyílt terepen a Látóvonal semmin sem változtat: csak akkor számít, ha a Látótávolság legalább 2, és vannak fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött terep.', + 'A Hatszögek felfedési távolsága minden hatszögön a kitöltésekor kerül tárolásra, ezért a kitöltés előtt állítsa be; a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is, 0 esetén pedig csak akkor fedődnek fel, ha belépnek beléjük. Hegyvonulathoz: állítsa a Hatszögek felfedési távolsága értékét 0-ra, töltse ki a hegyeket, állítsa vissza üresre (korlátozás nélkül), majd töltse ki a mögöttük lévő vidéket. Ha a Látótávolság 3 és a Látóvonal be van kapcsolva, a csapat látja a körülötte lévő nyílt terepet, de a hegyeket és azt, ami mögöttük van, nem. Minden hegyi hatszög akkor fedődik fel, amikor egy token belép bele.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és eltávolításra kerülnek, amikor egy token belép beléjük. A Bepillantás módban látott hatszögek a Látóvonal szempontjából nem számítanak takarásnak.', 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', ], @@ -6114,7 +6182,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distanza di rivelazione degli esagoni', - desc: 'Applicato agli esagoni mentre vengono disegnati: un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere. Lascia vuoto per nessun limite.', + desc: 'Memorizzata sugli esagoni quando vengono riempiti, quindi impostala prima di riempire: modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere; con 0 vengono rivelati solo entrandoci. Usala per montagne o foreste. Lascia vuoto per nessun limite.', }, revealDistance: { label: 'Distanza di vista', @@ -6122,7 +6190,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linea di vista', - desc: 'Quando è attivo, un esagono viene rivelato solo se non si trova alcun esagono coperto tra esso e il segnalino.', + desc: 'Quando è attivo, gli esagoni che restano coperti, come le montagne riempite con una Distanza di rivelazione degli esagoni, nascondono gli esagoni dietro di essi. Fa differenza solo con una Distanza di vista di 2 o più.', }, revealPath: { label: 'Rivela lungo il percorso', @@ -6304,9 +6372,9 @@ const HexplorationMod = (() => { points: [ 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', - "La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni. Con Linea di vista attiva, un esagono viene rivelato solo se in mezzo non c'è alcun esagono coperto.", - "La Distanza di rivelazione degli esagoni viene memorizzata sugli esagoni nel momento in cui vengono disegnati. Quegli esagoni vengono rivelati solo da non più di quel numero di esagoni di distanza, per quanto lontano possa vedere un segnalino. Usala per montagne o foreste che nascondono ciò che c'è dietro.", - 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra.', + 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', + "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", ], @@ -6491,7 +6559,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'ヘクスの公開距離', - desc: 'ヘクスが描画されるときに適用されます。トークンは、どれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス内に存在する必要があります。制限を設けない場合は空のままにします。', + desc: 'ヘクスを塗りつぶすときにヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス以内にいる必要があります。0の場合、ヘクスに入ったときにのみ公開されます。山や森に使用します。制限を設けない場合は空のままにします。', }, revealDistance: { label: '視界距離', @@ -6499,7 +6567,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: '視線', - desc: 'オンの場合、ヘクスは、そのヘクスとトークンの間に覆われたヘクスがない場合にのみ公開されます。', + desc: 'オンの場合、「ヘクスの公開距離」を設定して塗りつぶした山など、覆われたままのヘクスが、その背後のヘクスを隠します。「視界距離」が2以上の場合にのみ違いが出ます。', }, revealPath: { label: '経路に沿って表示', @@ -6677,9 +6745,9 @@ const HexplorationMod = (() => { points: [ 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', - '「視界距離」は、それらの各ヘクスの周囲のヘクスを表示します。「視線」がオンの場合、間に覆われたヘクスがないときだけヘクスが表示されます。', - '「ヘクスの公開距離」は、ヘクスを描画するときにそのヘクスに保存されます。それらのヘクスは、トークンがどれだけ遠くまで見えても、その数のヘクス以内からしか表示されません。背後を隠す山や森に使用します。', - '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを近い順に公開します。「視線」がオンの場合、ヘクスとトークンの間に覆われたヘクスがある間は、そのヘクスは公開されません。通常は近いヘクスから先に公開されるため、開けた土地では「視線」は何も変えません。意味を持つのは、「視界距離」が2以上で、「ヘクスの公開距離」を設定して塗りつぶした地形など、覆われたままのヘクスがある場合だけです。', + '「ヘクスの公開距離」は、ヘクスを塗りつぶすときに各ヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはその数のヘクス以内にいる必要があり、0の場合はヘクスに入ったときにのみ公開されます。山脈の場合：「ヘクスの公開距離」を0に設定して山を塗りつぶし、設定をなしに戻してから、その先の土地を塗りつぶします。「視界距離」を3にして「視線」をオンにすると、パーティーは周囲の開けた土地は見えますが、山やその背後にあるものは見えません。各山岳ヘクスは、トークンがその中に入ったときに公開されます。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。透過状態のヘクスは「視線」を遮りません。', 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', ], @@ -6864,7 +6932,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: '헥스 공개 거리', - desc: '그려진 헥스에 적용됩니다. 토큰이 볼 수 있는 범위에 관계없이 토큰을 표시하려면 이 많은 헥스 내에 있어야 합니다. 제한이 없으면 비워 두세요.', + desc: '헥스를 채울 때 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 이 헥스 수 이내에 있어야 합니다. 0이면 헥스에 들어가야만 공개됩니다. 산이나 숲에 사용하세요. 제한이 없으면 비워 두세요.', }, revealDistance: { label: '시야 거리', @@ -6872,7 +6940,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: '시선', - desc: '켜져 있으면 헥스와 토큰 사이에 가려진 헥스가 없는 경우에만 헥스가 드러납니다.', + desc: '켜져 있으면, 헥스 공개 거리로 채운 산처럼 계속 덮여 있는 헥스가 그 뒤의 헥스를 가립니다. 시야 거리가 2 이상일 때만 차이가 있습니다.', }, revealPath: { label: '경로를 따라 표시', @@ -7048,9 +7116,9 @@ const HexplorationMod = (() => { points: [ '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', - '시야 거리는 각 헥스 주변의 헥스를 나타냅니다. 시선이 켜진 상태에서, 가려진 헥스가 사이에 없는 경우에만 헥스가 드러납니다.', - '헥스 공개 거리는 헥스를 그릴 때 그 헥스에 저장됩니다. 그런 헥스는 토큰이 얼마나 멀리 볼 수 있든 그 헥스 수 이내에서만 공개됩니다. 뒤에 있는 것을 가리는 산이나 숲에 사용하세요.', - '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다.', + '시야 거리는 그 각 헥스 주변의 헥스를 가까운 것부터 공개합니다. 시선이 켜져 있으면, 헥스와 토큰 사이에 덮인 헥스가 있는 동안에는 그 헥스가 공개되지 않습니다. 보통 가까운 헥스가 먼저 공개되므로 탁 트인 지형에서는 시선이 아무것도 바꾸지 않습니다. 시야 거리가 2 이상이고, 헥스 공개 거리로 채운 지형처럼 계속 덮여 있는 헥스가 있을 때만 의미가 있습니다.', + '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], @@ -7235,7 +7303,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Odległość odkrywania heksagonów', - desc: 'Dotyczy to dobieranych heksów: żeton musi znajdować się w obrębie określonej liczby heksów, aby je odsłonić, bez względu na to, jak daleko sięga. Pozostaw puste bez ograniczeń.', + desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', }, revealDistance: { label: 'Zasięg wzroku', @@ -7243,7 +7311,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linia wzroku', - desc: 'Kiedy jest włączone, heks jest odkrywany tylko wtedy, gdy pomiędzy nim a żetonem nie leży żaden zakryty heks.', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', }, revealPath: { label: 'Odkrywaj wzdłuż ścieżki', @@ -7423,9 +7491,9 @@ const HexplorationMod = (() => { points: [ 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', - '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów. Gdy „Linia wzroku” jest włączona, heks zostaje odkryty tylko wtedy, gdy między nim a żetonem nie leży żaden zakryty heks.', - '„Odległość odkrywania heksagonów” jest zapisywana na heksach w chwili ich rysowania. Takie heksy można odkryć tylko z odległości najwyżej tylu heksów, niezależnie od tego, jak daleko widzi żeton. Używaj jej dla gór lub lasów, które zasłaniają to, co jest za nimi.', - 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', + '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', ], @@ -7610,7 +7678,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para os revelar, por mais longe que possa ver. Deixe em branco sem limite.', + desc: 'Guardada nos hexágonos quando são preenchidos, por isso defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, este número de hexágonos para os revelar, por mais longe que consiga ver; com 0, só são revelados quando se entra neles. Utilize-a para montanhas ou florestas. Deixe em branco para não haver limite.', }, revealDistance: { label: 'Distância de visão', @@ -7618,7 +7686,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linha de visão', - desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + desc: 'Quando ativado, os hexágonos que continuam cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos que estão por trás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', }, revealPath: { label: 'Revelar ao longo do percurso', @@ -7800,9 +7868,9 @@ const HexplorationMod = (() => { points: [ 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', - 'A Distância de Visão revela os hexágonos em torno de cada um destes hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não existir nenhum hexágono coberto entre eles.', - 'A Distância de revelação dos hexágonos é guardada nos hexágonos quando são desenhados. Esses hexágonos só são revelados a, no máximo, esse número de hexágonos de distância, por mais longe que uma ficha consiga ver. Utilize-a para montanhas ou florestas que escondem o que está por trás delas.', - 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles.', + 'A Distância de visão revela os hexágonos em torno de cada um destes hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto existir um hexágono coberto entre ele e a ficha. Os hexágonos mais próximos são normalmente revelados primeiro, por isso em terreno aberto a Linha de visão não altera nada: só tem importância com uma Distância de visão de 2 ou mais e hexágonos que continuam cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é guardada em cada hexágono quando este é preenchido, por isso defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, esse número de hexágonos para os revelar, por mais longe que consiga ver, e com 0 só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e depois preencha as terras mais além. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto à sua volta, mas não as montanhas nem o que está por trás delas. Cada hexágono de montanha é revelado quando uma ficha entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', ], @@ -7987,7 +8055,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Aplicado aos hexágonos à medida que são desenhados: uma ficha deve estar dentro deste número de hexágonos para revelá-los, por mais longe que possa ver. Deixe em branco sem limite.', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', }, revealDistance: { label: 'Distância de visão', @@ -7995,7 +8063,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linha de visão', - desc: 'Quando ativado, um hexágono só é revelado se nenhum hexágono coberto estiver entre ele e a ficha.', + desc: 'Quando ativado, os hexágonos que permanecem cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos atrás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', }, revealPath: { label: 'Revelar ao longo do caminho', @@ -8177,9 +8245,9 @@ const HexplorationMod = (() => { points: [ 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', - 'A Distância de Visão revela os hexágonos em torno de cada um desses hexágonos. Com a Linha de Visão ativada, um hexágono só é revelado se não houver nenhum hexágono coberto entre eles.', - 'A Distância de revelação dos hexágonos é gravada nos hexágonos quando eles são desenhados. Esses hexágonos só são revelados a no máximo essa quantidade de hexágonos de distância, por mais longe que um token consiga ver. Use-a para montanhas ou florestas que escondem o que há atrás delas.', - 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles.', + 'A Distância de visão revela os hexágonos em torno de cada um desses hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto houver um hexágono coberto entre ele e o token. Os hexágonos mais próximos costumam ser revelados primeiro, então em terreno aberto a Linha de visão não muda nada: ela só importa com uma Distância de visão de 2 ou mais e hexágonos que permanecem cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é gravada em cada hexágono quando ele é preenchido, então defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo essa quantidade de hexágonos para revelá-los, por mais longe que consiga ver, e com 0 eles só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e então preencha as terras mais adiante. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto ao seu redor, mas não as montanhas nem o que há atrás delas. Cada hexágono de montanha é revelado quando um token entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', ], @@ -8364,7 +8432,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Дальность раскрытия шестиугольников', - desc: 'Применительно к нарисованным гексам: фишка должна находиться в пределах этого количества гексов, чтобы их можно было обнаружить, как бы далеко он ни видел. Оставьте пустым, чтобы не было ограничений.', + desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { label: 'Расстояние обзора', @@ -8372,7 +8440,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Линия видимости', - desc: 'Когда эта опция включена, гекс раскрывается только в том случае, если между ним и жетоном нет закрытого гекса.', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', }, revealPath: { label: 'Раскрывать вдоль пути', @@ -8552,9 +8620,9 @@ const HexplorationMod = (() => { points: [ 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', - '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов. При включённой «Линии видимости» гекс раскрывается, только если между ним и токеном нет закрытого гекса.', - '«Дальность раскрытия шестиугольников» сохраняется в гексах при их рисовании. Такие гексы раскрываются только с расстояния не больше этого числа гексов, как бы далеко ни видел токен. Используйте её для гор или лесов, скрывающих то, что за ними.', - 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', + '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', ], @@ -8739,7 +8807,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distancia de revelación de hexágonos', - desc: 'Se aplica a los hexágonos a medida que se dibujan: una ficha debe estar dentro de esta cantidad de hexágonos para revelarlos, por muy lejos que pueda ver. Déjelo vacío sin límite.', + desc: 'Se guarda en los hexágonos cuando se rellenan, así que configúrelo antes de rellenar: cambiarlo después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esta cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver; con 0, sólo se revelan al entrar en ellos. Úselo para montañas o bosques. Déjelo vacío para no tener límite.', }, revealDistance: { label: 'Distancia de visión', @@ -8747,7 +8815,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Línea de visión', - desc: 'Cuando está activado, un hexágono sólo se revela si no hay ningún hexágono cubierto entre él y la ficha.', + desc: 'Cuando está activado, los hexágonos que siguen cubiertos, como las montañas rellenadas con una Distancia de revelación de hexágonos, ocultan los hexágonos que hay detrás de ellos. Sólo tiene efecto con una Distancia de visión de 2 o más.', }, revealPath: { label: 'Revelar a lo largo del camino', @@ -8931,9 +8999,9 @@ const HexplorationMod = (() => { points: [ 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', - 'La distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos. Con la Línea de Visión activada, un hexágono sólo se revela si no hay ningún hexágono cubierto en el medio.', - 'La distancia de revelación de hexágonos se almacena en los hexágonos a medida que se dibujan. Esos hexágonos sólo se revelan desde dentro de esa cantidad de hexágonos, por muy lejos que pueda ver una ficha. Úselo para montañas o bosques que ocultan lo que hay detrás de ellos.', - 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha ingresa en ellos.', + 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', + 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', ], @@ -9118,7 +9186,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Avslöjandeavstånd för hexar', - desc: 'Tillämpas på hexar när de ritas: en token måste finnas inom så många hexes för att avslöja dem, hur långt den än kan se. Lämna tomt utan gräns.', + desc: 'Lagras på hexarna när de fylls, så ställ in det innan du fyller: att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se; med 0 avslöjas de bara när man går in i dem. Använd det för berg eller skogar. Lämna tomt för ingen gräns.', }, revealDistance: { label: 'Siktavstånd', @@ -9126,7 +9194,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Siktlinje', - desc: 'När den är på avslöjas en hex endast om ingen täckt hex ligger mellan den och token.', + desc: 'När den är på döljer hexar som förblir täckta, till exempel berg som fyllts med ett Avslöjandeavstånd för hexar, hexarna bakom dem. Det gör bara skillnad med ett Siktavstånd på 2 eller mer.', }, revealPath: { label: 'Avslöja längs vägen', @@ -9302,9 +9370,9 @@ const HexplorationMod = (() => { points: [ 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', - 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar. Med Siktlinje på avslöjas en hex bara om ingen täckt hex ligger emellan.', - 'Avslöjandeavstånd för hexar lagras på hexarna när de ritas. Dessa hexar avslöjas bara inom så många hexars avstånd, hur långt en token än kan se. Använd det för berg eller skogar som döljer vad som finns bakom dem.', - 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar, de närmaste först. Med Siktlinje på avslöjas en hex inte så länge en täckt hex ligger mellan den och token. Närmare hexar avslöjas oftast först, så i öppen terräng ändrar Siktlinje ingenting: den spelar bara roll med ett Siktavstånd på 2 eller mer och hexar som förblir täckta, till exempel terräng som fyllts med ett Avslöjandeavstånd för hexar.', + 'Avslöjandeavstånd för hexar lagras på varje hex när den fylls, så ställ in det innan du fyller; att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se, och med 0 avslöjas de bara när man går in i dem. För en bergskedja: ställ in Avslöjandeavstånd för hexar på 0, fyll bergen, återställ det till inget och fyll sedan landet bortom. Med Siktavstånd 3 och Siktlinje på ser gruppen den öppna marken runt sig, men inte bergen eller det som ligger bakom dem. Varje berghex avslöjas när en token går in i den.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem. Genomskinliga Glimt-hexar blockerar inte Siktlinje.', 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', ], @@ -9489,7 +9557,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Altıgen Açığa Çıkarma Mesafesi', - desc: 'Altıgenlere çizilirken uygulanır: Bir jetonun, görebildiği kadar uzağı ortaya çıkarabilmesi için bu sayıda altıgen içinde olması gerekir. Sınırsız olarak boş bırakın.', + desc: 'Altıgenler doldurulurken onlara kaydedilir, bu yüzden doldurmadan önce ayarlayın: sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için bu kadar altıgen mesafede olmalıdır; 0 ile yalnızca içlerine girilerek açığa çıkarlar. Dağlar veya ormanlar için kullanın. Sınır olmaması için boş bırakın.', }, revealDistance: { label: 'Görüş Mesafesi', @@ -9497,7 +9565,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Görüş Hattı', - desc: 'Açıkken, bir altıgen yalnızca onunla belirteç arasında örtülü bir altıgen bulunmadığında ortaya çıkar.', + desc: 'Açıkken, Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş dağlar gibi örtülü kalan altıgenler, arkalarındaki altıgenleri gizler. Yalnızca 2 veya daha fazla Görüş Mesafesi ile fark yaratır.', }, revealPath: { label: 'Yol Boyunca Açığa Çıkar', @@ -9677,9 +9745,9 @@ const HexplorationMod = (() => { points: [ 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', - 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri açığa çıkarır. Görüş Hattı açıkken bir altıgen yalnızca arada örtülü bir altıgen yoksa açığa çıkar.', - 'Altıgen Açığa Çıkarma Mesafesi, altıgenler çizilirken onlara kaydedilir. Bu altıgenler, bir jeton ne kadar uzağı görürse görsün, yalnızca o kadar altıgen mesafeden açığa çıkar. Arkasındakini gizleyen dağlar veya ormanlar için kullanın.', - 'Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri en yakından başlayarak açığa çıkarır. Görüş Hattı açıkken, bir altıgen ile jeton arasında örtülü bir altıgen bulunduğu sürece o altıgen açığa çıkmaz. Yakın altıgenler genellikle önce açığa çıktığından, açık arazide Görüş Hattı hiçbir şeyi değiştirmez: yalnızca 2 veya daha fazla Görüş Mesafesi ve Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş arazi gibi örtülü kalan altıgenler olduğunda önem taşır.', + 'Altıgen Açığa Çıkarma Mesafesi, her altıgen doldurulurken ona kaydedilir, bu yüzden doldurmadan önce ayarlayın; sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için o kadar altıgen mesafede olmalıdır ve 0 ile yalnızca içlerine girilerek açığa çıkarlar. Bir sıradağ için: Altıgen Açığa Çıkarma Mesafesi ayarını 0 yapın, dağları doldurun, ayarı yeniden boşaltın, ardından ötedeki araziyi doldurun. Görüş Mesafesi 3 ve Görüş Hattı açıkken grup çevresindeki açık araziyi görür, ancak dağları ya da arkalarında olanları göremez. Her dağ altıgeni, bir jeton içine girdiğinde açığa çıkar.', + "Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır. Bakış durumundaki altıgenler Görüş Hattı'nı engellemez.", 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", ], @@ -9864,7 +9932,7 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Відстань розкриття шестикутників', - desc: 'Застосовується до гексів, коли вони намальовані: жетон має бути в межах такої кількості гексів, щоб відкрити їх, як би далеко він не бачив. Залиште порожнім, щоб не було обмежень.', + desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { label: 'Дальність огляду', @@ -9872,7 +9940,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Лінія видимості', - desc: 'Коли ввімкнено, гекс відкривається, лише якщо між ним і жетоном немає закритого гексу.', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', }, revealPath: { label: 'Розкривати вздовж шляху', @@ -10051,9 +10119,9 @@ const HexplorationMod = (() => { points: [ 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', - '«Дальність огляду» розкриває гекси навколо кожного з цих гексів. З увімкненою «Лінією видимості» гекс розкривається, лише якщо між ним і маркером немає закритого гекса.', - '«Відстань розкриття шестикутників» зберігається в гексах під час їх малювання. Такі гекси розкриваються лише з відстані, не більшої за цю кількість гексів, хоч би як далеко бачив маркер. Використовуйте її для гір або лісів, що приховують те, що за ними.', - 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', + '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', ], @@ -11889,6 +11957,35 @@ const HexplorationMod = (() => { return !!obj && PATH_TYPES.includes(obj.get('_type')); } + /** + * Returns a colour in a form the given path type accepts. + * + * @param {string} color Colour from the settings. + * @param {string} type Path type. + * @returns {string} Colour to write. + */ + function pathColor(color, type) { + return type === PATH_TYPE_V2 ? toPathV2Color(color) : color; + } + + /** + * Sets a path's colours, converting them for Jumpgate pathv2 objects. + * + * @param {object} obj Roll20 path or pathv2. + * @param {object} attrs Attributes to set; `fill` and `stroke` are converted. + * @returns {void} + */ + function setPathStyle(obj, attrs) { + const type = obj.get('_type'); + const converted = { ...attrs }; + for (const key of ['fill', 'stroke']) { + if (key in converted) { + converted[key] = pathColor(converted[key], type); + } + } + obj.set(converted); + } + /** * Copies the properties the polygon module needs from a path. * @@ -11990,8 +12087,8 @@ const HexplorationMod = (() => { const attrs = { ...geometry, _pageid: pageId, - fill: style.fill, - stroke: style.stroke, + fill: pathColor(style.fill, type), + stroke: pathColor(style.stroke, type), stroke_width: style.strokeWidth, controlledby: '', }; @@ -12201,7 +12298,7 @@ const HexplorationMod = (() => { maxDistance: hex.maxDistance ?? null, glimpsed: hex.glimpsed === true, }); - existingPath.set({ + setPathStyle(existingPath, { fill: style.fill, stroke: style.stroke, stroke_width: style.strokeWidth, @@ -12302,7 +12399,11 @@ const HexplorationMod = (() => { const hex = getHex(record.pageId, prev.key); const path = hex ? getPathObject(hex.id, hex.type) : null; if (path) { - path.set({ fill: prev.fill, stroke: prev.stroke, stroke_width: prev.strokeWidth }); + setPathStyle(path, { + fill: prev.fill, + stroke: prev.stroke, + stroke_width: prev.strokeWidth, + }); if (Number.isInteger(prev.maxDistance)) { hex.maxDistance = prev.maxDistance; } else { @@ -12847,17 +12948,26 @@ const HexplorationMod = (() => { */ function glimpseHex(ctx, key, distance) { const hex = getHex(ctx.pageId, key); - if (!hex || hex.glimpsed) { - return false; - } - if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + if (!hex) { return false; } const path = getPathObject(hex.id, hex.type); if (!path) { return false; } - path.set('fill', getConfig().glimpseColor); + const fill = pathColor(getConfig().glimpseColor, path.get('_type')); + if (hex.glimpsed) { + // Versions before this fix marked Jumpgate hexes as glimpsed without + // changing their colour; repaint them when they are seen again. + if (path.get('fill') !== fill) { + path.set('fill', fill); + } + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + path.set('fill', fill); hex.glimpsed = true; return true; } diff --git a/Hexploration/README.md b/Hexploration/README.md index 01c19bdc59..ed1a5fee1b 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -4,7 +4,7 @@ A Roll20 Mod that covers a hex map with opaque hexes and uncovers them as the pa Draw a shape over the area to hide, fill it with hexes, and every hex a player token moves through (and, if you like, the hexes around it) is revealed. Hidden locations can be tucked under hexes and are announced when they are found. -**Version 2.0.0 is a full rewrite that works in Jumpgate and Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder, and existing version 1 hex maps and commands keep working. +**Version 2 is a full rewrite that works in Jumpgate and Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder, and existing version 1 hex maps and commands keep working. ![Hexploration demo (version 1)](Hexploration.gif) @@ -152,7 +152,7 @@ The swatch next to each colour on the settings card shows the colour with its tr // Pass its previous position to reveal along the route as well. Hexploration.revealAround(token, { left: oldLeft, top: oldTop }); Hexploration.revealAround(tokenId); -Hexploration.version; // "2.0.0" +Hexploration.version; // "2.0.1" ``` ## Credits diff --git a/Hexploration/TESTING.md b/Hexploration/TESTING.md index 87c0828f47..9c740aa604 100644 --- a/Hexploration/TESTING.md +++ b/Hexploration/TESTING.md @@ -34,7 +34,7 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa ## Setup -- [ ] Install `Hexploration.js` and save. The API console shows `-=> Hexploration v2.0.0 … (Jumpgate) <=-` (or `(Legacy)`). +- [ ] Install `Hexploration.js` and save. The API console shows `-=> Hexploration v2.0.1 … (Jumpgate) <=-` (or `(Legacy)`). - [ ] The GM receives the "Hexploration is ready." whisper. - [ ] The Journal contains **Hexploration - Help** and **Hexploration - Command Deck**, neither visible to players. - [ ] Every button in the Command Deck works. @@ -98,7 +98,7 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa ## Upgrading from Version 1 (Legacy game) -- [ ] Replace v1.3 with v2.0.0. The startup whisper says the maps were upgraded. +- [ ] Replace v1.3 with v2.0.1. The startup whisper says the maps were upgraded. - [ ] Existing hexes reveal when tokens move; names and location tokens are announced. - [ ] Colours, border width and reveal distance match the v1 settings. - [ ] The `Hexploration_menu` macro opens the new menu; the v1 Fill buttons in old macros still work. diff --git a/Hexploration/package-lock.json b/Hexploration/package-lock.json index 8a0654e2f5..b31e4591e9 100644 --- a/Hexploration/package-lock.json +++ b/Hexploration/package-lock.json @@ -1,12 +1,12 @@ { "name": "hexploration-roll20", - "version": "2.0.0", + "version": "2.0.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "hexploration-roll20", - "version": "2.0.0", + "version": "2.0.1", "devDependencies": { "prettier": "^3.5.3", "rollup": "^4.34.8" diff --git a/Hexploration/package.json b/Hexploration/package.json index 27ab95a42c..c5c82fe7cb 100644 --- a/Hexploration/package.json +++ b/Hexploration/package.json @@ -1,6 +1,6 @@ { "name": "hexploration-roll20", - "version": "2.0.0", + "version": "2.0.1", "description": "Roll20 API Mod that covers hex maps with hexes that are revealed as tokens explore.", "private": true, "type": "module", diff --git a/Hexploration/script.json b/Hexploration/script.json index 9efd9c3ea7..a78722d4e8 100644 --- a/Hexploration/script.json +++ b/Hexploration/script.json @@ -1,12 +1,13 @@ { "name": "Hexploration", "script": "Hexploration.js", - "version": "2.0.0", + "version": "2.0.1", "previousversions": [ "1.0", "1.1", "1.2", - "1.3" + "1.3", + "2.0.0" ], "description": "# Hexploration\n\nCover a hex map with opaque hexes that are revealed as the party explores. Draw a polygon over the area to hide, fill it with hexes, and every hex a player token moves through (and, optionally, the hexes around it) is uncovered. Hidden locations are announced in chat when they are discovered.\n\n**Version 2.0.0 is a full rewrite that works in Jumpgate and in Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. Existing v1 hex maps and the v1 `!hexploration_*` commands keep working.\n\n## Getting started\n\n1. Use a page with a **Hex (V)** or **Hex (H)** grid.\n2. Draw one or more polygons over the area to hide and select them.\n3. Type `!hexploration fill`, or open the **Hexploration - Command Deck** handout and click **Fill**.\n4. Move a player token and watch the map open up.\n\nType `!hexploration` for the menu, or `!hexploration help` for every command. The **Hexploration - Help** handout is created in the Journal on startup.\n\n## Features\n\n* Works with Jumpgate (`pathv2`) and Legacy paths, on both hex grid orientations and any cell size.\n* Hexes are drawn on the foreground layer when the game has one, otherwise on the token layer.\n* Reveals along the whole path a token travels, covers every hex a large token occupies, and respects line of sight.\n* Optional glimpse mode: nearby hexes turn see-through and clear when a token enters them.\n* Named locations and hidden location tokens, announced (and optionally pinged) when discovered.\n* Reveal or re-cover selected hexes, reveal or clear a page, undo the last fill, and per-page settings.\n* Rescan rebuilds the hex list after a page is duplicated or a Legacy game is copied to Jumpgate.\n* Grid calibration for maps whose hexes do not line up.\n* Translated into 24 languages.\n\nOriginal mod by Ada Lindberg. Version 2 is maintained by MidNiteShadow7.", "authors": "Ada Lindberg, MidNiteShadow7", From 2ababf39e331f753757ad478503a0fcba5f43016 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 17:33:10 +0000 Subject: [PATCH 18/24] fix(Hexploration): Track locations.js and state.js in lower case Version 1 had src/Locations.js and src/State.js. The rewrite replaced them on a case-insensitive file system, so git kept the capitals while every import names ./locations.js and ./state.js. A clone on a case-sensitive file system could not build the script. Rename the tracked files to match the imports, as was done for chat.js. Signed-off-by: Steve Roberts --- Hexploration/src/{Locations.js => locations.js} | 0 Hexploration/src/{State.js => state.js} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename Hexploration/src/{Locations.js => locations.js} (100%) rename Hexploration/src/{State.js => state.js} (100%) diff --git a/Hexploration/src/Locations.js b/Hexploration/src/locations.js similarity index 100% rename from Hexploration/src/Locations.js rename to Hexploration/src/locations.js diff --git a/Hexploration/src/State.js b/Hexploration/src/state.js similarity index 100% rename from Hexploration/src/State.js rename to Hexploration/src/state.js From 9b8383d2f4830443ab892b204ab49de918a61976 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:12:41 +0000 Subject: [PATCH 19/24] fix(Hexploration): Give hex name labels a font Jumpgate can draw Naming a hex in Jumpgate made Roll20 show "Something Went Wrong" and stop drawing the tabletop, and it happened again every time the page was opened. A text created through the API without a font gets the font "unset", and Jumpgate cannot render it. Name labels are now created in Arial. Labels made by 2.0.0 and 2.0.1 are given the font when the sandbox starts, and when Rescan re-links them, so pages that already crash are mended without renaming every hex. The test stub now gives a text the "unset" font, as Roll20 does, so the tests would catch a label made without one. Signed-off-by: Steve Roberts --- Hexploration/src/constants.js | 4 ++ Hexploration/src/hexes.js | 2 + Hexploration/src/index.js | 6 ++- Hexploration/src/locations.js | 48 +++++++++++++++++++++++- Hexploration/tests/hexploration.test.mjs | 16 ++++++++ Hexploration/tests/roll20-stub.mjs | 3 +- 6 files changed, 76 insertions(+), 3 deletions(-) diff --git a/Hexploration/src/constants.js b/Hexploration/src/constants.js index 6467d0b63e..3630258918 100644 --- a/Hexploration/src/constants.js +++ b/Hexploration/src/constants.js @@ -52,6 +52,10 @@ export const PATH_TYPE_LEGACY = 'path'; export const PATH_TYPE_V2 = 'pathv2'; export const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; +// Font for hex name labels. Jumpgate cannot draw a text without a font. +export const LABEL_FONT_FAMILY = 'Arial'; +export const LABEL_FONT_SIZE = 16; + // Status marker v1 used to flag location tokens. Still honoured as a fallback. export const LOCATION_MARKER = 'white-tower'; diff --git a/Hexploration/src/hexes.js b/Hexploration/src/hexes.js index 4156210999..d35b3b270d 100644 --- a/Hexploration/src/hexes.js +++ b/Hexploration/src/hexes.js @@ -26,6 +26,7 @@ import { findLocationTokens, getHexIcon, removeLabel, + repairLabelFont, } from './locations.js'; import { createHexPath, @@ -459,6 +460,7 @@ export function rescanPage(ctx) { const [cx, cy] = hexToPixel(ctx.grid, row, col); const hex = getHex(ctx.pageId, hexKey(row, col)); if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + repairLabelFont(text); hex.nameId = text.get('_id'); hex.name = String(text.get('text') || '').trim() || hex.name; counts.labels++; diff --git a/Hexploration/src/index.js b/Hexploration/src/index.js index 214e741e9c..98506ce9db 100644 --- a/Hexploration/src/index.js +++ b/Hexploration/src/index.js @@ -11,7 +11,7 @@ import { refreshPage, refreshToken } from './cover.js'; import { pruneMissingHexes } from './hexes.js'; import { t } from './i18n.js'; import { installHandouts } from './journals.js'; -import { removeLabel } from './locations.js'; +import { removeLabel, repairLabelFonts } from './locations.js'; import { revealAroundToken, handleTokenChange } from './reveal.js'; import { applyGlobalConfig, @@ -143,6 +143,10 @@ function checkInstall() { const migratedFrom = initialiseState(); applyGlobalConfig(); const pruned = pruneMissingHexes(); + const repairedLabels = repairLabelFonts(getPageIds()); + if (repairedLabels > 0) { + log(`${SCRIPT_NAME}: gave ${repairedLabels} hex name label(s) a font Jumpgate can draw.`); + } for (const pageId of new Set([ ...getPageIds(), ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), diff --git a/Hexploration/src/locations.js b/Hexploration/src/locations.js index 53ea86051c..0275489e14 100644 --- a/Hexploration/src/locations.js +++ b/Hexploration/src/locations.js @@ -4,7 +4,14 @@ // icon (a token hidden on the GM layer). Both are announced when the hex is // revealed, and the icon is moved back to the token layer. -import { LAYER_GM, LAYER_TOKEN, LOCATION_MARKER, MAX_NAME_LENGTH } from './constants.js'; +import { + LABEL_FONT_FAMILY, + LABEL_FONT_SIZE, + LAYER_GM, + LAYER_TOKEN, + LOCATION_MARKER, + MAX_NAME_LENGTH, +} from './constants.js'; import { hexKey, hexToPixel, pixelToHex } from './grid.js'; import { getConfig, @@ -50,6 +57,43 @@ export function removeLabel(hex) { } } +/** + * Gives a name label a font Jumpgate can draw. A text created through the API + * without one gets the font "unset", and Jumpgate stops drawing the whole + * tabletop ("Something Went Wrong") when it meets it. Labels made by 2.0.0 and + * 2.0.1 have that font. + * + * @param {object} text Roll20 text object. + * @returns {boolean} Whether the font was changed. + */ +export function repairLabelFont(text) { + const font = toText(text.get('font_family')); + if (font && font !== 'unset') { + return false; + } + text.set('font_family', LABEL_FONT_FAMILY); + return true; +} + +/** + * Repairs the font of every name label Hexploration knows about. + * + * @param {string[]} pageIds Pages with hexes. + * @returns {number} Number of labels repaired. + */ +export function repairLabelFonts(pageIds) { + let count = 0; + for (const pageId of pageIds) { + for (const hex of getPageHexes(pageId)) { + const text = hex.nameId ? getObj('text', hex.nameId) : null; + if (text && repairLabelFont(text)) { + count++; + } + } + } + return count; +} + /** * Sets or clears a hex's name and redraws its GM-layer label. * @@ -74,6 +118,8 @@ export function setHexName(ctx, hex, name) { top: y, text: clean, color: getConfig().labelColor, + font_family: LABEL_FONT_FAMILY, + font_size: LABEL_FONT_SIZE, }); if (label) { hex.nameId = label.get('_id'); diff --git a/Hexploration/tests/hexploration.test.mjs b/Hexploration/tests/hexploration.test.mjs index bc6a18805a..675eded343 100644 --- a/Hexploration/tests/hexploration.test.mjs +++ b/Hexploration/tests/hexploration.test.mjs @@ -411,6 +411,8 @@ describe('locations', () => { game.command('!hexploration name Cave', [hex]); const label = game.ofType('text')[0]; assert.equal(label.attrs.layer, 'gmlayer'); + // Jumpgate stops drawing the tabletop when a text has no font + assert.equal(label.attrs.font_family, 'Arial'); const hero = addToken(game, JG_V, 2, 1); game.move(hero, ...hexToPixel(JG_V, 2, 3)); const announcement = game.chat.find((c) => /Location Discovered/.test(c.text)); @@ -432,6 +434,20 @@ describe('locations', () => { }); describe('maintenance', () => { + it('gives name labels from earlier versions a font on startup', () => { + const first = readyGame(); + first.command('!hexploration fill', [drawRect(first, 0, 0, 700, 500)]); + const hex = first.objects.get(first.hexState().pages.page1.hexes['2,3'].id); + first.command('!hexploration name Cave', [hex]); + const label = first.ofType('text')[0]; + // As 2.0.0 and 2.0.1 made it + label.attrs.font_family = 'unset'; + // Restart the sandbox with the same objects and state + first.ready(); + assert.equal(label.attrs.font_family, 'Arial'); + assert.ok(first.logs.some((line) => /gave 1 hex name label/.test(line))); + }); + it('forgets hexes deleted by hand', () => { const game = readyGame(); game.command('!hexploration fill', [drawRect(game, 0, 0, 400, 400)]); diff --git a/Hexploration/tests/roll20-stub.mjs b/Hexploration/tests/roll20-stub.mjs index 973cf08fe9..4a2fe1aa95 100644 --- a/Hexploration/tests/roll20-stub.mjs +++ b/Hexploration/tests/roll20-stub.mjs @@ -118,7 +118,8 @@ export function createSandbox({ if (type === 'pathv2' && !jumpgate) { return undefined; } - const obj = new Obj(type, attrs); + // Roll20 gives a text made without a font the font "unset", which Jumpgate cannot draw. + const obj = new Obj(type, type === 'text' ? { font_family: 'unset', ...attrs } : attrs); if (attrs.layer === 'foreground' && !foreground) { obj.attrs.layer = 'objects'; } From 7b21f2c218f79272e73fdb4f041a17fc4e616863 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:12:42 +0000 Subject: [PATCH 20/24] fix(Hexploration): Keep marked locations when a fill is undone A fill that covers a token marked with Mark Location hides it and uses up the mark. Undo Fill put the token back on the token layer but did not restore the mark, so the next fill covered it as an ordinary token: it stayed visible under the hexes to the GM only and was never announced when the party found it. The fill now records which hidden tokens were marked, and undo marks them again, so filling after an undo hides them as before. Signed-off-by: Steve Roberts --- Hexploration/src/hexes.js | 11 +++++++++-- Hexploration/tests/hexploration.test.mjs | 11 +++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/Hexploration/src/hexes.js b/Hexploration/src/hexes.js index d35b3b270d..380d4195a2 100644 --- a/Hexploration/src/hexes.js +++ b/Hexploration/src/hexes.js @@ -236,7 +236,10 @@ export function fillCells(ctx, cells, { sources = [], kind, onDone }) { const token = locations.get(key); if (token && !hex.iconId) { - record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + // Remember a Mark Location token so undo can mark it again + const id = token.get('_id'); + const pending = getPendingLocations(ctx.pageId).includes(id); + record.icons.push({ id, layer: token.get('layer'), pending }); attachIcon(hex, token); summary.icons++; } @@ -320,7 +323,7 @@ export function undoLastFill() { } } - for (const { id, layer } of record.icons || []) { + for (const { id, layer, pending } of record.icons || []) { const token = getObj('graphic', id); if (token) { for (const hex of getPageHexes(record.pageId)) { @@ -329,6 +332,10 @@ export function undoLastFill() { } } token.set('layer', layer || LAYER_TOKEN); + // Hiding it used up its Mark Location; mark it again so the next fill hides it + if (pending) { + setPendingLocation(id, record.pageId); + } } } diff --git a/Hexploration/tests/hexploration.test.mjs b/Hexploration/tests/hexploration.test.mjs index 675eded343..cbfef50d1f 100644 --- a/Hexploration/tests/hexploration.test.mjs +++ b/Hexploration/tests/hexploration.test.mjs @@ -391,6 +391,17 @@ describe('locations', () => { ); }); + it('keeps a marked location after undoing the fill that hid it', () => { + const game = readyGame(); + const tower = addToken(game, JG_V, 3, 3, { name: 'Old Tower', controlledby: '' }); + game.command('!hexploration mark', [tower]); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + game.command('!hexploration undo'); + assert.equal(tower.attrs.layer, 'objects'); + game.command('!hexploration fill', [drawRect(game, 0, 0, 700, 500)]); + assert.equal(tower.attrs.layer, 'gmlayer', 'hidden again by the next fill'); + }); + it('honours the v1 white-tower marker', () => { const game = readyGame(); const tower = addToken(game, JG_V, 2, 2, { From c4793391d6d1acf6065451195950a34c6387caf9 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:13:22 +0000 Subject: [PATCH 21/24] docs(Hexploration): Explain where name labels show in Jumpgate Name labels sit on the GM layer, which Jumpgate draws below the foreground layer, even while the GM layer is selected. With hexes on the foreground layer, the default, a label is hidden under its own hex, and the help still said the GM would see it. The help handout, in all 24 languages, and the README now say that in Jumpgate the labels only show over covered hexes when Hex Layer is set to the token layer, and that each name is still announced when its hex is revealed. The translations use each language's own names for the setting and the layers. Signed-off-by: Steve Roberts --- Hexploration/README.md | 3 ++- Hexploration/src/locales/locale/af.js | 2 +- Hexploration/src/locales/locale/ca.js | 2 +- Hexploration/src/locales/locale/cs.js | 2 +- Hexploration/src/locales/locale/da.js | 2 +- Hexploration/src/locales/locale/de.js | 2 +- Hexploration/src/locales/locale/el.js | 2 +- Hexploration/src/locales/locale/en-US.js | 2 +- Hexploration/src/locales/locale/es.js | 2 +- Hexploration/src/locales/locale/fi.js | 2 +- Hexploration/src/locales/locale/fr.js | 2 +- Hexploration/src/locales/locale/he.js | 2 +- Hexploration/src/locales/locale/hu.js | 2 +- Hexploration/src/locales/locale/it.js | 2 +- Hexploration/src/locales/locale/ja.js | 2 +- Hexploration/src/locales/locale/ko.js | 2 +- Hexploration/src/locales/locale/nl.js | 2 +- Hexploration/src/locales/locale/pl.js | 2 +- Hexploration/src/locales/locale/pt-BR.js | 2 +- Hexploration/src/locales/locale/pt-PT.js | 2 +- Hexploration/src/locales/locale/ru.js | 2 +- Hexploration/src/locales/locale/sv.js | 2 +- Hexploration/src/locales/locale/tr.js | 2 +- Hexploration/src/locales/locale/uk.js | 2 +- Hexploration/src/locales/locale/zh-TW.js | 2 +- 25 files changed, 26 insertions(+), 25 deletions(-) diff --git a/Hexploration/README.md b/Hexploration/README.md index ed1a5fee1b..062b86ebe6 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -100,7 +100,7 @@ Glimpsed hexes do not block Line of Sight. | `hexLayer` | Hex Layer | `auto` | | `auto`, `foreground` or `objects`. Auto tries the foreground layer first. | | `fillColor` | Fill Colour | `#222222` | | Colour of new hexes. A colour with transparency makes see-through hexes. | | `strokeColor` | Border Colour | `#444444` | | Outline colour of new hexes. | -| `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. | +| `labelColor` | Label Colour | `#FFFFFF` | | Colour of GM-only name labels. In Jumpgate they only show over covered hexes when Hex Layer is `objects`. | | `glimpseColor` | Glimpse Colour | `rgba(34,34,34,0.5)` | | Colour of glimpsed hexes. Use a colour with transparency. | | `strokeWidth` | Border Width | `1` | | Outline width in pixels (0–20). | | `maxDistance` | Hex Reveal Distance | none | | Stored on hexes as they are filled; they reveal only from within this many hexes. Set it before filling. See [Terrain That Blocks Sight](#terrain-that-blocks-sight). | @@ -143,6 +143,7 @@ The swatch next to each colour on the settings card shows the colour with its tr - Hexploration detects the engine and draws `pathv2` shapes in Jumpgate and `path` shapes in Legacy games. Shapes drawn in either editor can be filled. - With **Hex Layer** on `auto`, hexes go on the foreground layer, above tokens. If the game rejects that layer, the token layer is used instead and the GM is told. - Jumpgate draws regular hexes, which differ slightly from Legacy's. If hexes do not line up with a page's grid, snap a token to a hex centre, select it and run `!hexploration calibrate`. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size as well. +- Name Hex labels sit on the GM layer, which Jumpgate draws below the foreground layer. With hexes on the foreground layer, the labels are hidden under them; set Hex Layer to `objects` to see them. Each name is still announced when its hex is revealed. - Copying a page or game gives its hexes new IDs. Run `!hexploration rescan` on the page to pick them up again, together with their name labels and location tokens. ## API for Other Mods diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index b256c2f1f6..13ed4c21dc 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -312,7 +312,7 @@ const TRANSLATION = { "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', - "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index 72056ed65d..a7e5fab8f8 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -315,7 +315,7 @@ const TRANSLATION = { "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", - "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], }, diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index 9a80ed92d4..d953b365db 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -310,7 +310,7 @@ const TRANSLATION = { 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index 40ebc097dc..3ce729ed25 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -308,7 +308,7 @@ const TRANSLATION = { 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', - 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], }, diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index 3889c53586..e693fa309e 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -320,7 +320,7 @@ const TRANSLATION = { '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', - '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird. Jumpgate zeichnet die GM-Ebene unterhalb der Vordergrundebene, daher sind die Beschriftungen in Jumpgate nur sichtbar, wenn „Hexfeld-Ebene“ auf die Token-Ebene gesetzt ist.', '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', ], }, diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index 7f9d602181..127354dbbb 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -313,7 +313,7 @@ const TRANSLATION = { 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', - 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], }, diff --git a/Hexploration/src/locales/locale/en-US.js b/Hexploration/src/locales/locale/en-US.js index 1b88070fa6..a29a27c633 100644 --- a/Hexploration/src/locales/locale/en-US.js +++ b/Hexploration/src/locales/locale/en-US.js @@ -306,7 +306,7 @@ export default { 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', - 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed. Jumpgate draws the GM layer below the foreground layer, so in Jumpgate the labels only show when Hex Layer is set to the token layer.', 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', ], }, diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index 51d0770fcc..1808289dd7 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -315,7 +315,7 @@ const TRANSLATION = { 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', - 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], }, diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index 046e8d7613..09b4f033a7 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -312,7 +312,7 @@ const TRANSLATION = { 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', - 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], }, diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index 259e7801b9..0ea43abbc0 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -316,7 +316,7 @@ const TRANSLATION = { "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", - "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], }, diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index 13cebb41c0..d7d5eee2cd 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -304,7 +304,7 @@ const TRANSLATION = { 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', - 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], }, diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index 94d9b53303..c033514743 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -313,7 +313,7 @@ const TRANSLATION = { 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', - 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index 40a9cb7c40..90b582e9e3 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -313,7 +313,7 @@ const TRANSLATION = { 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', - "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], }, diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index d0034084d9..878f3b33f1 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -309,7 +309,7 @@ const TRANSLATION = { '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', - '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], }, diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index 0ce59a5446..0bd4a1eb1e 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -307,7 +307,7 @@ const TRANSLATION = { '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', - '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다. Jumpgate는 GM 레이어를 전경 레이어 아래에 그리므로, Jumpgate에서는 헥스 레이어 설정이 토큰 레이어로 되어 있을 때만 라벨이 표시됩니다.', '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', ], }, diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index d50d1020ab..c4bb042a89 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -313,7 +313,7 @@ const TRANSLATION = { 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', - 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], }, diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index fa9e2f569b..2ab6f3846f 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -312,7 +312,7 @@ const TRANSLATION = { 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index ec7e23f7f7..64a46854af 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -313,7 +313,7 @@ const TRANSLATION = { 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', - 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], }, diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index 1e70f34808..686aeeedd6 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -312,7 +312,7 @@ const TRANSLATION = { 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', - 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], }, diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index e24d5a1155..5e2c28031c 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -311,7 +311,7 @@ const TRANSLATION = { '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index 480c859b76..78aa958960 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -307,7 +307,7 @@ const TRANSLATION = { 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', - 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], }, diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index 02c37a0d62..eb2e00efa8 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -310,7 +310,7 @@ const TRANSLATION = { 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', - "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], }, diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index a6f7d39e57..a993e6c28b 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -311,7 +311,7 @@ const TRANSLATION = { '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index 49e228d3a0..2f4b68f034 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -296,7 +296,7 @@ const TRANSLATION = { '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', - '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', ], }, From 85f768bd164e88d1e284c843c804af8441e7ee73 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:13:26 +0000 Subject: [PATCH 22/24] chore(Hexploration): Release 2.0.2 Bumps the version to 2.0.2 for the name label and Undo Fill fixes and the note on where labels show in Jumpgate. Like 2.0.1, it goes into the same pull request as 2.0.0, so 2.0.1 joins the previous versions and its snapshot folder is left as it was. The rebuilt script is copied to the new 2.0.2 folder, and the changelog, testing checklist, developer notes and README API example carry the new version. The testing checklist gains checks for the label crash, the repair of older labels and Undo Fill keeping marked locations. Signed-off-by: Steve Roberts --- Hexploration/2.0.2/Hexploration.js | 14361 +++++++++++++++++++++++++++ Hexploration/CHANGELOG.md | 11 + Hexploration/DEVELOPERS.md | 2 +- Hexploration/Hexploration.js | 115 +- Hexploration/README.md | 2 +- Hexploration/TESTING.md | 7 +- Hexploration/package-lock.json | 4 +- Hexploration/package.json | 2 +- Hexploration/script.json | 6 +- 9 files changed, 14470 insertions(+), 40 deletions(-) create mode 100644 Hexploration/2.0.2/Hexploration.js diff --git a/Hexploration/2.0.2/Hexploration.js b/Hexploration/2.0.2/Hexploration.js new file mode 100644 index 0000000000..c305cb694d --- /dev/null +++ b/Hexploration/2.0.2/Hexploration.js @@ -0,0 +1,14361 @@ +/** + * NOTE: GENERATED FILE - DO NOT EDIT DIRECTLY. + * NOTE: Source files live under src/ and are bundled with `npm run build`. + * ------------------------------------------------ + * Name: Hexploration + * Script: Hexploration.js + * Version: 2.0.2 + * Built: 2026-10-30T22:13:47.401Z + */ +const HexplorationMod = (() => { + 'use strict'; + + // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. + const SCRIPT_NAME = 'Hexploration'; + const SCRIPT_VERSION = '2.0.2'; + const SCRIPT_LAST_UPDATED = '2026-10-30T22:13:47.401Z'; + + const DEFAULT_LOCALE$1 = 'en-US'; + + const STATE_KEY = 'Hexploration'; + const SCHEMA_VERSION = 2; + const COMMAND = '!hexploration'; + + // v1 commands, kept so existing macros and the Hexploration_menu macro still work. + const LEGACY_COMMANDS = { + '!hexploration_fillPoly': 'fill', + '!hexploration_fillInversePoly': 'fillInverse', + '!hexploration_showMenuMain': 'menu', + '!hexploration_configModifyProperty': 'legacyConfig', + '!hexploration_hexModifyProperty': 'legacyHex', + }; + + // Separator v1 used between the arguments of its config and hex commands. + const LEGACY_ARG_SEPARATOR = '&&'; + + const HANDOUT_HELP_NAME = 'Hexploration - Help'; + // The deck's name is not translated, so it always matches the handout's name. + const DECK_TITLE = 'Command Deck'; + const HANDOUT_DECK_NAME = `Hexploration - ${DECK_TITLE}`; + + const AUTHOR_LINKS = { + original: { + name: 'Ada Lindberg', + profile: 'https://app.roll20.net/users/46544/ada-l', + marketplace: 'https://marketplace.roll20.net/browse/publisher/165/ada-lindberg', + }, + maintainer: { + name: 'MidNiteShadow7', + profile: 'https://app.roll20.net/users/16506286/midniteshadow7', + github: 'https://github.com/steverobertsuk', + }, + }; + + const DEMO_GIF_URL = + 'https://raw.githubusercontent.com/Roll20/roll20-api-scripts/master/Hexploration/Hexploration.gif'; + + // Roll20 layer identifiers. + const LAYER_TOKEN = 'objects'; + const LAYER_GM = 'gmlayer'; + const LAYER_FOREGROUND = 'foreground'; + + // Roll20 object types for drawn shapes. Jumpgate draws pathv2; Legacy draws path. + const PATH_TYPE_LEGACY = 'path'; + const PATH_TYPE_V2 = 'pathv2'; + const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + + // Font for hex name labels. Jumpgate cannot draw a text without a font. + const LABEL_FONT_FAMILY = 'Arial'; + const LABEL_FONT_SIZE = 16; + + // Status marker v1 used to flag location tokens. Still honoured as a fallback. + const LOCATION_MARKER = 'white-tower'; + + // Option lists for settings. + const HEX_LAYER_OPTIONS = ['auto', 'foreground', 'objects']; + const REVEAL_BY_OPTIONS = ['players', 'characters', 'all']; + const REVEAL_MODE_OPTIONS = ['clear', 'glimpse']; + const ANNOUNCE_OPTIONS = ['all', 'gm', 'off']; + + // Default configuration for new installs. Migrated v1 games keep their own values. + const DEFAULT_CONFIG = { + language: DEFAULT_LOCALE$1, + hexLayer: 'auto', + fillColor: '#222222', + strokeColor: '#444444', + labelColor: '#FFFFFF', + glimpseColor: 'rgba(34,34,34,0.5)', + strokeWidth: 1, + revealDistance: 1, + maxDistance: null, + lineOfSight: true, + revealPath: true, + revealBy: 'players', + revealMode: 'clear', + announce: 'all', + pingDiscoveries: false, + hideCoveredTokens: true, + }; + + // Player-visible token properties switched off while a token is under a + // covered hex, because Roll20 draws nameplates, bars and auras above the + // foreground layer. Saved values are restored when the token is uncovered. + const COVERED_TOKEN_PROPS = [ + 'showplayers_name', + 'showplayers_bar1', + 'showplayers_bar2', + 'showplayers_bar3', + 'showplayers_aura1', + 'showplayers_aura2', + ]; + + // Settings that can be overridden for a single page. + const PAGE_SETTING_KEYS = [ + 'revealDistance', + 'lineOfSight', + 'revealPath', + 'revealBy', + 'revealMode', + 'announce', + 'pingDiscoveries', + ]; + + // Limits that keep a single command from creating an unreasonable number of objects. + const MAX_REVEAL_DISTANCE = 20; + const MAX_STROKE_WIDTH = 20; + const MAX_FILL_HEXES = 20000; + const MAX_NAME_LENGTH = 100; + + // Hexes are created and removed in batches so large fills do not trip the + // API's long-running script watchdog. + const BATCH_SIZE = 100; + + // How close (as a fraction of the column step) a path's centre must be to a + // hex centre for Rescan to adopt it as a hex. + const RESCAN_CENTRE_TOLERANCE = 0.2; + + // How close (in pixels) a text label must be to a hex centre to be adopted as its name. + const RESCAN_LABEL_TOLERANCE = 6; + + // Colour palette for chat cards and handouts. + const COLOR_HEADER_BG = '#1b2a1f'; + const COLOR_HEADER_TEXT = '#e8dcb5'; + const COLOR_CARD_BG_TOP = '#22352a'; + const COLOR_CARD_BG_BOTTOM = '#14211a'; + const COLOR_BORDER = '#3c5a45'; + const COLOR_TEXT = '#e4e0d0'; + const COLOR_MUTED = '#9aa89c'; + const COLOR_ACCENT = '#d9a441'; + const COLOR_BUTTON_BG = '#b5832a'; + const COLOR_BUTTON_TEXT = '#ffffff'; + const COLOR_WARNING_BG = '#fef3c7'; + const COLOR_WARNING_BORDER = '#92400e'; + const COLOR_WARNING_TEXT = '#92400e'; + const COLOR_ERROR_BG = '#fee2e2'; + const COLOR_ERROR_BORDER = '#991b1b'; + const COLOR_ERROR_TEXT = '#991b1b'; + + /** + * Returns true when a value is a plain non-null, non-array object. + * + * @param {*} value Value to test. + * @returns {boolean} True when the value is a record. + */ + function isRecord(value) { + return value !== null && typeof value === 'object' && !Array.isArray(value); + } + + /** + * Converts a value to trimmed text, treating null and undefined as empty. + * + * @param {*} value Value to convert. + * @returns {string} Trimmed string. + */ + function toText(value) { + return value === null || value === undefined ? '' : String(value).trim(); + } + + /** + * Escapes HTML special characters. + * + * @param {*} text Text to escape. + * @returns {string} Escaped text. + */ + function escapeHtml(text) { + return String(text) + .replaceAll('&', '&') + .replaceAll('<', '<') + .replaceAll('>', '>') + .replaceAll('"', '"') + .replaceAll("'", '''); + } + + /** + * Parses a whole number, rejecting anything that is not entirely digits + * (with an optional leading minus sign). + * + * @param {*} raw Raw input. + * @returns {number|null} Parsed integer, or null when invalid. + */ + function parseStrictInt(raw) { + const text = toText(raw); + return /^-?\d+$/.test(text) ? Number(text) : null; + } + + /** + * Parses a yes/no style value. + * + * @param {*} raw Raw input. + * @returns {boolean|null} Parsed boolean, or null when not recognised. + */ + function parseBoolean(raw) { + if (typeof raw === 'boolean') { + return raw; + } + const text = toText(raw).toLowerCase(); + if (['on', 'true', 'yes', '1'].includes(text)) { + return true; + } + if (['off', 'false', 'no', '0'].includes(text)) { + return false; + } + return null; + } + + /** + * Returns true when a value is a colour Roll20 accepts for path fill and stroke: + * #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(), rgba(), transparent, or a CSS colour name. + * + * @param {*} raw Colour text. + * @returns {boolean} True when valid. + */ + function isValidColor(raw) { + const text = toText(raw); + return ( + /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text) || + /^rgba?\(\s*[\d.]+%?\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(?:,\s*[\d.]+%?\s*)?\)$/i.test(text) || + /^[a-z]{3,20}$/i.test(text) + ); + } + + /** + * Parses a hex, rgb() or rgba() colour into its channels. + * + * @param {*} raw Colour text. + * @returns {{r: number, g: number, b: number, a: number}|null} Channels 0–255 and alpha 0–1, or null for other colours such as names. + */ + function parseColor(raw) { + const text = toText(raw); + + const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(text); + if (hex) { + const digits = hex[1].length <= 4 ? [...hex[1]].map((c) => c + c).join('') : hex[1]; + const [r, g, b, a = 255] = digits.match(/../g).map((pair) => parseInt(pair, 16)); + return { r, g, b, a: a / 255 }; + } + + const fn = + /^rgba?\(\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i.exec( + text + ); + if (!fn) { + return null; + } + const channel = (v) => + clamp(v.endsWith('%') ? (parseFloat(v) * 255) / 100 : parseFloat(v), 0, 255); + const alpha = + fn[4] === undefined ? 1 : fn[4].endsWith('%') ? parseFloat(fn[4]) / 100 : parseFloat(fn[4]); + return { r: channel(fn[1]), g: channel(fn[2]), b: channel(fn[3]), a: clamp(alpha, 0, 1) }; + } + + /** + * Converts a colour to the #rrggbb or #rrggbbaa form Jumpgate's pathv2 objects + * accept. Jumpgate silently ignores rgb(), rgba() and short hex colours, so a + * hex keeps its old colour. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for a pathv2 fill or stroke. + */ + function toPathV2Color(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + const hex = (n) => Math.round(n).toString(16).padStart(2, '0'); + const rgb = `#${hex(color.r)}${hex(color.g)}${hex(color.b)}`; + return color.a >= 1 ? rgb : `${rgb}${hex(color.a * 255)}`; + } + + /** + * Converts a colour to a form Roll20 chat keeps in inline styles. Chat drops + * #rrggbbaa colours and rgb() with an alpha value, leaving the style empty; + * #rrggbb and rgba() survive. Colour names are returned unchanged. + * + * @param {*} raw Colour text. + * @returns {string} Colour for chat HTML. + */ + function toChatColor(raw) { + const color = parseColor(raw); + if (!color) { + return toText(raw); + } + if (color.a >= 1) { + return toPathV2Color(raw); + } + const [r, g, b] = [color.r, color.g, color.b].map(Math.round); + return `rgba(${r},${g},${b},${Math.round(color.a * 100) / 100})`; + } + + /** + * Clamps a number into a range. + * + * @param {number} value Value. + * @param {number} min Minimum. + * @param {number} max Maximum. + * @returns {number} Clamped value. + */ + function clamp(value, min, max) { + return Math.min(max, Math.max(min, value)); + } + + let jumpgateCache = null; + + /** + * Returns true when the game runs on Jumpgate. Roll20 has exposed this as + * both `_release` and `release`, so both are checked. + * + * @returns {boolean} True for Jumpgate games. + */ + function isJumpgate() { + if (jumpgateCache === null) { + const campaign = Campaign(); + const release = toText(campaign.get('_release') || campaign.get('release')).toLowerCase(); + jumpgateCache = release === 'jumpgate'; + } + return jumpgateCache; + } + + /** + * Returns the page a player is viewing: their own page when split from the + * party, otherwise the player ribbon page. + * + * @param {string} playerId Roll20 player ID. + * @returns {string} Page ID. + */ + function getPlayerPageId(playerId) { + const campaign = Campaign(); + if (playerIsGM(playerId)) { + const player = getObj('player', playerId); + const lastPage = player?.get('_lastpage'); + if (lastPage) { + return lastPage; + } + } + const specific = campaign.get('playerspecificpages'); + if (isRecord(specific) && specific[playerId]) { + return specific[playerId]; + } + return campaign.get('playerpageid'); + } + + /** + * Returns the player IDs who control a token, directly or through the + * character it represents. + * + * @param {Graphic} token Roll20 token. + * @returns {string[]} Controller IDs (may include 'all'). + */ + function getTokenControllers(token) { + const ids = new Set(); + const add = (list) => { + for (const id of toText(list).split(',')) { + if (id.trim()) { + ids.add(id.trim()); + } + } + }; + add(token.get('controlledby')); + const characterId = token.get('represents'); + if (characterId) { + add(getObj('character', characterId)?.get('controlledby')); + } + return [...ids]; + } + + /** + * Returns true when a token carries a status marker, matching both plain + * markers ("white-tower") and numbered ones ("white-tower@2"). + * + * @param {Graphic} token Roll20 token. + * @param {string} marker Marker tag. + * @returns {boolean} True when the marker is present. + */ + function tokenHasMarker(token, marker) { + return toText(token.get('statusmarkers')) + .split(',') + .some((tag) => tag.split('@')[0] === marker); + } + + /** + * Splits work into batches run on successive event-loop turns, so large jobs + * do not trip the API sandbox's long-running script watchdog. + * + * @param {Array} items Items to process. + * @param {number} size Batch size. + * @param {(item: *, index: number) => void} work Called for each item. + * @param {(errors: number) => void} [done] Called once every item has been + * processed, with the number of items whose work threw. + * @returns {void} + */ + function runInBatches(items, size, work, done) { + let index = 0; + let errors = 0; + // Errors are caught per item: an exception thrown from a timer callback + // would otherwise stop the whole API sandbox. + const step = () => { + const end = Math.min(items.length, index + size); + for (; index < end; index++) { + try { + work(items[index], index); + } catch (err) { + errors++; + log(`Hexploration: batch item failed: ${err?.message || err}`); + } + } + if (index < items.length) { + setTimeout(step, 0); + } else if (done) { + try { + done(errors); + } catch (err) { + log(`Hexploration: batch completion failed: ${err?.message || err}`); + } + } + }; + step(); + } + + const CHAT_CARD_STYLE = [ + 'width:100%', + 'border-radius:4px', + 'box-shadow:1px 1px 3px rgba(0,0,0,0.4)', + 'text-align:left', + 'margin:2px auto', + `border:1px solid ${COLOR_BORDER}`, + `color:${COLOR_TEXT}`, + `background-image:-webkit-linear-gradient(135deg,${COLOR_CARD_BG_TOP} 0%,${COLOR_CARD_BG_BOTTOM} 100%)`, + `background-color:${COLOR_CARD_BG_BOTTOM}`, + 'overflow:hidden', + ].join(';'); + + const CHAT_HEADER_STYLE = [ + `background:${COLOR_HEADER_BG}`, + `color:${COLOR_HEADER_TEXT}`, + 'padding:4px 8px', + `border-bottom:2px solid ${COLOR_ACCENT}`, + 'font-variant:small-caps', + 'font-weight:bold', + 'font-size:1.05em', + 'text-align:center', + 'letter-spacing:0.05em', + ].join(';'); + + const CHAT_CONTENT_STYLE = 'padding:5px 8px;line-height:1.5'; + + const BUTTON_STYLE = [ + `background:${COLOR_BUTTON_BG}`, + `color:${COLOR_BUTTON_TEXT}`, + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const BUTTON_SECONDARY_STYLE = [ + 'background:#2c4034', + `color:${COLOR_TEXT}`, + 'border:1px solid #4d6b56', + 'padding:2px 7px', + 'border-radius:3px', + 'text-decoration:none', + 'font-size:0.9em', + 'display:inline-block', + 'margin:1px 2px', + ].join(';'); + + const SECTION_LABEL_STYLE = [ + `color:${COLOR_MUTED}`, + 'font-size:0.8em', + 'text-transform:uppercase', + 'letter-spacing:0.08em', + 'margin-top:4px', + 'margin-bottom:2px', + ].join(';'); + + const DIVIDER_STYLE = `border:none;border-top:1px solid ${COLOR_BORDER};margin:4px 0`; + + /** + * Returns the whisper target for a player, falling back to all GMs. + * + * Double quotes are stripped so the name is safe inside /w "name". + * + * @param {string} [playerId] Roll20 player ID. + * @returns {string} Whisper target text. + */ + function whisperTarget(playerId) { + const player = playerId ? getObj('player', playerId) : null; + if (!player) { + return 'gm'; + } + return `"${String(player.get('displayname') || playerId).replaceAll('"', '')}"`; + } + + /** + * Sends a styled card whispered to a player, or to every GM when no player is given. + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} title Card header text. + * @param {string|string[]} content HTML body content. + * @returns {void} + */ + function whisper(playerId, title, content) { + const body = Array.isArray(content) ? content.join('') : content; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${buildCard(title, body)}`, null, { + noarchive: true, + }); + } + + /** + * Sends a warning whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message Warning text. + * @returns {void} + */ + function whisperWarning(playerId, message) { + const style = [ + `background:${COLOR_WARNING_BG}`, + `color:${COLOR_WARNING_TEXT}`, + `border:1px solid ${COLOR_WARNING_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const html = `
    ${escapeHtml(message)}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Sends an error whispered to a player (or every GM). + * + * @param {string|null} playerId Roll20 player ID. + * @param {string} message What went wrong. + * @param {string} [hint] How to fix it. + * @returns {void} + */ + function whisperError(playerId, message, hint) { + const style = [ + `background:${COLOR_ERROR_BG}`, + `color:${COLOR_ERROR_TEXT}`, + `border:1px solid ${COLOR_ERROR_BORDER}`, + 'padding:4px 8px', + 'border-radius:4px', + 'font-size:0.95em', + ].join(';'); + const hintHtml = hint + ? `
    ${escapeHtml(hint)}
    ` + : ''; + const html = `
    ${escapeHtml(message)}${hintHtml}
    `; + sendChat(SCRIPT_NAME, `/w ${whisperTarget(playerId)} ${html}`, null, { noarchive: true }); + } + + /** + * Builds a styled chat card. + * + * @param {string} title Header text (escaped). + * @param {string} body Body HTML (trusted). + * @returns {string} HTML string. + */ + function buildCard(title, body) { + return [ + `
    `, + `
    ${escapeHtml(title)}
    `, + `
    ${body}
    `, + '
    ', + ].join(''); + } + + /** + * Builds a primary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @returns {string} HTML anchor. + */ + function buildButton(label, command) { + return `${escapeHtml(label)}`; + } + + /** + * Builds a secondary action button. + * + * @param {string} label Button label. + * @param {string} command Chat command the button runs. + * @param {string} [prefixHtml=''] Trusted HTML shown before the label, such as a flag. + * @returns {string} HTML anchor. + */ + function buildSecondaryButton(label, command, prefixHtml = '') { + return `${prefixHtml}${escapeHtml(label)}`; + } + + /** + * Builds a Twemoji asset URL for a locale flag. + * + * @param {string} flag Unicode regional-indicator flag. + * @returns {string} SVG asset URL or an empty string. + */ + function flagAssetUrl(flag) { + const codepoints = Array.from(String(flag || '').trim()) + .map((character) => character.codePointAt(0).toString(16)) + .join('-'); + return codepoints + ? `https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/svg/${codepoints}.svg` + : ''; + } + + /** + * Builds a locale's flag as a Twemoji image. Roll20 on Windows shows emoji + * flags as letter pairs, so the flag is drawn from an SVG instead. + * + * @param {object} locale Locale metadata. + * @returns {string} Trusted flag HTML, or an empty string when there is no flag. + */ + function buildLocaleFlag(locale) { + const label = escapeHtml(locale?.flagLabel || locale?.name || ''); + const url = flagAssetUrl(locale?.flag); + if (!url) { + return ''; + } + return `${label}`; + } + + /** + * Builds a section label. + * + * @param {string} text Label text. + * @returns {string} HTML string. + */ + function buildSectionLabel(text) { + return `
    ${escapeHtml(text)}
    `; + } + + /** + * Builds a horizontal divider. + * + * @returns {string} HTML string. + */ + function buildDivider() { + return `
    `; + } + + /** + * Builds a label/value row. The value may be trusted HTML (e.g. a button). + * + * @param {string} label Label text (escaped). + * @param {string} valueHtml Value HTML. + * @returns {string} HTML string. + */ + function buildRow(label, valueHtml) { + return [ + '', + ``, + ``, + '
    ${escapeHtml(label)}${valueHtml}
    ', + ].join(''); + } + + /** + * Builds a small colour swatch with its value. + * + * @param {string} color CSS colour. + * @returns {string} HTML string. + */ + function buildSwatch(color) { + const safe = escapeHtml(color); + return ` ${safe}`; + } + + // Hex grid geometry. Pure functions only: nothing here touches the Roll20 API, + // so the whole module can be unit tested in Node. + // + // Hexes are addressed by offset coordinates [row, col], matching the keys v1 + // stored in state. "vertical" is Roll20's Hex (V) grid (pointy-top hexes, odd + // rows shifted right by half a hex). "horizontal" is Hex (H) (flat-top hexes, + // odd columns shifted down by half a hex). Internally the maths converts to + // cube coordinates, which make distance, rounding and line drawing exact. + + const SQRT3 = Math.sqrt(3); + + const ORIENTATION_VERTICAL = 'vertical'; + const ORIENTATION_HORIZONTAL = 'horizontal'; + + // Pixel spacing of a 1-unit hex grid. + // + // Legacy values were measured from the Legacy editor's grid by the v1 author + // and are kept exactly so existing v1 hexes stay aligned. Legacy hexes are + // slightly stretched rather than regular. + // + // Jumpgate draws mathematically regular hexes from the 70 px grid unit: the + // distance across the flats is one unit, so the corner radius is 70/√3. The + // first hex's bounding box sits at the page's top-left corner. (Taken from the + // Jumpgate client's hex grid, which builds cells with radius gridCellSize/√3.) + // Pages that still do not line up can be corrected with `!hexploration calibrate`. + const LEGACY_V = { + colStep: 75.19856198446, + rowStep: 66.965827824268, + originX: 37.5, + originY: 44, + }; + const LEGACY_H = { + colStep: 69.585127490377, + rowStep: 79.688789983504, + originX: 47, + originY: 40.5, + }; + const JUMPGATE_UNIT = 70; + + const GRID_PROFILES = { + legacy: { + [ORIENTATION_VERTICAL]: LEGACY_V, + [ORIENTATION_HORIZONTAL]: LEGACY_H, + }, + jumpgate: { + [ORIENTATION_VERTICAL]: { + colStep: JUMPGATE_UNIT, + rowStep: (JUMPGATE_UNIT * SQRT3) / 2, + originX: JUMPGATE_UNIT / 2, + originY: JUMPGATE_UNIT / SQRT3, + }, + [ORIENTATION_HORIZONTAL]: { + colStep: (JUMPGATE_UNIT * SQRT3) / 2, + rowStep: JUMPGATE_UNIT, + originX: JUMPGATE_UNIT / SQRT3, + originY: JUMPGATE_UNIT / 2, + }, + }, + }; + + /** + * Maps a Roll20 page grid_type to a hex orientation. + * + * @param {string} gridType Page grid_type ('hex' or 'hexr'). + * @returns {string|null} Orientation, or null when the grid is not hexagonal. + */ + function orientationForGridType(gridType) { + if (gridType === 'hex') { + return ORIENTATION_VERTICAL; + } + if (gridType === 'hexr') { + return ORIENTATION_HORIZONTAL; + } + return null; + } + + /** + * Builds a grid description for a page. + * + * @param {object} options Grid options. + * @param {string} options.gridType Page grid_type. + * @param {number} [options.scale=1] Page snapping_increment (cell size in units). + * @param {boolean} [options.jumpgate=false] True for Jumpgate geometry. + * @param {number} [options.offsetX=0] Jumpgate page grid_offset_x, in pixels. + * @param {number} [options.offsetY=0] Jumpgate page grid_offset_y, in pixels. Jumpgate + * measures it upwards, so a positive value moves the grid up the page. + * @param {object|null} [options.calibration] Per-page pixel overrides from calibrate. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function createGrid({ + gridType, + scale = 1, + jumpgate = false, + offsetX = 0, + offsetY = 0, + calibration = null, + }) { + const orientation = orientationForGridType(gridType); + if (!orientation) { + return null; + } + + const unit = Number(scale) > 0 ? Number(scale) : 1; + const profile = GRID_PROFILES[jumpgate ? 'jumpgate' : 'legacy'][orientation]; + const grid = { + orientation, + colStep: profile.colStep * unit, + rowStep: profile.rowStep * unit, + originX: profile.originX * unit + (jumpgate ? Number(offsetX) || 0 : 0), + originY: profile.originY * unit - (jumpgate ? Number(offsetY) || 0 : 0), + }; + + if (calibration) { + for (const key of ['colStep', 'rowStep', 'originX', 'originY']) { + if ( + Number.isFinite(calibration[key]) && + (key.startsWith('origin') || calibration[key] > 0) + ) { + grid[key] = calibration[key]; + } + } + } + + return grid; + } + + /** + * Returns true when an integer is odd, including negative values. + * + * @param {number} n Integer. + * @returns {boolean} True when odd. + */ + function isOdd(n) { + return (n & 1) === 1; + } + + /** + * Builds the state key for a hex. + * + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {string} Key in "row,col" form. + */ + function hexKey(row, col) { + return `${row},${col}`; + } + + /** + * Parses a "row,col" hex key. + * + * @param {string} key Hex key. + * @returns {number[]|null} [row, col], or null when malformed. + */ + function parseHexKey(key) { + const parts = String(key).split(','); + if (parts.length !== 2) { + return null; + } + const row = Number(parts[0]); + const col = Number(parts[1]); + return Number.isInteger(row) && Number.isInteger(col) ? [row, col] : null; + } + + /** + * Converts offset coordinates to cube coordinates. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [q, r, s]. + */ + function offsetToCube(grid, row, col) { + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = col - (row - (row & 1)) / 2; + r = row; + } else { + q = col; + r = row - (col - (col & 1)) / 2; + } + return [q, r, -q - r]; + } + + /** + * Converts cube coordinates to offset coordinates. + * + * @param {object} grid Grid object. + * @param {number[]} cube [q, r, s]. + * @returns {number[]} [row, col]. + */ + function cubeToOffset(grid, cube) { + const [q, r] = cube; + if (grid.orientation === ORIENTATION_VERTICAL) { + return [r, q + (r - (r & 1)) / 2]; + } + return [r + (q - (q & 1)) / 2, q]; + } + + /** + * Rounds fractional cube coordinates to the nearest hex. + * + * @param {number[]} cube Fractional [q, r, s]. + * @returns {number[]} Integer [q, r, s]. + */ + function cubeRound(cube) { + let q = Math.round(cube[0]); + let r = Math.round(cube[1]); + let s = Math.round(cube[2]); + const dq = Math.abs(q - cube[0]); + const dr = Math.abs(r - cube[1]); + const ds = Math.abs(s - cube[2]); + + if (dq > dr && dq > ds) { + q = -r - s; + } else if (dr > ds) { + r = -q - s; + } else { + s = -q - r; + } + // Normalise -0 so keys never contain "-0". + return [q + 0, r + 0, s + 0]; + } + + /** + * Returns the pixel centre of a hex. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[]} [x, y]. + */ + function hexToPixel(grid, row, col) { + if (grid.orientation === ORIENTATION_VERTICAL) { + return [ + grid.originX + (col + (isOdd(row) ? 0.5 : 0)) * grid.colStep, + grid.originY + row * grid.rowStep, + ]; + } + return [ + grid.originX + col * grid.colStep, + grid.originY + (row + (isOdd(col) ? 0.5 : 0)) * grid.rowStep, + ]; + } + + /** + * Returns the hex containing a pixel position. + * + * The grid is treated as a regular hex lattice scaled by colStep and rowStep, + * so this is exact for both regular (Jumpgate) and stretched (Legacy) hexes. + * + * @param {object} grid Grid object. + * @param {number} x Pixel x. + * @param {number} y Pixel y. + * @returns {number[]} [row, col]. + */ + function pixelToHex(grid, x, y) { + const colF = (x - grid.originX) / grid.colStep; + const rowF = (y - grid.originY) / grid.rowStep; + let q; + let r; + if (grid.orientation === ORIENTATION_VERTICAL) { + q = colF - rowF / 2; + r = rowF; + } else { + q = colF; + r = rowF - colF / 2; + } + return cubeToOffset(grid, cubeRound([q, r, -q - r])); + } + + /** + * Returns the number of hex steps between two hexes. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number} Distance in hexes. + */ + function hexDistance(grid, a, b) { + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + return Math.max(Math.abs(ca[0] - cb[0]), Math.abs(ca[1] - cb[1]), Math.abs(ca[2] - cb[2])); + } + + /** + * Returns every hex within a distance of a hex (excluding the hex itself), + * nearest first. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {number} radius Distance in hexes. + * @returns {number[][]} Array of [row, col]. + */ + function hexesWithin(grid, row, col, radius) { + const result = []; + const [q, r] = offsetToCube(grid, row, col); + for (let dist = 1; dist <= radius; dist++) { + for (let dq = -dist; dq <= dist; dq++) { + for (let dr = Math.max(-dist, -dq - dist); dr <= Math.min(dist, -dq + dist); dr++) { + const ds = -dq - dr; + if (Math.max(Math.abs(dq), Math.abs(dr), Math.abs(ds)) === dist) { + result.push(cubeToOffset(grid, [q + dq, r + dr, -(q + dq) - (r + dr)])); + } + } + } + } + return result; + } + + /** + * Returns the hexes on a straight line between two hexes, both ends included. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexLine(grid, a, b) { + const n = hexDistance(grid, a, b); + const ca = offsetToCube(grid, a[0], a[1]); + const cb = offsetToCube(grid, b[0], b[1]); + if (n === 0) { + return [[a[0], a[1]]]; + } + + // A tiny nudge stops the line landing exactly on hex edges, where rounding + // would otherwise pick a side inconsistently. + const nudge = [1e-6, 2e-6, -3e-6]; + const result = []; + for (let i = 0; i <= n; i++) { + const t = i / n; + const cube = [0, 1, 2].map((k) => ca[k] + nudge[k] + (cb[k] - ca[k]) * t); + result.push(cubeToOffset(grid, cubeRound(cube))); + } + return result; + } + + /** + * Returns the hexes strictly between two hexes on a straight line. + * + * @param {object} grid Grid object. + * @param {number[]} a [row, col]. + * @param {number[]} b [row, col]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesBetween(grid, a, b) { + return hexLine(grid, a, b).slice(1, -1); + } + + /** + * Returns the hexes crossed by a pixel-space line segment, in travel order. + * + * @param {object} grid Grid object. + * @param {number[]} from [x, y]. + * @param {number[]} to [x, y]. + * @returns {number[][]} Array of [row, col]. + */ + function hexesAlongSegment(grid, from, to) { + return hexLine(grid, pixelToHex(grid, from[0], from[1]), pixelToHex(grid, to[0], to[1])); + } + + /** + * Returns the six corner points of a hex in pixels. + * + * @param {object} grid Grid object. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @returns {number[][]} Array of six [x, y] points, clockwise. + */ + function hexCorners(grid, row, col) { + const [cx, cy] = hexToPixel(grid, row, col); + const corners = []; + for (let i = 0; i < 6; i++) { + if (grid.orientation === ORIENTATION_VERTICAL) { + const angle = ((30 + 60 * i) * Math.PI) / 180; + corners.push([ + cx + (Math.cos(angle) / SQRT3) * grid.colStep, + cy + ((Math.sin(angle) * 2) / 3) * grid.rowStep, + ]); + } else { + const angle = (60 * i * Math.PI) / 180; + corners.push([ + cx + ((Math.cos(angle) * 2) / 3) * grid.colStep, + cy + (Math.sin(angle) / SQRT3) * grid.rowStep, + ]); + } + } + return corners; + } + + /** + * Returns every hex whose centre lies inside a bounding box. + * + * @param {object} grid Grid object. + * @param {object} box Box with left, top, right and bottom in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesInBox(grid, box) { + const [r0, c0] = pixelToHex(grid, box.left, box.top); + const [r1, c1] = pixelToHex(grid, box.right, box.bottom); + const result = []; + for (let row = Math.min(r0, r1) - 1; row <= Math.max(r0, r1) + 1; row++) { + for (let col = Math.min(c0, c1) - 1; col <= Math.max(c0, c1) + 1; col++) { + const [x, y] = hexToPixel(grid, row, col); + if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) { + result.push([row, col]); + } + } + } + return result; + } + + /** + * Returns every hex needed to cover a page completely, including the partial + * hexes along its edges. + * + * @param {object} grid Grid object. + * @param {number} widthPx Page width in pixels. + * @param {number} heightPx Page height in pixels. + * @returns {number[][]} Array of [row, col]. + */ + function hexesCoveringPage(grid, widthPx, heightPx) { + // A hex overlaps the page when its centre is within its own half-size of + // the page edge. Slivers thinner than a quarter pixel are ignored. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const padX = (vertical ? grid.colStep / 2 : (grid.colStep * 2) / 3) - 0.25; + const padY = (vertical ? (grid.rowStep * 2) / 3 : grid.rowStep / 2) - 0.25; + return hexesInBox(grid, { + left: -padX, + top: -padY, + right: widthPx + padX, + bottom: heightPx + padY, + }); + } + + /** + * Returns the hexes a token covers: every hex whose centre lies under the + * token, plus the hex under its centre. + * + * @param {object} grid Grid object. + * @param {number} x Token centre x. + * @param {number} y Token centre y. + * @param {number} width Token width in pixels. + * @param {number} height Token height in pixels. + * @returns {number[][]} Array of [row, col], centre hex first. + */ + function hexesUnderToken(grid, x, y, width, height) { + const centre = pixelToHex(grid, x, y); + // Shrink slightly so a token that only touches a neighbour's centre does not claim it. + const halfW = Math.max(0, width / 2 - 2); + const halfH = Math.max(0, height / 2 - 2); + const covered = hexesInBox(grid, { + left: x - halfW, + top: y - halfH, + right: x + halfW, + bottom: y + halfH, + }); + const centreKey = hexKey(centre[0], centre[1]); + return [centre, ...covered.filter(([r, c]) => hexKey(r, c) !== centreKey)]; + } + + /** + * Derives a calibration from tokens the GM has snapped to hex centres. + * + * One token corrects the grid origin. Two tokens in neighbouring cells of the + * same row (Hex V) or column (Hex H) also correct the hex spacing, keeping the + * current ratio between column and row spacing. + * + * @param {object} grid Current grid object. + * @param {number[][]} points Token centres [[x, y], ...]. + * @returns {object|null} Calibration, or null when the points cannot be used. + */ + function calibrateGrid(grid, points) { + if (!Array.isArray(points) || points.length === 0) { + return null; + } + + let { colStep, rowStep } = grid; + if (points.length >= 2) { + const [a, b] = points; + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const along = vertical ? Math.abs(b[0] - a[0]) : Math.abs(b[1] - a[1]); + const across = vertical ? Math.abs(b[1] - a[1]) : Math.abs(b[0] - a[0]); + const currentStep = vertical ? colStep : rowStep; + const steps = Math.round(along / currentStep); + if (steps < 1 || across > currentStep / 4) { + return null; + } + const ratio = rowStep / colStep; + if (vertical) { + colStep = along / steps; + rowStep = colStep * ratio; + } else { + rowStep = along / steps; + colStep = rowStep / ratio; + } + } + + const scaled = { ...grid, colStep, rowStep }; + const [px, py] = points[0]; + const [row, col] = pixelToHex(scaled, px, py); + const [cx, cy] = hexToPixel(scaled, row, col); + const calibration = { + colStep, + rowStep, + originX: grid.originX + (px - cx), + originY: grid.originY + (py - cy), + }; + + // Keep the origin inside the first cell so offsets stay small and stable. + // Shifting by two rows/columns preserves the odd/even offset pattern. + const vertical = grid.orientation === ORIENTATION_VERTICAL; + const wrapX = vertical ? colStep : colStep * 2; + const wrapY = vertical ? rowStep * 2 : rowStep; + calibration.originX = ((calibration.originX % wrapX) + wrapX) % wrapX; + calibration.originY = ((calibration.originY % wrapY) + wrapY) % wrapY; + return calibration; + } + + const TRANSLATION$m = { + titles: { + ready: 'Hexploration is gereed.', + settings: 'Hexploration-instellings', + languages: "Kies 'n taal", + pageSettings: 'Bladsyinstellings: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdragte', + confirm: 'Bevestig asseblief', + }, + discovery: { + title: 'Ligging ontdek', + }, + menu: { + draw: 'Teken', + reveal: 'Openbaar en versteek', + locations: 'Liggings', + tools: 'Gereedskap', + layerInUse: 'Nuwe seshoeke word op die {layer} geteken.', + pageSettingsHelp: + 'Hierdie instellings geld slegs vir hierdie bladsy. Instellings gemerk met ★ oorskryf die globale instellings.', + }, + buttons: { + fill: 'Vul', + fillInverse: 'Omgekeerde vulling', + undo: 'Ontdoen vulling', + reveal: 'Onthul', + conceal: 'Versteek', + explore: 'Verken', + revealPage: 'Onthul bladsy', + resetPage: 'Stel bladsy terug', + mark: 'Merk ligging', + unmark: 'Ontmerk', + name: 'Benoem seshoek', + settings: 'Instellings', + pageSettings: 'Bladsy-instellings', + status: 'Status', + rescan: 'Skandeer weer', + calibrate: 'Kalibreer', + calibrateReset: 'Stel kalibrasie terug', + help: 'Hulp', + change: 'Verander', + menu: 'Kieslys', + clearOverrides: 'Vee oorskrywings uit', + confirmReset: 'Ja, verwyder alle seshoeke', + }, + prompts: { + name: 'Liggingnaam (laat leeg om skoon te maak)', + }, + values: { + on: 'Aan', + off: 'Af', + none: 'Geen', + hexLayer: { + auto: 'Outo (voorgrond indien beskikbaar)', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', + }, + revealBy: { + players: 'Speler-tokens', + characters: 'Karaktertokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Verwyder', + glimpse: 'Glimp', + }, + announce: { + all: 'Almal', + gm: 'Slegs GM', + off: 'Af', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vul', + fillInverse: 'Omgekeerde vulling', + conceal: 'Versteek', + }, + }, + settings: { + language: { + label: 'Taal', + desc: 'Taal vir kieslyste, boodskappe en uitdeelstukke.', + }, + hexLayer: { + label: 'Seshoeklaag', + desc: 'Waar nuwe seshoeke geteken word. Outo probeer die voorgrondlaag (bo tokens) en val terug na die tokenlaag as die speletjie dit nie ondersteun nie.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nuwe seshoeke. Gebruik rgba() vir deursigtige seshoeke, byvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van die buitelyn van nuwe seshoeke.', + }, + labelColor: { + label: 'Etiketkleur', + desc: 'Kleur van die naametikette wat net die GM sien, op benoemde seshoeke.', + }, + glimpseColor: { + label: 'Glimpkleur', + desc: "Kleur waarna seshoeke verander wanneer hulle deurskynend word (Glimp-onthullingsmodus). Gebruik 'n deurskynende rgba()-kleur.", + }, + strokeWidth: { + label: 'Randdikte', + desc: 'Dikte van die buitelyn van nuwe seshoeke, in pieksels (0 tot 20).', + }, + maxDistance: { + label: 'Seshoek-onthullingsafstand', + desc: "Word op seshoeke gestoor wanneer hulle gevul word, so stel dit in voordat jy vul: om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien; met 0 word hulle slegs onthul deur hulle binne te gaan. Gebruik dit vir berge of woude. Laat leeg vir geen beperking nie.", + }, + revealDistance: { + label: 'Sigafstand', + desc: "Hoeveel seshoeke rondom 'n bewegende token onthul word (0 tot 20). 0 onthul slegs die seshoeke waardeur die token beweeg.", + }, + lineOfSight: { + label: 'Siglyn', + desc: "Wanneer dit aan is, versteek seshoeke wat bedek bly, soos berge wat met 'n Seshoek-onthullingsafstand gevul is, die seshoeke agter hulle. Dit maak slegs 'n verskil met 'n Sigafstand van 2 of meer.", + }, + revealPath: { + label: 'Onthul langs pad', + desc: "Wanneer dit aan is, word elke seshoek waardeur 'n token beweeg terwyl dit gesleep word (insluitend tussenpunte), onthul, nie net waar dit stop nie.", + }, + revealBy: { + label: 'Tokens wat onthul', + desc: "Watter tokens op die tokenlaag seshoeke onthul: tokens wat deur 'n speler beheer word, tokens wat enige karakter verteenwoordig, of elke token.", + }, + revealMode: { + label: 'Onthullingsmodus', + desc: "Met Verwyder word seshoeke binne sig verwyder. Met Glimp word hulle eerder deurskynend; hulle word verwyder wanneer 'n token hulle binnegaan.", + }, + announce: { + label: 'Kondig ontdekkings aan', + desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + }, + pingDiscoveries: { + label: 'Ping ontdekkings', + desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + }, + hideCoveredTokens: { + label: 'Versteek bedekte tokens', + desc: "Roll20 teken name, balke en auras bo seshoeke. Wanneer dit aan is, word die naam, balke en auras wat spelers kan sien, afgeskakel vir tokens onder 'n bedekte seshoek, en weer aangeskakel wanneer hulle ontbloot word.", + }, + }, + status: { + engine: 'Spelenjin', + grid: 'Rooster', + layer: 'Seshoeklaag', + hexes: 'Seshoeke', + named: 'Benoemde seshoeke', + icons: 'Liggingtokens', + glimpsed: 'Deurskynende seshoeke', + pending: "Liggings wat op 'n vulling wag", + calibrated: 'Gekalibreer', + overrides: 'Bladsy-oorskrywings', + undo: 'Ontdoen beskikbaar', + }, + messages: { + filled: + 'Vulling voltooi. Seshoeke geteken: {created}. Herstileer: {restyled}. Liggings versteek: {icons}.', + revealed: 'Seshoeke onthul: {count}.', + revealedPage: 'Elke seshoek op die bladsy is onthul ({count}).', + confirmReset: + 'Verwyder elke seshoek van "{page}" ({count})? Liggingtokens keer terug na die tokenlaag. Ontdoen kan dit nie omkeer nie.', + resetPage: 'Seshoeke van die bladsy verwyder: {count}.', + undone: + 'Laaste vulling ontdoen. Seshoeke verwyder: {removed}. Herstileerde seshoeke herstel: {restored}.', + named: 'Seshoeke benoem as "{name}": {count}.', + unnamed: 'Name skoongemaak: {count}.', + marked: + 'Liggings versteek in bestaande seshoeke: {attached}. Wag vir die volgende vulling wat hulle bedek: {pending}.', + unmarked: 'Tokens wat nie meer liggings is nie: {count}.', + settingChanged: '{setting} gestel na {value}.', + rescanned: + 'Herskandeer voltooi. Gehou: {kept}. Aangeneem: {adopted}. Herliasseer: {moved}. Ontbreek en vergeet: {dropped}. Etikette herskakel: {labels}. Liggingtokens herskakel: {icons}.', + calibrated: + 'Rooster gekalibreer (kolomstap {colStep}px, rystap {rowStep}px). Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', + calibrationReset: + 'Kalibrasie verwyder. Herskandeer: behou {kept}, herliasseer {moved}, het {adopted} aangeneem.', + journalRebuilt: 'Die "{help}" en "{deck}"-uitdeelstukke is herbou.', + migrated: + "Jou Hexploration 1.x-seshoekkaarte is opgegradeer. As hierdie speletjie uit 'n Legacy-speletjie gekopieer is, gebruik Skandeer weer op elke seshoekkaartbladsy.", + pruned: + 'Gestoorde seshoeke wat nie meer bestaan nie en vergeet is: {dropped}. As hierdie speletjie of bladsy gekopieer is, gebruik Skandeer weer op die bladsy om sy seshoeke weer op te tel.', + readyHint: + 'Tik !hexploration vir die kieslys, of maak die "Hexploration - Command Deck"-uitdeelstuk oop.', + }, + warnings: { + foregroundUnavailable: + 'Hierdie speletjie ondersteun nie teken op die voorgrondlaag nie, dus is die seshoeke op die tokenlaag geteken.', + someFailed: + 'Seshoeke wat nie geteken kon word nie: {count}. Kyk in die API-konsole vir besonderhede.', + }, + errors: { + noPage: 'Kon nie die bladsy vind om aan te werk nie.', + notHex: "Hierdie bladsy gebruik nie 'n seshoekrooster nie.", + noPolygons: 'Kies een of meer getekende vorms om te vul.', + emptyArea: 'Die geselekteerde gebied bevat geen seshoekmiddelpunte nie.', + tooMany: 'Dit sal te veel seshoeke op een slag skep ({count}).', + nothingToConceal: 'Kies getekende vorms of tokens om te versteek.', + nothingToReveal: 'Kies seshoeke, getekende vorms of tokens om te onthul.', + noTokens: 'Kies eers een of meer tokens.', + noHexes: 'Kies eers een of meer seshoeke (of tokens wat op seshoeke staan).', + nothingToUndo: 'Daar is geen vul om ongedaan te maak nie.', + unknownCommand: 'Onbekende opdrag: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellings wat per bladsy gestel kan word: {keys}', + invalidValue: '"{value}" is nie \'n geldige waarde vir {key} nie.', + calibrateNeedsTokens: 'Kies een of twee tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateFailed: 'Daardie tokens kan nie gebruik word om te kalibreer nie.', + unexpected: 'Iets het verkeerd geloop: {message}', + }, + hints: { + noPage: 'Maak die bladsy oop waaraan jy wil werk, of kies iets daarop.', + notHex: 'Stel die bladsyrooster op Hex (V) of Hex (H) in Bladsy-instellings.', + noPolygons: + "Teken 'n veelhoek, reghoek, ellips of vryhandvorm om die area, kies dit en probeer dan weer.", + emptyArea: "Teken 'n groter vorm, of gaan die bladsyroosterinstellings na.", + tooMany: "Vul 'n kleiner gebied, of verdeel die gebied in verskeie vorms.", + noHexes: + 'Seshoeke is op die voorgrond- of tokenlaag; skakel oor na daardie laag om hulle te kies.', + unknownCommand: 'Tik !hexploration help om die opdragte te lys.', + unknownSetting: 'Tik !hexploration set om elke instelling te sien.', + calibrateNeedsTokens: + "Klik 'n token vas in die middel van 'n seshoek en kies dit. Kies 'n tweede token wat op 'n naburige seshoek in dieselfde ry (Hex V) of kolom (Hex H) vasgeklik is om ook die seshoekgrootte reg te stel.", + calibrateFailed: + 'Die twee tokens moet in dieselfde ry (Hex V) of dieselfde kolom (Hex H) wees, minstens een seshoek uitmekaar.', + unexpected: 'Besonderhede is in die API-konsole-logboek.', + }, + help: { + menu: 'Wys die kieslys.', + fill: 'Bedek die geselekteerde getekende vorms met seshoeke.', + fillInverse: 'Bedek die hele bladsy behalwe binne die geselekteerde vorms.', + undo: 'Ontdoen die laaste vulling, omgekeerde vulling of versteek, en herstel die vorms wat dit gebruik het.', + reveal: + 'Onthul die geselekteerde seshoeke, en die seshoeke onder die geselekteerde vorms en tokens.', + revealPage: 'Onthul elke seshoek op die bladsy sonder aankondigings.', + conceal: 'Bedek die gebied onder die geselekteerde vorms en tokens weer met seshoeke.', + explore: 'Onthul rondom die geselekteerde tokens asof hulle pas daarheen beweeg het.', + resetPage: 'Verwyder elke seshoek op die bladsy (vra eers).', + name: 'Benoem die geselekteerde seshoeke, of die seshoeke onder die geselekteerde tokens. Laat die naam leeg om dit uit te vee.', + mark: 'Verander die geselekteerde tokens in versteekte liggings.', + unmark: 'Stop dat die geselekteerde tokens versteekte liggings is.', + set: "Verander 'n instelling, of wys alle instellings.", + pageSet: "Oorskryf 'n onthullingsinstelling slegs op die huidige bladsy.", + pageClear: 'Verwyder die huidige bladsy se oorskrywings.', + rescan: + "Herbou die bladsy se seshoeklys, byvoorbeeld nadat jy 'n bladsy of speletjie gekopieer het.", + calibrate: + 'Belyn die seshoekrooster met een of twee geselekteerde tokens wat op seshoekmiddelpunte vasgeklik is.', + calibrateReset: 'Verwyder die huidige bladsy se kalibrasie.', + status: 'Wys wat Hexploration van die huidige bladsy weet.', + journal: 'Herbou die Help- en Command Deck-uitdeelstukke.', + help: 'Wys hierdie lys.', + handout: 'Volledige instruksies is in die "{name}"-uitdeelstuk.', + }, + deck: { + drawDesc: + "Teken vorms om 'n area, kies hulle en vul dan. Ontdoen keer die laaste vulling om.", + revealDesc: + 'Kies seshoeke, vorms of tokens om hulle te onthul of weer te bedek. Verken onthul rondom geselekteerde tokens asof hulle beweeg het.', + locationsDesc: + "Kies tokens om hulle as liggings onder seshoeke te versteek. Kies seshoeke of tokens om 'n seshoek te benoem.", + toolsDesc: + 'Instellings, bladsy-oorskrywings, status, herskandering van gekopieerde bladsye en kalibrering van die rooster.', + footer: 'Sien die "{help}"-uitdeelstuk vir volledige instruksies.', + }, + handout: { + versionLabel: 'Weergawe', + subtitle: 'Seshoek-vir-seshoek-verkenning vir Roll20', + footer: 'Gebruik die "{deck}"-uitdeelstuk vir een-klik kontroles.', + overview: { + heading: 'Oorsig', + body: "Hexploration bedek 'n seshoekkaart met ondeursigtige seshoeke. Soos die groep beweeg, word die seshoeke waardeur hulle gaan (en, as jy wil, die seshoeke rondom hulle) verwyder, sodat die kaart een seshoek op 'n slag ontbloot word. Versteekte liggings kan onder seshoeke geplaas word en word aangekondig wanneer hulle gevind word. Dit werk in Jumpgate- en Legacy-speletjies, op Hex (V)- en Hex (H)-roosters van enige grootte.", + demo: "Kyk na 'n kort demonstrasie (vanaf weergawe 1)", + }, + quickStart: { + heading: 'Vinnige Begin', + steps: [ + "Maak 'n bladsy oop waarvan die rooster op Hex (V) of Hex (H) gestel is.", + 'Teken een of meer vorms (veelhoek, reghoek, ellips of vryhand) om die area om weg te steek.', + 'Kies die vorms en klik op Vul in die Command Deck (of tik !hexploration fill). Die vorms word deur seshoeke vervang.', + 'Opsioneel: kies voor die vulling tokens vir belangrike plekke en klik Merk ligging. Hulle word onder die seshoeke versteek en aangekondig wanneer hulle ontdek word.', + "Beweeg 'n speler-token. Elke seshoek waardeur dit beweeg, en die seshoeke binne sy Sigafstand, word onthul.", + ], + }, + commands: { + heading: 'Opdragte', + intro: + "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", + colCommand: 'Bevel', + colDesc: 'Wat dit doen', + }, + revealing: { + heading: 'Hoe onthulling werk', + points: [ + 'Slegs tokens op die tokenlaag onthul seshoeke. Watter tokens tel, word deur Tokens wat onthul bepaal: by verstek speler-tokens, sodat die GM monsters kan skuif sonder om die kaart te ontbloot.', + "'n Token onthul elke seshoek wat dit bedek (groot tokens bedek verskeie) en, met Onthul langs pad aan, elke seshoek op die roete waarlangs dit gesleep is, insluitend tussenpunte.", + "Sigafstand onthul die seshoeke rondom elk van daardie seshoeke, die naaste eerste. Met Siglyn aan word 'n seshoek nie onthul solank 'n bedekte seshoek tussen dit en die token lê nie. Nader seshoeke word gewoonlik eerste onthul, so in oop terrein verander Siglyn niks nie: dit maak slegs saak met 'n Sigafstand van 2 of meer en seshoeke wat bedek bly, soos terrein wat met 'n Seshoek-onthullingsafstand gevul is.", + "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", + "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", + "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + ], + }, + locations: { + heading: 'Benoemde seshoeke en liggings', + points: [ + "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", + 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', + 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", + 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + ], + }, + settings: { + heading: 'Instellings', + intro: + 'Verander instellings met !hexploration set (of die Instellings-knoppie). Seshoeklaag, Tokens wat onthul en Taal kan ook op die Mod se instellingsbladsy gestel word.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beskrywing', + perPage: '(Kan per bladsy gestel word.)', + }, + jumpgate: { + heading: 'Jumpgate en Legacy', + points: [ + 'Hexploration bepaal watter enjin die speletjie gebruik en teken die ooreenstemmende soort vorm. Vorms wat in enige van die twee redigeerders geteken is, kan gevul word.', + 'Met Seshoeklaag op Outo gestel, word seshoeke op die voorgrondlaag bo tokens geteken, sodat spelers nie kan sien wat daaronder is nie. As die voorgrondlaag nie beskikbaar is nie, word die tokenlaag eerder gebruik.', + "Jumpgate teken wiskundig reëlmatige seshoeke, wat 'n effens ander vorm as Legacy-seshoeke het. As die seshoeke nie met 'n bladsy se rooster belyn nie, klik 'n token vas op 'n seshoekmiddelpunt, kies dit en klik Kalibreer. Kies twee tokens in naburige seshoeke van dieselfde ry (Hex V) of kolom (Hex H) om ook die seshoekgrootte reg te stel.", + "Wanneer 'n bladsy of speletjie gekopieer word, kry sy seshoeke nuwe ID's. Gebruik Skandeer weer op die bladsy om hulle weer op te tel, saam met hul naametikette en liggingtokens.", + ], + }, + upgrading: { + heading: 'Opgradering vanaf weergawe 1', + points: [ + "Weergawe 2 het nie meer PathMath, MatrixMath, Vector Math of HTML Builder nodig nie. Jy kan hulle verwyder tensy 'n ander mod dit gebruik.", + 'Bestaande seshoekkaarte, name, liggingtokens en instellings word met die eerste begin outomaties opgegradeer.', + 'Die weergawe 1-opdragte, insluitend die Hexploration_menu-makro, werk steeds.', + "Weergawe 1 het enige token wat 'n karakter verteenwoordig, seshoeke laat onthul. Stel Tokens wat onthul op Karaktertokens om daardie gedrag te behou.", + ], + colV1: 'Weergawe 1 opdrag', + colV2: 'Weergawe 2 opdrag', + }, + troubleshooting: { + heading: 'Probleemoplossing', + points: [ + "Niks gebeur wanneer 'n token beweeg nie: maak seker dat die token op die tokenlaag is en by Tokens wat onthul pas, en dat die bladsy seshoeke het (!hexploration status).", + "Seshoeke is van die rooster af verskuif: gebruik Kalibreer en kyk dan met 'n token op 'n paar seshoeke oor die kaart heen.", + "Seshoeke word nie meer onthul nadat 'n bladsy of speletjie gekopieer is nie: gebruik Skandeer weer op die bladsy.", + 'Vul sê die gebied het geen seshoekmiddelpunte nie: die vorm moet die middelpunt van ten minste een seshoek bevat.', + 'Vir enigiets anders, gaan die API-konsole-logboek na en sluit sy boodskappe in wanneer jy om hulp vra.', + ], + }, + languages: { + heading: 'Tale', + body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + colLanguage: 'Taal', + colNative: 'Naam in eie taal', + colCode: 'Kode', + }, + credits: { + heading: 'Krediete', + original: 'Oorspronklike mod deur', + maintainer: 'Weergawe 2 onderhou deur', + marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', + support: + "As jy 'n fout vind of 'n idee het, plaas in die Roll20 Mod-forum of maak 'n probleem op GitHub oop, en sluit enige boodskappe van die API-konsole-logboek in.", + }, + }, + }; + + const TRANSLATION$l = { + titles: { + ready: 'Hexploration està a punt.', + settings: "Configuració d'Hexploration", + languages: 'Trieu un idioma', + pageSettings: 'Configuració de la pàgina: {page}', + status: "Estat d'Hexploration: {page}", + help: "Comandes d'Hexploration", + confirm: 'Si us plau, confirmeu', + }, + discovery: { + title: 'Ubicació descoberta', + }, + menu: { + draw: 'Dibuixa', + reveal: 'Revela i amaga', + locations: 'Ubicacions', + tools: 'Eines', + layerInUse: "S'estan dibuixant hexàgons nous a la {layer}.", + pageSettingsHelp: + "Aquesta configuració només s'aplica a aquesta pàgina. La configuració marcada amb ★ anul·la la configuració global.", + }, + buttons: { + fill: 'Omple', + fillInverse: 'Emplenament invers', + undo: "Desfés l'emplenament", + reveal: 'Revela', + conceal: 'Amaga', + explore: 'Explora', + revealPage: 'Revela la pàgina', + resetPage: 'Restableix la pàgina', + mark: 'Marca la ubicació', + unmark: 'Desmarca', + name: "Anomena l'hexàgon", + settings: 'Configuració', + pageSettings: 'Configuració de la pàgina', + status: 'Estat', + rescan: 'Torna a escanejar', + calibrate: 'Calibra', + calibrateReset: 'Restableix la calibració', + help: 'Ajuda', + change: 'Canvia', + menu: 'Menú', + clearOverrides: 'Esborra les substitucions', + confirmReset: 'Sí, elimina tots els hexàgons', + }, + prompts: { + name: 'Nom de la ubicació (deixeu en blanc per esborrar)', + }, + values: { + on: 'Activat', + off: 'Desactivat', + none: 'Cap', + hexLayer: { + auto: 'Automàtic (primer pla si està disponible)', + foreground: 'capa de primer pla', + objects: 'capa de fitxes', + }, + revealBy: { + players: 'Fitxes de jugador', + characters: 'Fitxes de personatges', + all: 'Totes les fitxes', + }, + revealMode: { + clear: 'Neteja', + glimpse: "Cop d'ull", + }, + announce: { + all: 'Tothom', + gm: 'Només el GM', + off: 'Desactivat', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Omple', + fillInverse: 'Emplenament invers', + conceal: 'Amaga', + }, + }, + settings: { + language: { + label: 'Llengua', + desc: 'Idioma per a menús, missatges i fullets.', + }, + hexLayer: { + label: 'Capa dels hexàgons', + desc: "On es dibuixen els hexàgons nous. Automàtic prova la capa de primer pla (per sobre de les fitxes) i recorre a la capa de fitxes si el joc no l'admet.", + }, + fillColor: { + label: 'Color de farciment', + desc: 'Color dels hexàgons nous. Utilitzeu rgba() per a hexàgons transparents, per exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color de la vora', + desc: 'Color del contorn dels nous hexagonals.', + }, + labelColor: { + label: "Color de l'etiqueta", + desc: 'Color de les etiquetes de nom, visibles només per al GM, dels hexàgons amb nom.', + }, + glimpseColor: { + label: "Color de cop d'ull", + desc: "Color que prenen els hexàgons quan es veuen de cop d'ull (mode de revelació Cop d'ull). Utilitzeu un color rgba() transparent.", + }, + strokeWidth: { + label: 'Amplada de la vora', + desc: 'Amplada del contorn dels hexàgons nous, en píxels (de 0 a 20).', + }, + maxDistance: { + label: 'Distància de revelació dels hexàgons', + desc: "Es desa als hexàgons quan s'omplen, així que configureu-la abans d'omplir: canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure; amb 0, només es revelen quan s'hi entra. Utilitzeu-la per a muntanyes o boscos. Deixeu-ho buit perquè no hi hagi límit.", + }, + revealDistance: { + label: 'Distància de visió', + desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + }, + lineOfSight: { + label: 'Línia de visió', + desc: 'Quan està activat, els hexàgons que continuen coberts, com ara muntanyes omplertes amb una Distància de revelació dels hexàgons, amaguen els hexàgons que hi ha darrere. Només té efecte amb una Distància de visió de 2 o més.', + }, + revealPath: { + label: 'Revela al llarg del camí', + desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + }, + revealBy: { + label: 'Fitxes que revelen', + desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + }, + revealMode: { + label: 'Mode de revelació', + desc: "Neteja elimina els hexàgons a la vista. Cop d'ull, en canvi, els fa transparents; s'eliminen quan hi entra una fitxa.", + }, + announce: { + label: 'Anunciar descobriments', + desc: 'Qui veu el missatge de xat quan es descobreix una ubicació amb nom.', + }, + pingDiscoveries: { + label: 'Fer ping als descobriments', + desc: 'Quan està activat, els jugadors reben un ping a una ubicació amb nom quan es descobreix.', + }, + hideCoveredTokens: { + label: 'Amaga les fitxes cobertes', + desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + }, + }, + status: { + engine: 'Motor de joc', + grid: 'Quadrícula', + layer: 'Capa dels hexàgons', + hexes: 'Hexàgons', + named: 'Hexàgons amb nom', + icons: "Fitxes d'ubicació", + glimpsed: 'Hexàgons albirats', + pending: "Ubicacions pendents d'emplenament", + calibrated: 'Calibrat', + overrides: 'Substitucions de la pàgina', + undo: 'Es pot desfer', + }, + messages: { + filled: + 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', + revealed: 'Hexagones revelats: {count}.', + revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", + confirmReset: + 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', + resetPage: 'Hexàgons eliminats de la pàgina: {count}.', + undone: + 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + named: 'Hexàgons anomenats "{name}": {count}.', + unnamed: 'Noms esborrats: {count}.', + marked: + 'Ubicacions amagades en hexàgons existents: {attached}. Pendents del següent farciment que les cobreixi: {pending}.', + unmarked: 'Fitxes que ja no són ubicacions: {count}.', + settingChanged: "{setting} s'ha establert en {value}.", + rescanned: + "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", + calibrated: + "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + calibrationReset: + "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', + migrated: + "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", + pruned: + "Hexàgons desats que ja no existeixen i s'han oblidat: {dropped}. Si s'ha copiat aquest joc o pàgina, executeu Torna a escanejar a la pàgina per recuperar-ne els hexàgons.", + readyHint: + 'Escriviu !hexploration per obrir el menú o obriu el fullet "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + someFailed: + "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", + }, + errors: { + noPage: "No s'ha pogut trobar la pàgina per treballar.", + notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', + noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', + emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", + tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', + nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer un o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToUndo: 'No hi ha cap emplenament per desfer.', + unknownCommand: 'Ordre desconeguda: {command}', + unknownSetting: 'Configuració desconeguda: {key}', + unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', + invalidValue: '"{value}" no és un valor vàlid per a {key}.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', + unexpected: "S'ha produït un error: {message}", + }, + hints: { + noPage: 'Obriu la pàgina en què voleu treballar o seleccioneu-hi alguna cosa.', + notHex: + 'Estableix la quadrícula de la pàgina a Hex (V) o Hex (H) a la configuració de la pàgina.', + noPolygons: + "Dibuixa un polígon, un rectangle, una el·lipse o una forma a mà alçada al voltant de l'àrea, selecciona'l i torna-ho a provar.", + emptyArea: + 'Dibuixa una forma més gran o comprova la configuració de la quadrícula de la pàgina.', + tooMany: "Omple una àrea més petita o divideix l'àrea en diverses formes.", + noHexes: + 'Els hexàgons són a la capa de primer pla o a la de fitxes; canvieu a aquesta capa per seleccionar-los.', + unknownCommand: 'Escriviu !hexploration help per llistar les ordres.', + unknownSetting: 'Escriviu !hexploration set per veure tots els paràmetres.', + calibrateNeedsTokens: + "Col·loqueu una fitxa al centre d'un hexàgon i seleccioneu-la. Seleccioneu una segona fitxa ajustada a un hexàgon veí de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + calibrateFailed: + "Les dues fitxes han d'estar a la mateixa fila (Hex V) o a la mateixa columna (Hex H), separades almenys per un hexàgon.", + unexpected: "Els detalls es troben al registre de la consola de l'API.", + }, + help: { + menu: 'Mostra el menú.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', + undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + reveal: + 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', + conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", + explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', + name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + mark: 'Converteix les fitxes seleccionades en llocs ocults.', + unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + set: 'Canvia un paràmetre o mostra tots els paràmetres.', + pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', + pageClear: 'Elimina les substitucions de la pàgina actual.', + rescan: + "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", + calibrate: + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + calibrateReset: 'Elimineu el calibratge de la pàgina actual.', + status: 'Mostra què sap Hexploration sobre la pàgina actual.', + journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", + help: 'Mostra aquesta llista.', + handout: 'Les instruccions completes es troben al fullet "{name}".', + }, + deck: { + drawDesc: + "Dibuixa formes al voltant d'una àrea, selecciona-les i omple. Desfés l'emplenament reverteix l'últim emplenament.", + revealDesc: + "Selecciona hexàgons, formes o fitxes per revelar-los o tornar-los a cobrir. Explora revela el voltant de les fitxes seleccionades com si s'haguessin mogut.", + locationsDesc: + 'Seleccioneu fitxes per amagar-les com a ubicacions sota els hexàgons. Seleccioneu hexàgons o fitxes per posar nom a un hexàgon.', + toolsDesc: + 'Configuració, substitucions de pàgines, estat, reescaneig de pàgines copiades i calibratge de la quadrícula.', + footer: 'Consulteu el fullet "{help}" per obtenir instruccions completes.', + }, + handout: { + versionLabel: 'Versió', + subtitle: 'Exploració hexàgon a hexàgon per a Roll20', + footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', + overview: { + heading: 'Visió general', + body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + demo: 'Mira una petita demostració (de la versió 1)', + }, + quickStart: { + heading: 'Inici ràpid', + steps: [ + 'Obriu una pàgina la graella de la qual estigui configurada en Hex (V) o Hex (H).', + "Dibuixa una o més formes (polígon, rectangle, el·lipse o mà alçada) al voltant de l'àrea per amagar.", + 'Seleccioneu les formes i feu clic a Omple al Command Deck (o escriviu !hexploration fill). Les formes se substitueixen per hexàgons.', + "Opcional: abans d'omplir, seleccioneu fitxes per a llocs importants i feu clic a Marca la ubicació. S'amaguen sota els hexàgons i s'anuncien quan es descobreixen.", + 'Mou una fitxa de jugador. Es revelen tots els hexàgons que travessa i els hexàgons dins de la seva distància de visió.', + ], + }, + commands: { + heading: 'Ordres', + intro: + 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', + colCommand: 'Comandament', + colDesc: 'Què fa', + }, + revealing: { + heading: 'Com funciona la revelació', + points: [ + 'Només les fitxes de la capa de fitxes revelen hexàgons. Quines fitxes compten ho determina Fitxes que revelen: per defecte, les fitxes de jugador, de manera que el GM pot moure monstres sense descobrir el mapa.', + "Una fitxa revela tots els hexàgons que cobreix (les fitxes grans en cobreixen diversos) i, amb Revela al llarg del camí activat, tots els hexàgons de la ruta per on s'ha arrossegat, inclosos els punts de pas.", + "La Distància de visió revela els hexàgons al voltant de cadascun d'aquests hexàgons, començant pels més propers. Amb la Línia de visió activada, un hexàgon no es revela mentre hi hagi un hexàgon cobert entre ell i la fitxa. Normalment els hexàgons més propers es revelen primer, de manera que en terreny obert la Línia de visió no canvia res: només importa amb una Distància de visió de 2 o més i hexàgons que continuen coberts, com ara terreny omplert amb una Distància de revelació dels hexàgons.", + "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", + "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", + "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", + "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + ], + }, + locations: { + heading: 'Hexes i ubicacions anomenades', + points: [ + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", + "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", + "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", + ], + }, + settings: { + heading: 'Configuració', + intro: + 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', + colKey: 'clau', + colName: 'Configuració', + colDesc: 'Descripció', + perPage: '(Es pot configurar per pàgina.)', + }, + jumpgate: { + heading: 'Jumpgate i Legacy', + points: [ + 'Hexploration determina quin motor utilitza el joc i dibuixa el tipus de forma corresponent. Les formes dibuixades en qualsevol dels editors es poden omplir.', + "Amb Capa dels hexàgons establerta a Automàtic, els hexàgons es dibuixen a la capa de primer pla, per sobre de les fitxes, perquè els jugadors no puguin veure què hi ha a sota. Si la capa de primer pla no està disponible, s'utilitza la capa de fitxes.", + "Jumpgate dibuixa hexàgons matemàticament regulars, que tenen una forma lleugerament diferent dels hexàgons de Legacy. Si els hexàgons no s'alineen amb la graella d'una pàgina, ajusteu una fitxa al centre d'un hexàgon, seleccioneu-la i feu clic a Calibra. Seleccioneu dues fitxes en hexàgons veïns de la mateixa fila (Hex V) o columna (Hex H) per corregir també la mida de l'hexàgon.", + "Quan es copia una pàgina o un joc, els seus hexàgons reben identificadors nous. Executeu Torna a escanejar a la pàgina per tornar-los a recuperar, juntament amb les etiquetes de nom i les fitxes d'ubicació.", + ], + }, + upgrading: { + heading: 'Actualització de la versió 1', + points: [ + 'La versió 2 ja no necessita PathMath, MatrixMath, Vector Math o HTML Builder. Podeu eliminar-los tret que els utilitzi un altre mod.', + "Els mapes d'hexàgons, els noms, les fitxes d'ubicació i la configuració existents s'actualitzen automàticament la primera vegada que s'inicia.", + 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', + 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', + ], + colV1: 'Comandament de la versió 1', + colV2: 'Comandament de la versió 2', + }, + troubleshooting: { + heading: 'Resolució de problemes', + points: [ + 'No passa res quan es mou una fitxa: comproveu que la fitxa és a la capa de fitxes i que coincideix amb Fitxes que revelen, i que la pàgina té hexàgons (!hexploration status).', + 'Els hexàgons estan desplaçats respecte de la quadrícula: utilitzeu Calibra i, a continuació, comproveu-ho amb una fitxa en uns quants hexàgons del mapa.', + 'Els hexàgons han deixat de revelar-se després de copiar una pàgina o un joc: executeu Torna a escanejar a la pàgina.', + "Omple diu que l'àrea no té centres d'hexàgon: la forma ha de contenir el centre d'almenys un hexàgon.", + "Per a qualsevol altra cosa, comproveu el registre de la consola de l'API i incloeu-ne els missatges quan demaneu ajuda.", + ], + }, + languages: { + heading: 'Idiomes', + body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + colLanguage: 'Llengua', + colNative: 'Nom original', + colCode: 'Codi', + }, + credits: { + heading: 'Crèdits', + original: 'Mod original de', + maintainer: 'Versió 2 mantinguda per', + marketplace: "Els paquets d'art de l'Ada al mercat Roll20", + support: + "Si trobeu un error o teniu una idea, publiqueu-lo al fòrum Roll20 Mod o obriu un problema a GitHub i incloeu qualsevol missatge del registre de la consola de l'API.", + }, + }, + }; + + const TRANSLATION$k = { + titles: { + ready: 'Hexploration 已就緒。', + settings: 'Hexploration 設定', + languages: '選擇語言', + pageSettings: '頁面設定：{page}', + status: 'Hexploration 狀態：{page}', + help: 'Hexploration 指令', + confirm: '請確認', + }, + discovery: { + title: '發現地點', + }, + menu: { + draw: '繪製', + reveal: '揭示與隱藏', + locations: '地點', + tools: '工具', + layerInUse: '正在 {layer} 上繪製新的六角形。', + pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', + }, + buttons: { + fill: '填充', + fillInverse: '反向填充', + undo: '撤銷填充', + reveal: '揭示', + conceal: '隱藏', + explore: '探索', + revealPage: '揭示整頁', + resetPage: '重置頁面', + mark: '標記地點', + unmark: '取消標記', + name: '命名六角格', + settings: '設定', + pageSettings: '頁面設定', + status: '狀態', + rescan: '重新掃描', + calibrate: '校準', + calibrateReset: '重置校準', + help: '說明', + change: '變更', + menu: '選單', + clearOverrides: '清除覆寫', + confirmReset: '是，移除所有六角格', + }, + prompts: { + name: '地點名稱（留空以清除）', + }, + values: { + on: '開', + off: '關', + none: '無', + hexLayer: { + auto: '自動（可用時使用前景層）', + foreground: '前景層', + objects: '令牌層', + }, + revealBy: { + players: '玩家令牌', + characters: '角色令牌', + all: '所有令牌', + }, + revealMode: { + clear: '清除', + glimpse: '瞥見', + }, + announce: { + all: '所有人', + gm: '僅限 GM', + off: '關', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '填充', + fillInverse: '反向填充', + conceal: '隱藏', + }, + }, + settings: { + language: { + label: '語言', + desc: '選單、訊息和講義的語言。', + }, + hexLayer: { + label: '六角格圖層', + desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + }, + fillColor: { + label: '填充顏色', + desc: '新六角格的顏色。若要讓六角格半透明，請使用 rgba()，例如 rgba(0,0,0,0.8)。', + }, + strokeColor: { + label: '邊框顏色', + desc: '新六邊形輪廓的顏色。', + }, + labelColor: { + label: '標籤顏色', + desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + }, + glimpseColor: { + label: '瞥見顏色', + desc: '六角格被瞥見時變成的顏色（「瞥見」揭示模式）。請使用半透明的 rgba() 顏色。', + }, + strokeWidth: { + label: '邊框寬度', + desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + }, + maxDistance: { + label: '六角格揭示距離', + desc: '六角格在填充時會儲存此值，因此請在填充前設定：之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於這麼多格以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。可用於山脈或森林。留空則無限制。', + }, + revealDistance: { + label: '視距', + desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + }, + lineOfSight: { + label: '視線', + desc: '啟用後，持續被覆蓋的六角格（例如以「六角格揭示距離」填充的山脈）會遮住其後方的六角格。只有在「視距」為 2 或以上時才會有差別。', + }, + revealPath: { + label: '沿路徑顯示', + desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + }, + revealBy: { + label: '可揭示的令牌', + desc: '令牌層上哪些令牌會揭示六角格：由玩家控制的令牌、代表任何角色的令牌，或所有令牌。', + }, + revealMode: { + label: '揭示模式', + desc: '清除會移除視線範圍內的六角格。瞥見則改為讓六角格變得半透明；令牌進入時才將其移除。', + }, + announce: { + label: '公告發現', + desc: '當發現指定位置時誰會看到聊天訊息。', + }, + pingDiscoveries: { + label: '標示發現位置', + desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + }, + hideCoveredTokens: { + label: '隱藏被覆蓋的令牌', + desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + }, + }, + status: { + engine: '遊戲引擎', + grid: '網格', + layer: '六角格圖層', + hexes: '六角格', + named: '已命名的六角格', + icons: '地點令牌', + glimpsed: '被瞥見的六角格', + pending: '等待填充的地點', + calibrated: '已校準', + overrides: '頁面覆寫', + undo: '可撤銷', + }, + messages: { + filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', + revealed: '六角形顯示：{count}。', + revealedPage: '已揭示頁面上的所有六角格（{count}）。', + confirmReset: + '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', + resetPage: '已從頁面移除的六角格：{count}。', + undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', + named: '名為「{name}」的六角形：{count}。', + unnamed: '已清除的名稱：{count}。', + marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', + unmarked: '不再是位置的標記：{count}。', + settingChanged: '{setting} 設定為 {value}。', + rescanned: + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', + calibrated: + '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + journalRebuilt: '“{help}”和“{deck}”講義已重建。', + migrated: + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', + pruned: + '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', + readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', + }, + warnings: { + foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', + someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', + }, + errors: { + noPage: '找不到要處理的頁面。', + notHex: '此頁面不使用六角網格。', + noPolygons: '選擇一個或多個要填滿的繪製形狀。', + emptyArea: '所選區域不包含任何六角形中心。', + tooMany: '這會一次建立太多的六角形 ({count})。', + nothingToConceal: '選擇要隱藏的繪製形狀或標記。', + nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + noTokens: '首先選擇一個或多個令牌。', + noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + nothingToUndo: '沒有可撤消的填充。', + unknownCommand: '未知指令：{command}', + unknownSetting: '未知設定：{key}', + unknownPageSetting: '每頁可設定的設定：{keys}', + invalidValue: '“{value}”對於 {key} 不是有效值。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateFailed: '這些令牌不能用於校準。', + unexpected: '出了點問題：{message}', + }, + hints: { + noPage: '開啟您要處理的頁面，或選擇其中的某些內容。', + notHex: '請在頁面設定中將頁面網格設為 Hex (V) 或 Hex (H)。', + noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', + emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', + tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', + noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + unknownCommand: '鍵入 !hexploration help 以列出指令。', + unknownSetting: '輸入 !hexploration set 查看每個設定。', + calibrateNeedsTokens: + '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', + unexpected: '詳細資訊位於 API 控制台日誌中。', + }, + help: { + menu: '顯示選單。', + fill: '用六角形覆蓋選定的繪製形狀。', + fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', + undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', + reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + revealPage: '揭示頁面上的所有六角格，不發布公告。', + conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', + explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + resetPage: '移除頁面上的所有六角格（會先確認）。', + name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', + mark: '將選取的標記變成隱藏位置。', + unmark: '停止將選定的標記隱藏在位置。', + set: '更改設定或顯示所有設定。', + pageSet: '僅覆蓋目前頁面上的顯示設定。', + pageClear: '刪除目前頁面的覆蓋。', + rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', + calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrateReset: '刪除目前頁面的校準。', + status: '顯示 Hexploration 對目前頁面的了解。', + journal: '重建說明與 Command Deck 講義。', + help: '顯示此清單。', + handout: '完整說明位於「{name}」講義。', + }, + deck: { + drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', + revealDesc: + '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', + toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', + footer: '有關完整說明，請參閱“{help}”講義。', + }, + handout: { + versionLabel: '版本', + subtitle: 'Roll20 的逐格六角格探索', + footer: '使用“{deck}”講義進行一鍵式控制項。', + overview: { + heading: '概述', + body: 'Hexploration 以不透明的六角格覆蓋六角格地圖。隊伍移動時，他們經過的六角格（以及你願意的話，周圍的六角格）會被移除，讓地圖一格一格地揭開。隱藏地點可以放在六角格下方，被找到時會公告。它適用於 Jumpgate 和 Legacy 遊戲，以及任何大小的 Hex (V) 和 Hex (H) 網格。', + demo: '觀看簡短的演示（來自版本 1）', + }, + quickStart: { + heading: '快速入門', + steps: [ + '開啟網格設為 Hex (V) 或 Hex (H) 的頁面。', + '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', + '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', + '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', + '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + ], + }, + commands: { + heading: '命令', + intro: + '只有 GM 可以使用這些指令。大多數作用於選定的物件；其餘的將在您正在查看的頁面上進行操作。', + colCommand: '命令', + colDesc: '它的作用', + }, + revealing: { + heading: '揭示如何運作', + points: [ + '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', + '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', + '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', + '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', + 'Roll20 會把令牌的名稱、條和光環繪製在六角格上方。啟用「隱藏被覆蓋的令牌」後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，直到被揭開為止，讓隱藏的怪物不會暴露行蹤。若在令牌仍被覆蓋時開啟其中任何一項，它會保持隱藏，並在令牌被揭開時開啟。', + 'API 不會回報其他模組造成的移動。TokenMod 的移動會自動偵測；對於其他模組，請選取令牌並點選「探索」，或從你自己的模組呼叫 Hexploration.revealAround(token)。', + ], + }, + locations: { + heading: '命名六角形和位置', + points: [ + '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', + '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', + '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', + ], + }, + settings: { + heading: '設定', + intro: + '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', + colKey: '鑰匙', + colName: '環境', + colDesc: '描述', + perPage: '（可按頁設定。）', + }, + jumpgate: { + heading: 'Jumpgate 與 Legacy', + points: [ + 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', + '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', + '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + ], + }, + upgrading: { + heading: '從版本 1 升級', + points: [ + '版本 2 不再需要 PathMath、MatrixMath、Vector Math 或 HTML Builder。您可以刪除它們，除非另一個模組使用它們。', + '現有的六角格地圖、名稱、地點令牌與設定會在首次啟動時自動升級。', + '版本 1 的指令（包括 Hexploration_menu 巨集）仍然有效。', + '版本 1 允許任何代表角色的令牌揭示六角格。若要保留此行為，請將「可揭示的令牌」設為「角色令牌」。', + ], + colV1: '版本 1 指令', + colV2: '版本 2 指令', + }, + troubleshooting: { + heading: '故障排除', + points: [ + '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', + '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', + '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', + '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', + ], + }, + languages: { + heading: '語言', + body: '使用 !hexploration set language 選擇語言。可用語言：', + colLanguage: '語言', + colNative: '原文名稱', + colCode: '程式碼', + }, + credits: { + heading: '製作人員', + original: '原始模組由', + maintainer: '版本 2 維護者', + marketplace: 'Roll20 Marketplace 上的 Ada 藝術包', + support: + '如果您發現錯誤或有想法，請在 Roll20 Mod 論壇中發佈或在 GitHub 上提出問題，並包含 API 控制台日誌中的任何訊息。', + }, + }, + }; + + const TRANSLATION$j = { + titles: { + ready: 'Hexploration je připraven.', + settings: 'Nastavení Hexploration', + languages: 'Vyberte jazyk', + pageSettings: 'Nastavení stránky: {page}', + status: 'Stav Hexploration: {page}', + help: 'Příkazy Hexploration', + confirm: 'Potvrďte prosím', + }, + discovery: { + title: 'Místo objeveno', + }, + menu: { + draw: 'Kreslení', + reveal: 'Odhalení a skrytí', + locations: 'Místa', + tools: 'Nástroje', + layerInUse: 'Vrstva, do které se kreslí nové hexy: {layer}.', + pageSettingsHelp: + 'Tato nastavení platí pouze pro tuto stránku. Nastavení označená ★ přepíší globální nastavení.', + }, + buttons: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + undo: 'Vrátit výplň', + reveal: 'Odhalit', + conceal: 'Zakrýt', + explore: 'Prozkoumat', + revealPage: 'Odhalit stránku', + resetPage: 'Resetovat stránku', + mark: 'Označit místo', + unmark: 'Zrušit označení', + name: 'Pojmenovat hex', + settings: 'Nastavení', + pageSettings: 'Nastavení stránky', + status: 'Stav', + rescan: 'Znovu skenovat', + calibrate: 'Kalibrovat', + calibrateReset: 'Resetovat kalibraci', + help: 'Pomoc', + change: 'Změnit', + menu: 'Menu', + clearOverrides: 'Zrušit přepsání', + confirmReset: 'Ano, odebrat všechny hexy', + }, + prompts: { + name: 'Název místa (pro vymazání ponechte prázdné)', + }, + values: { + on: 'Zapnuto', + off: 'Vypnuto', + none: 'Žádné', + hexLayer: { + auto: 'Auto (popředí, pokud je k dispozici)', + foreground: 'vrstva popředí', + objects: 'vrstva žetonů', + }, + revealBy: { + players: 'Žetony hráčů', + characters: 'Žetony postav', + all: 'Všechny žetony', + }, + revealMode: { + clear: 'Odstranění', + glimpse: 'Záblesk', + }, + announce: { + all: 'Všichni', + gm: 'Pouze GM', + off: 'Vypnuto', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vyplnit', + fillInverse: 'Inverzní výplň', + conceal: 'Zakrýt', + }, + }, + settings: { + language: { + label: 'Jazyk', + desc: 'Jazyk pro nabídky, zprávy a letáky.', + }, + hexLayer: { + label: 'Vrstva šestiúhelníků', + desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', + }, + fillColor: { + label: 'Barva výplně', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Barva ohraničení', + desc: 'Barva obrysu nových hexů.', + }, + labelColor: { + label: 'Barva popisku', + desc: 'Barva jmenovek pouze GM na pojmenovaných hexech.', + }, + glimpseColor: { + label: 'Barva záblesku', + desc: 'Barva, kterou hexy získají při zahlédnutí (režim odhalování Záblesk). Použijte průhlednou barvu rgba().', + }, + strokeWidth: { + label: 'Šířka ohraničení', + desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', + }, + maxDistance: { + label: 'Vzdálenost odhalení šestiúhelníků', + desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', + }, + revealDistance: { + label: 'Vzdálenost dohledu', + desc: 'Kolik hexů kolem pohybujícího se žetonu je odhaleno (0 až 20). 0 odhaluje pouze hexy, kterými žeton prochází.', + }, + lineOfSight: { + label: 'Přímá viditelnost', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', + }, + revealPath: { + label: 'Odhalovat po cestě', + desc: 'Když je zapnuto, je odhalen každý hex, kterým žeton při tažení projde (včetně trasových bodů), nejen tam, kde se zastaví.', + }, + revealBy: { + label: 'Žetony, které odhalují', + desc: 'Které žetony na vrstvě žetonů odhalují hexy: žetony ovládané hráčem, žetony, které představují jakoukoli postavu, nebo každý žeton.', + }, + revealMode: { + label: 'Režim odhalování', + desc: 'Odstranění odstraní hexy v dohledu. Záblesk je místo toho zprůhlední; odstraní se, když do nich vstoupí žeton.', + }, + announce: { + label: 'Oznamovat objevy', + desc: 'Kdo uvidí chatovou zprávu, když je objeveno pojmenované místo.', + }, + pingDiscoveries: { + label: 'Pingnout objevy', + desc: 'Když je zapnuto, hráči jsou pingnuti na pojmenované místo, když je objeveno.', + }, + hideCoveredTokens: { + label: 'Skrýt zakryté žetony', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + }, + }, + status: { + engine: 'Herní engine', + grid: 'Mřížka', + layer: 'Vrstva hexů', + hexes: 'Hexy', + named: 'Pojmenované hexy', + icons: 'Žetony míst', + glimpsed: 'Zahlédnuté hexy', + pending: 'Místa čekající na výplň', + calibrated: 'Zkalibrováno', + overrides: 'Přepsání stránky', + undo: 'Lze vrátit zpět', + }, + messages: { + filled: + 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + revealed: 'Odhalené hexy: {count}.', + revealedPage: 'Každé odhalené hex na stránce ({count}).', + confirmReset: + 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + resetPage: 'Ze stránky byly odstraněny hexy: {count}.', + undone: + 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', + named: 'Hexusy s názvem „{name}“: {count}.', + unnamed: 'Jména vymazána: {count}.', + marked: + 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', + unmarked: 'Tokeny, které již nejsou umístěními: {count}.', + settingChanged: '{setting} nastaveno na {value}.', + rescanned: + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', + calibrated: + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', + calibrationReset: + 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', + migrated: + 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', + pruned: + 'Uložené hexy, které již neexistují a byly zapomenuty: {dropped}. Pokud byla tato hra nebo stránka zkopírována, spusťte na stránce Znovu skenovat, aby se její hexy znovu načetly.', + readyHint: + 'Zadejte !hexploration pro otevření nabídky nebo otevřete leták "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', + someFailed: + 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', + }, + errors: { + noPage: 'Nelze najít stránku, na které by se dalo pracovat.', + notHex: 'Tato stránka nepoužívá hexovou mřížku.', + noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', + nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', + nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', + noTokens: 'Nejprve vyberte jeden nebo více žetonů.', + noHexes: 'Nejprve vyberte jeden nebo více hexů (nebo žetonů stojících na hexech).', + nothingToUndo: 'Neexistuje žádná výplň, kterou lze vrátit zpět.', + unknownCommand: 'Neznámý příkaz: {command}', + unknownSetting: 'Neznámé nastavení: {key}', + unknownPageSetting: 'Nastavení, která lze nastavit na stránce: {keys}', + invalidValue: '„{value}“ není platná hodnota pro {key}.', + calibrateNeedsTokens: 'Vyberte jeden nebo dva žetony přichycené na středy hexů.', + calibrateFailed: 'Tyto tokeny nelze použít ke kalibraci.', + unexpected: 'Něco se pokazilo: {message}', + }, + hints: { + noPage: 'Otevřete stránku, na které chcete pracovat, nebo na ní něco vyberte.', + notHex: 'Nastavte mřížku stránky na Hex (V) nebo Hex (H) v Nastavení stránky.', + noPolygons: + 'Nakreslete kolem oblasti mnohoúhelník, obdélník, elipsu nebo tvar od ruky, vyberte jej a zkuste to znovu.', + emptyArea: 'Nakreslete větší tvar nebo zkontrolujte nastavení mřížky stránky.', + tooMany: 'Vyplňte menší oblast nebo oblast rozdělte do několika tvarů.', + noHexes: 'Hexy jsou na popředí nebo vrstvě tokenů; přepněte na tuto vrstvu a vyberte je.', + unknownCommand: 'Chcete-li zobrazit seznam příkazů, zadejte !hexploration help.', + unknownSetting: 'Chcete-li zobrazit všechna nastavení, zadejte !hexploration set.', + calibrateNeedsTokens: + 'Přichyťte žeton do středu hexu a vyberte jej. Vyberte druhý žeton přichycený na sousední hex ve stejném řádku (Hex V) nebo sloupci (Hex H), abyste také opravili velikost hexu.', + calibrateFailed: + 'Dva žetony musí být ve stejném řádku (Hex V) nebo stejném sloupci (Hex H), alespoň jeden hex od sebe.', + unexpected: 'Podrobnosti jsou v protokolu konzoly API.', + }, + help: { + menu: 'Ukaž menu.', + fill: 'Zakryjte vybrané nakreslené tvary hexy.', + fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', + undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', + reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', + revealPage: 'Odhalte každé hex na stránce bez oznámení.', + conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', + explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', + resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', + name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', + mark: 'Proměňte vybrané žetony na skrytá místa.', + unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + set: 'Změňte nastavení nebo zobrazte všechna nastavení.', + pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', + pageClear: 'Odstraňte přepsání aktuální stránky.', + rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + calibrate: + 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', + calibrateReset: 'Odstraňte kalibraci aktuální stránky.', + status: 'Zobrazit, co Hexploration ví o aktuální stránce.', + journal: 'Znovu vytvořte letáky „Pomoc“ a „Command Deck“.', + help: 'Zobrazit tento seznam.', + handout: 'Úplné pokyny jsou v letáku „{name}“.', + }, + deck: { + drawDesc: + 'Nakreslete tvary kolem oblasti, vyberte je a poté vyplňte. Zpět vrátí poslední výplň zpět.', + revealDesc: + 'Vyberte hexy, tvary nebo žetony, abyste je odhalili nebo znovu zakryli. Prozkoumat odhalí okolí vybraných žetonů, jako by se pohnuly.', + locationsDesc: + 'Vyberte žetony a skryjte je jako místa pod hexy. Vyberte hexy nebo žetony a pojmenujte hex.', + toolsDesc: + 'Nastavení, přepsání stránek, stav, opětovné skenování zkopírovaných stránek a kalibrace mřížky.', + footer: 'Úplné pokyny naleznete v letáku „{help}“.', + }, + handout: { + versionLabel: 'Verze', + subtitle: 'Průzkum hex po hexu pro Roll20', + footer: 'Pro ovládání jedním kliknutím použijte leták „{deck}“.', + overview: { + heading: 'Přehled', + body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', + demo: 'Podívejte se na krátkou ukázku (od verze 1)', + }, + quickStart: { + heading: 'Rychlý start', + steps: [ + 'Otevřete stránku, jejíž mřížka je nastavena na Hex (V) nebo Hex (H).', + 'Nakreslete jeden nebo více tvarů (mnohoúhelník, obdélník, elipsa nebo od ruky) kolem oblasti, kterou chcete skrýt.', + 'Vyberte tvary a v Command Deck klikněte na Vyplnit (nebo zadejte !hexploration fill). Tvary se nahradí hexy.', + 'Volitelné: před vyplněním vyberte žetony pro důležitá místa a klikněte na Označit místo. Jsou ukryty pod hexy a oznámeny, když jsou objeveny.', + 'Přesuňte žeton hráče. Každý hex, kterým projde, a hexy v jeho Vzdálenosti dohledu jsou odhaleny.', + ], + }, + commands: { + heading: 'Příkazy', + intro: + 'Tyto příkazy mohou používat pouze GM. Většina působí na vybrané objekty; zbytek působí na stránce, kterou si prohlížíte.', + colCommand: 'Příkaz', + colDesc: 'Co to dělá', + }, + revealing: { + heading: 'Jak funguje odhalování', + points: [ + 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', + 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', + 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', + 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', + 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', + ], + }, + locations: { + heading: 'Pojmenované hexy a umístění', + points: [ + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', + 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', + 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', + ], + }, + settings: { + heading: 'Nastavení', + intro: + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', + colKey: 'Klíč', + colName: 'Nastavení', + colDesc: 'Popis', + perPage: '(Lze nastavit na stránku.)', + }, + jumpgate: { + heading: 'Jumpgate a Legacy', + points: [ + 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', + 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', + 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', + ], + }, + upgrading: { + heading: 'Upgrade z verze 1', + points: [ + 'Verze 2 již nepotřebuje PathMath, MatrixMath, Vector Math nebo HTML Builder. Můžete je odstranit, pokud je nepoužívá jiný mod.', + 'Stávající hexové mapy, názvy, tokeny lokací a nastavení se při prvním spuštění automaticky aktualizují.', + 'Příkazy verze 1, včetně makra Hexploration_menu, stále fungují.', + 'Verze 1 umožňovala odhalovat hexy každému žetonu, který představoval postavu. Chcete-li toto chování zachovat, nastavte Žetony, které odhalují, na Žetony postav.', + ], + colV1: 'Příkaz verze 1', + colV2: 'Příkaz verze 2', + }, + troubleshooting: { + heading: 'Odstraňování problémů', + points: [ + 'Když se žeton pohne, nic se nestane: zkontrolujte, zda je žeton na vrstvě žetonů a odpovídá nastavení Žetony, které odhalují, a zda stránka obsahuje hexy (!hexploration status).', + 'Hexy jsou odsazeny od mřížky: použijte Kalibrovat a poté zkontrolujte pomocí žetonu několik hexů po mapě.', + 'Po zkopírování stránky nebo hry se hexy přestaly odhalovat: spusťte na stránce Znovu skenovat.', + 'Vyplnit hlásí, že oblast neobsahuje žádné středy hexů: tvar musí obsahovat střed alespoň jednoho hexu.', + 'Pro cokoli jiného zkontrolujte protokol konzoly API a při žádosti o pomoc zahrňte jeho zprávy.', + ], + }, + languages: { + heading: 'Jazyky', + body: 'Jazyk vyberte příkazem !hexploration set language. Dostupné jazyky:', + colLanguage: 'Jazyk', + colNative: 'Vlastní název', + colCode: 'Kód', + }, + credits: { + heading: 'Kredity', + original: 'Původní mod od', + maintainer: 'Verze 2 spravovaná společností', + marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', + support: + 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', + }, + }, + }; + + const TRANSLATION$i = { + titles: { + ready: 'Hexploration er klar.', + settings: 'Indstillinger for Hexploration', + languages: 'Vælg et sprog', + pageSettings: 'Sideindstillinger: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandoer', + confirm: 'Bekræft venligst', + }, + discovery: { + title: 'Sted opdaget', + }, + menu: { + draw: 'Tegn', + reveal: 'Afslør og skjul', + locations: 'Steder', + tools: 'Værktøjer', + layerInUse: 'Nye hexfelter tegnes på {layer}.', + pageSettingsHelp: + 'Disse indstillinger gælder kun for denne side. Indstillinger markeret ★ tilsidesætter de globale indstillinger.', + }, + buttons: { + fill: 'Fyld', + fillInverse: 'Omvendt fyld', + undo: 'Fortryd fyld', + reveal: 'Afslør', + conceal: 'Skjul', + explore: 'Udforsk', + revealPage: 'Afslør side', + resetPage: 'Nulstil side', + mark: 'Marker sted', + unmark: 'Fjern markering', + name: 'Navngiv hexfelt', + settings: 'Indstillinger', + pageSettings: 'Sideindstillinger', + status: 'Status', + rescan: 'Scan igen', + calibrate: 'Kalibrer', + calibrateReset: 'Nulstil kalibrering', + help: 'Hjælp', + change: 'Skift', + menu: 'Menu', + clearOverrides: 'Ryd tilsidesættelser', + confirmReset: 'Ja, fjern alle hexfelter', + }, + prompts: { + name: 'Stednavn (lad feltet være tomt for at rydde)', + }, + values: { + on: 'Til', + off: 'Fra', + none: 'Ingen', + hexLayer: { + auto: 'Auto (forgrund, hvis tilgængelig)', + foreground: 'forgrundslaget', + objects: 'tokenlaget', + }, + revealBy: { + players: 'Spillertokens', + characters: 'Karaktertokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Fjern', + glimpse: 'Glimt', + }, + announce: { + all: 'Alle', + gm: 'Kun GM', + off: 'Fra', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fyld', + fillInverse: 'Omvendt fyld', + conceal: 'Skjul', + }, + }, + settings: { + language: { + label: 'Sprog', + desc: 'Sprog til menuer, beskeder og uddelingskopier.', + }, + hexLayer: { + label: 'Lag for hexfelter', + desc: 'Hvor nye hexfelter tegnes. Auto prøver forgrundslaget (over tokens) og falder tilbage til tokenlaget, hvis spillet ikke understøtter det.', + }, + fillColor: { + label: 'Fyldfarve', + desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfarve', + desc: 'Farve på omridset af nye sekskanter.', + }, + labelColor: { + label: 'Etiketfarve', + desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + }, + glimpseColor: { + label: 'Glimtfarve', + desc: 'Den farve, hexfelter skifter til, når de skimtes (afsløringstilstanden Glimt). Brug en gennemsigtig rgba()-farve.', + }, + strokeWidth: { + label: 'Kantbredde', + desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + }, + maxDistance: { + label: 'Afsløringsafstand for hexfelter', + desc: 'Gemmes på hexfelterne, når de udfyldes, så indstil den før udfyldning: Ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se; med 0 afsløres de kun ved at gå ind i dem. Brug den til bjerge eller skove. Lad feltet stå tomt for ingen grænse.', + }, + revealDistance: { + label: 'Synsafstand', + desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + }, + lineOfSight: { + label: 'Synslinje', + desc: 'Når den er slået til, skjuler hexfelter, der forbliver dækket, såsom bjerge udfyldt med en Afsløringsafstand for hexfelter, hexfelterne bag dem. Den gør kun en forskel med en Synsafstand på 2 eller mere.', + }, + revealPath: { + label: 'Afslør langs ruten', + desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + }, + revealBy: { + label: 'Afslørende tokens', + desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + }, + revealMode: { + label: 'Afsløringstilstand', + desc: 'Fjern fjerner hexfelter inden for synsvidde. Glimt gør dem i stedet gennemsigtige; de fjernes, når et token går ind i dem.', + }, + announce: { + label: 'Annoncer opdagelser', + desc: 'Hvem ser chatbeskeden, når en navngivet placering opdages.', + }, + pingDiscoveries: { + label: 'Ping opdagelser', + desc: 'Når den er aktiveret, bliver spillere pinget til en navngiven placering, når den opdages.', + }, + hideCoveredTokens: { + label: 'Skjul dækkede tokens', + desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + }, + }, + status: { + engine: 'Spilmotor', + grid: 'Gitter', + layer: 'Lag for hexfelter', + hexes: 'Hexfelter', + named: 'Navngivne hexfelter', + icons: 'Stedtokens', + glimpsed: 'Gennemsigtige hexfelter', + pending: 'Steder, der venter på fyld', + calibrated: 'Kalibreret', + overrides: 'Sidetilsidesættelser', + undo: 'Fortryd tilgængelig', + }, + messages: { + filled: + 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexer afsløret: {count}.', + revealedPage: 'Hver hex på siden afsløret ({count}).', + confirmReset: + 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexer fjernet fra siden: {count}.', + undone: + 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', + named: 'Hexer med navnet "{name}": {count}.', + unnamed: 'Navne ryddet: {count}.', + marked: + 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + unmarked: 'Tokens, der ikke længere er placeringer: {count}.', + settingChanged: '{setting} indstillet til {value}.', + rescanned: + 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', + calibrated: + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', + calibrationReset: + 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', + migrated: + 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', + pruned: + 'Gemte hexfelter, der ikke længere findes og er blevet glemt: {dropped}. Hvis dette spil eller denne side blev kopieret, skal du køre Scan igen på siden for at finde dens hexfelter igen.', + readyHint: + 'Skriv !hexploration for at åbne menuen, eller åbn uddelingsarket "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', + someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', + }, + errors: { + noPage: 'Kunne ikke finde siden at arbejde på.', + notHex: 'Denne side bruger ikke et hex-gitter.', + noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', + emptyArea: 'Det valgte område indeholder ingen hex-centre.', + tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', + nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + noTokens: 'Vælg først et eller flere tokens.', + noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + nothingToUndo: 'Der er ingen udfyldning at fortryde.', + unknownCommand: 'Ukendt kommando: {command}', + unknownSetting: 'Ukendt indstilling: {key}', + unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', + invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', + unexpected: 'Noget gik galt: {message}', + }, + hints: { + noPage: 'Åbn den side, du vil arbejde på, eller vælg noget på den.', + notHex: 'Indstil sidegitteret til Hex (V) eller Hex (H) i Sideindstillinger.', + noPolygons: + 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', + emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', + tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', + noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', + unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', + calibrateNeedsTokens: + 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + calibrateFailed: + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + unexpected: 'Detaljer er i API-konsolloggen.', + }, + help: { + menu: 'Vis menuen.', + fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', + undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', + reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', + revealPage: 'Afslør hver hex på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', + resetPage: 'Fjern hver hex på siden (spørg først).', + name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + mark: 'Gør de valgte tokens til skjulte placeringer.', + unmark: 'Stop de valgte tokens med at være skjulte placeringer.', + set: 'Skift en indstilling, eller vis alle indstillinger.', + pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', + pageClear: 'Fjern den aktuelle sides tilsidesættelser.', + rescan: + 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + calibrate: + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + calibrateReset: 'Fjern den aktuelle sides kalibrering.', + status: 'Vis, hvad Hexploration ved om den aktuelle side.', + journal: 'Genopbyg uddelingsarkene Help og Command Deck.', + help: 'Vis denne liste.', + handout: 'Fuldstændige instruktioner findes i "{name}" uddelingsark.', + }, + deck: { + drawDesc: + 'Tegn figurer rundt om et område, vælg dem, og fyld derefter. Fortryd fyld annullerer den sidste fyldning.', + revealDesc: + 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', + locationsDesc: + 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + toolsDesc: + 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', + footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-udforskning for Roll20', + footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', + overview: { + heading: 'Oversigt', + body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + demo: 'Se en kort demo (fra version 1)', + }, + quickStart: { + heading: 'Hurtig start', + steps: [ + 'Åbn en side, hvis gitter er indstillet til Hex (V) eller Hex (H).', + 'Tegn en eller flere figurer (polygon, rektangel, ellipse eller frihånd) rundt om området for at skjule.', + 'Vælg figurerne, og klik på Fyld i Command Deck (eller skriv !hexploration fill). Figurerne erstattes af hexfelter.', + 'Valgfrit: Før du fylder, kan du vælge tokens for vigtige steder og klikke på Marker sted. De skjules under hexfelterne og annonceres, når de opdages.', + 'Flyt et spillertoken. Hvert hexfelt, det passerer igennem, og hexfelterne inden for dets Synsafstand afsløres.', + ], + }, + commands: { + heading: 'Kommandoer', + intro: + "Kun GM'er kan bruge disse kommandoer. De fleste handler på de valgte objekter; resten handler på den side, du ser.", + colCommand: 'Kommando', + colDesc: 'Hvad den gør', + }, + revealing: { + heading: 'Sådan fungerer afsløring', + points: [ + 'Kun tokens på tokenlaget afslører hexfelter. Hvilke tokens der tæller, bestemmes af Afslørende tokens: som standard spillertokens, så GM kan flytte monstre uden at afdække kortet.', + 'Et token afslører hvert hexfelt, det dækker (store tokens dækker flere), og med Afslør langs ruten slået til hvert hexfelt på den rute, det blev trukket langs, inklusive mellempunkter.', + 'Synsafstand afslører hexfelterne omkring hvert af disse hexfelter, de nærmeste først. Med Synslinje slået til afsløres et hexfelt ikke, så længe der ligger et dækket hexfelt mellem det og tokenet. Nærmere hexfelter afsløres som regel først, så i åbent terræn ændrer Synslinje intet: Den har kun betydning med en Synsafstand på 2 eller mere og hexfelter, der forbliver dækket, såsom terræn udfyldt med en Afsløringsafstand for hexfelter.', + 'Afsløringsafstand for hexfelter gemmes på hvert hexfelt, når det udfyldes, så indstil den før udfyldning; ændres den senere, påvirker det ikke hexfelter, der allerede er på kortet. Et token skal være inden for så mange hexfelter for at afsløre dem, uanset hvor langt det kan se, og med 0 afsløres de kun ved at gå ind i dem. Til en bjergkæde: Sæt Afsløringsafstand for hexfelter til 0, udfyld bjergene, sæt den tilbage til ingen, og udfyld derefter landet bagved. Med Synsafstand 3 og Synslinje slået til ser gruppen det åbne terræn omkring sig, men ikke bjergene eller det, der ligger bag dem. Hvert bjerghexfelt afsløres, når et token går ind i det.', + 'I tilstanden Glimt bliver hexfelter inden for synsvidde gennemsigtige i stedet for at forsvinde og fjernes, når et token går ind i dem. Gennemsigtige Glimt-hexfelter blokerer ikke Synslinje.', + 'Roll20 tegner tokennavne, bjælker og auraer oven over hexfelterne. Med Skjul dækkede tokens slået til får et token under et dækket hexfelt sit navn, sine bjælker og auraer, som spillerne kan se, slået fra, indtil det afdækkes, så skjulte monstre ikke afslører sig selv. Hvis du slår en af dem til, mens tokenet er dækket, forbliver den skjult og slås til, når tokenet afdækkes.', + 'API’en rapporterer ikke flytninger foretaget af andre mods. Flytninger med TokenMod opfanges automatisk; for andre mods skal du vælge tokens og klikke på Udforsk eller kalde Hexploration.revealAround(token) fra din egen mod.', + ], + }, + locations: { + heading: 'Navngivne Hekser og Steder', + points: [ + 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', + 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', + 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', + ], + }, + settings: { + heading: 'Indstillinger', + intro: + 'Skift indstillinger med !hexploration set (eller knappen Indstillinger). Lag for hexfelter, Afslørende tokens og Sprog kan også indstilles på modens indstillingsside.', + colKey: 'Nøgle', + colName: 'Indstilling', + colDesc: 'Beskrivelse', + perPage: '(Kan indstilles pr. side.)', + }, + jumpgate: { + heading: 'Jumpgate og Legacy', + points: [ + 'Hexploration finder ud af, hvilken motor spillet bruger, og tegner den matchende form. Figurer tegnet i begge editorer kan udfyldes.', + 'Når Lag for hexfelter er sat til Auto, tegnes hexfelter på forgrundslaget over tokens, så spillerne ikke kan se, hvad der er nedenunder. Hvis forgrundslaget ikke er tilgængeligt, bruges tokenlaget i stedet.', + 'Jumpgate tegner matematisk regulære hexfelter, som har en lidt anden form end Legacy-hexfelter. Hvis hexfelterne ikke flugter med en sides gitter, så fastgør et token til midten af et hexfelt, vælg det, og klik på Kalibrer. Vælg to tokens i nabohexfelter i samme række (Hex V) eller kolonne (Hex H) for også at rette hexfeltstørrelsen.', + 'Når en side eller et spil kopieres, får hexfelterne nye id’er. Kør Scan igen på siden for at finde dem igen sammen med deres navneetiketter og stedtokens.', + ], + }, + upgrading: { + heading: 'Opgradering fra version 1', + points: [ + 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', + 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', + 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', + ], + colV1: 'Version 1 kommando', + colV2: 'Version 2 kommando', + }, + troubleshooting: { + heading: 'Fejlfinding', + points: [ + 'Der sker ikke noget, når et token flytter sig: Kontroller, at tokenet ligger på tokenlaget og matcher Afslørende tokens, og at siden har hexfelter (!hexploration status).', + 'Hexfelterne er forskudt i forhold til gitteret: Brug Kalibrer, og kontroller derefter med et token på nogle få hexfelter rundt om på kortet.', + 'Hexfelterne holdt op med at blive afsløret efter kopiering af en side eller et spil: Kør Scan igen på siden.', + 'Fyld siger, at området ikke har nogen hexfeltcentre: Figuren skal indeholde midten af mindst ét hexfelt.', + 'For alt andet skal du tjekke API-konsolloggen og inkludere dens meddelelser, når du beder om hjælp.', + ], + }, + languages: { + heading: 'Sprog', + body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + colLanguage: 'Sprog', + colNative: 'Eget navn', + colCode: 'Kode', + }, + credits: { + heading: 'Kreditter', + original: 'Original mod af', + maintainer: 'Version 2 vedligeholdes af', + marketplace: 'Adas kunstpakker på Roll20 Marketplace', + support: + 'Hvis du finder en fejl eller har en idé, skal du skrive i Roll20 Mod-forummet eller åbne et problem på GitHub og inkludere eventuelle meddelelser fra API-konsollens log.', + }, + }, + }; + + const TRANSLATION$h = { + titles: { + ready: 'Hexploration is klaar.', + settings: 'Hexploration-instellingen', + languages: 'Kies een taal', + pageSettings: 'Pagina-instellingen: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-opdrachten', + confirm: 'Bevestig alstublieft', + }, + discovery: { + title: 'Locatie ontdekt', + }, + menu: { + draw: 'Tekenen', + reveal: 'Onthullen en verbergen', + locations: 'Locaties', + tools: 'Hulpmiddelen', + layerInUse: 'Nieuwe zeshoeken worden getekend op de {layer}.', + pageSettingsHelp: + 'Deze instellingen zijn alleen van toepassing op deze pagina. Instellingen gemarkeerd met ★ overschrijven de algemene instellingen.', + }, + buttons: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + undo: 'Vulling ongedaan maken', + reveal: 'Onthullen', + conceal: 'Verbergen', + explore: 'Verkennen', + revealPage: 'Pagina onthullen', + resetPage: 'Pagina opnieuw instellen', + mark: 'Locatie markeren', + unmark: 'Markering opheffen', + name: 'Zeshoek benoemen', + settings: 'Instellingen', + pageSettings: 'Pagina-instellingen', + status: 'Status', + rescan: 'Opnieuw scannen', + calibrate: 'Kalibreren', + calibrateReset: 'Kalibratie opnieuw instellen', + help: 'Help', + change: 'Wijzigen', + menu: 'Menu', + clearOverrides: 'Overschrijvingen wissen', + confirmReset: 'Ja, verwijder alle zeshoeken', + }, + prompts: { + name: 'Locatienaam (leeg laten om te wissen)', + }, + values: { + on: 'Aan', + off: 'Uit', + none: 'Geen', + hexLayer: { + auto: 'Automatisch (voorgrond indien beschikbaar)', + foreground: 'voorgrondlaag', + objects: 'tokenlaag', + }, + revealBy: { + players: 'Spelertokens', + characters: 'Personagetokens', + all: 'Alle tokens', + }, + revealMode: { + clear: 'Wissen', + glimpse: 'Glimp', + }, + announce: { + all: 'Iedereen', + gm: 'Alleen GM', + off: 'Uit', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Vullen', + fillInverse: 'Omgekeerde vulling', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Taal', + desc: "Taal voor menu's, berichten en hand-outs.", + }, + hexLayer: { + label: 'Laag voor zeshoeken', + desc: 'Waar nieuwe zeshoeken worden getekend. Automatisch probeert de voorgrondlaag (boven tokens) en valt terug op de tokenlaag als het spel die niet ondersteunt.', + }, + fillColor: { + label: 'Vulkleur', + desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randkleur', + desc: 'Kleur van de omtrek van nieuwe vakjes.', + }, + labelColor: { + label: 'Labelkleur', + desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + }, + glimpseColor: { + label: 'Glimpkleur', + desc: 'Kleur die zeshoeken krijgen wanneer er een glimp van wordt opgevangen (onthullingsmodus Glimp). Gebruik een doorzichtige rgba()-kleur.', + }, + strokeWidth: { + label: 'Randbreedte', + desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + }, + maxDistance: { + label: 'Onthullingsafstand van zeshoeken', + desc: 'Wordt bij het vullen in de zeshoeken opgeslagen, dus stel dit in vóór het vullen: later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken; bij 0 worden ze alleen onthuld door ze te betreden. Gebruik dit voor bergen of bossen. Laat leeg voor geen limiet.', + }, + revealDistance: { + label: 'Zichtafstand', + desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + }, + lineOfSight: { + label: 'Zichtlijn', + desc: 'Wanneer deze optie aan staat, verbergen zeshoeken die bedekt blijven, zoals bergen die zijn gevuld met een Onthullingsafstand van zeshoeken, de zeshoeken erachter. Het maakt alleen verschil bij een Zichtafstand van 2 of meer.', + }, + revealPath: { + label: 'Onthullen langs pad', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + }, + revealBy: { + label: 'Tokens die onthullen', + desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + }, + revealMode: { + label: 'Onthullingsmodus', + desc: 'Wissen verwijdert zeshoeken binnen het zicht. Glimp maakt ze in plaats daarvan doorzichtig; ze worden verwijderd wanneer een token ze betreedt.', + }, + announce: { + label: 'Ontdekkingen aankondigen', + desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + }, + pingDiscoveries: { + label: 'Ontdekkingen pingen', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + }, + hideCoveredTokens: { + label: 'Bedekte tokens verbergen', + desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + }, + }, + status: { + engine: 'Game-engine', + grid: 'Rooster', + layer: 'Laag voor zeshoeken', + hexes: 'Zeshoeken', + named: 'Benoemde zeshoeken', + icons: 'Locatietokens', + glimpsed: 'Doorzichtige zeshoeken', + pending: 'Locaties die op een vulling wachten', + calibrated: 'Gekalibreerd', + overrides: 'Pagina-overschrijvingen', + undo: 'Ongedaan maken beschikbaar', + }, + messages: { + filled: + 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Hexen onthuld: {count}.', + revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + confirmReset: + 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Hexes verwijderd van de pagina: {count}.', + undone: + 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', + named: 'Hexen met de naam "{name}": {count}.', + unnamed: 'Namen gewist: {count}.', + marked: + 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + unmarked: 'Tokens die niet langer locaties zijn: {count}.', + settingChanged: '{setting} ingesteld op {value}.', + rescanned: + 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + calibrated: + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + calibrationReset: + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', + migrated: + 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', + pruned: + 'Opgeslagen zeshoeken die niet meer bestaan en zijn vergeten: {dropped}. Als dit spel of deze pagina is gekopieerd, voer dan Opnieuw scannen uit op de pagina om de zeshoeken weer op te pikken.', + readyHint: + 'Typ !hexploration voor het menu, of open de hand-out "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + someFailed: + 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + }, + errors: { + noPage: 'Kon de pagina niet vinden om aan te werken.', + notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', + noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', + emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', + tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', + nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + noTokens: 'Selecteer eerst een of meer tokens.', + noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', + unknownCommand: 'Onbekend commando: {command}', + unknownSetting: 'Onbekende instelling: {key}', + unknownPageSetting: 'Instellingen die per pagina kunnen worden ingesteld: {keys}', + invalidValue: '"{value}" is geen geldige waarde voor {key}.', + calibrateNeedsTokens: + 'Selecteer een of twee tokens die op de middelpunten van de zeshoeken zijn vastgemaakt.', + calibrateFailed: 'Deze tokens kunnen niet worden gebruikt om te kalibreren.', + unexpected: 'Er is iets misgegaan: {message}', + }, + hints: { + noPage: 'Open de pagina waaraan u wilt werken of selecteer er iets op.', + notHex: 'Stel het paginaraster in op Hex (V) of Hex (H) in Pagina-instellingen.', + noPolygons: + 'Teken een veelhoek, rechthoek, ellips of vorm uit de vrije hand rond het gebied, selecteer het en probeer het opnieuw.', + emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', + tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', + noHexes: + 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', + unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', + calibrateNeedsTokens: + 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + calibrateFailed: + 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', + unexpected: 'Details staan ​​in het API-consolelogboek.', + }, + help: { + menu: 'Laat de menukaart zien.', + fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', + undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + reveal: + 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', + revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', + explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', + resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', + name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + mark: 'Verander de geselecteerde tokens in verborgen locaties.', + unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', + set: 'Wijzig een instelling of toon alle instellingen.', + pageSet: 'Overschrijf een instelling voor onthullen alleen op de huidige pagina.', + pageClear: 'Verwijder de overschrijvingen van de huidige pagina.', + rescan: + 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', + calibrate: + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', + calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', + status: 'Laat zien wat Hexploration weet over de huidige pagina.', + journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', + help: 'Laat deze lijst zien.', + handout: 'Volledige instructies vindt u in de hand-out "{name}".', + }, + deck: { + drawDesc: + 'Teken vormen rond een gebied, selecteer ze en vul ze dan. Vulling ongedaan maken draait de laatste vulling terug.', + revealDesc: + 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', + locationsDesc: + 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + toolsDesc: + "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", + footer: 'Zie de hand-out "{help}" voor volledige instructies.', + }, + handout: { + versionLabel: 'Versie', + subtitle: 'Hex-voor-hex verkenning voor Roll20', + footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', + overview: { + heading: 'Overzicht', + body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + demo: 'Bekijk een korte demo (vanaf versie 1)', + }, + quickStart: { + heading: 'Snel beginnen', + steps: [ + 'Open een pagina waarvan het raster is ingesteld op Hex (V) of Hex (H).', + 'Teken een of meer vormen (veelhoek, rechthoek, ellips of uit de vrije hand) rond het gebied dat u wilt verbergen.', + 'Selecteer de vormen en klik in het Command Deck op Vullen (of typ !hexploration fill). De vormen worden vervangen door zeshoeken.', + 'Optioneel: selecteer vóór het vullen tokens voor belangrijke plaatsen en klik op Locatie markeren. Ze worden verborgen onder de zeshoeken en aangekondigd wanneer ze worden ontdekt.', + 'Verplaats een spelertoken. Elke zeshoek waar het doorheen gaat, en de zeshoeken binnen zijn Zichtafstand, worden onthuld.', + ], + }, + commands: { + heading: "Commando's", + intro: + "Alleen GM's kunnen deze commando's gebruiken. De meeste werken op de geselecteerde objecten; de rest handelt op de pagina die u bekijkt.", + colCommand: 'Commando', + colDesc: 'Wat het doet', + }, + revealing: { + heading: 'Hoe onthullen werkt', + points: [ + 'Alleen tokens op de tokenlaag onthullen zeshoeken. Welke tokens meetellen, bepaalt Tokens die onthullen: standaard spelertokens, zodat de GM monsters kan verplaatsen zonder de kaart bloot te leggen.', + 'Een token onthult elke zeshoek die het bedekt (grote tokens bedekken er meerdere) en, als Onthullen langs pad aan staat, elke zeshoek op de route waarlangs het is gesleept, inclusief tussenpunten.', + 'Zichtafstand onthult de zeshoeken rond elk van die zeshoeken, de dichtstbijzijnde eerst. Als Zichtlijn aan staat, wordt een zeshoek niet onthuld zolang er een bedekte zeshoek tussen die zeshoek en het token ligt. Dichterbij gelegen zeshoeken worden meestal eerst onthuld, dus in open terrein verandert Zichtlijn niets: het telt alleen bij een Zichtafstand van 2 of meer en zeshoeken die bedekt blijven, zoals terrein dat is gevuld met een Onthullingsafstand van zeshoeken.', + 'Onthullingsafstand van zeshoeken wordt bij het vullen in elke zeshoek opgeslagen, dus stel dit in vóór het vullen; later wijzigen heeft geen effect op zeshoeken die al op de kaart staan. Een token moet zich binnen zoveel zeshoeken bevinden om ze te onthullen, hoe ver het ook kan kijken, en bij 0 worden ze alleen onthuld door ze te betreden. Voor een bergketen: stel Onthullingsafstand van zeshoeken in op 0, vul de bergen, zet de waarde terug op geen en vul daarna het land erachter. Met Zichtafstand 3 en Zichtlijn aan ziet de groep het open terrein om zich heen, maar niet de bergen of wat erachter ligt. Elke bergzeshoek wordt onthuld wanneer een token erin stapt.', + 'In de modus Glimp worden zeshoeken binnen het zicht doorzichtig in plaats van te verdwijnen, en ze worden verwijderd wanneer een token ze betreedt. Doorzichtige Glimp-zeshoeken blokkeren de Zichtlijn niet.', + 'Roll20 tekent tokennamen, balken en aura’s boven de zeshoeken. Als Bedekte tokens verbergen aan staat, worden bij een token onder een bedekte zeshoek de voor spelers zichtbare naam, balken en aura’s uitgeschakeld totdat het wordt onthuld, zodat verborgen monsters zichzelf niet verraden. Als u een ervan inschakelt terwijl het token bedekt is, blijft het verborgen en wordt het ingeschakeld zodra het token wordt onthuld.', + 'De API meldt geen verplaatsingen door andere mods. Verplaatsingen door TokenMod worden automatisch opgepikt; voor andere mods selecteert u de tokens en klikt u op Verkennen, of roept u Hexploration.revealAround(token) aan vanuit uw eigen mod.', + ], + }, + locations: { + heading: 'Genoemde velden en locaties', + points: [ + 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', + 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', + 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', + 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', + ], + }, + settings: { + heading: 'Instellingen', + intro: + 'Wijzig de instellingen met !hexploration set (of de knop Instellingen). Laag voor zeshoeken, Tokens die onthullen en Taal kunnen ook worden ingesteld op de instellingenpagina van de mod.', + colKey: 'Sleutel', + colName: 'Instelling', + colDesc: 'Beschrijving', + perPage: '(Kan per pagina worden ingesteld.)', + }, + jumpgate: { + heading: 'Jumpgate en erfenis', + points: [ + 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', + 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', + 'Jumpgate tekent wiskundig regelmatige zeshoeken, die een iets andere vorm hebben dan Legacy-zeshoeken. Als de zeshoeken niet samenvallen met het raster van een pagina, zet dan een token vast op het midden van een zeshoek, selecteer het en klik op Kalibreren. Selecteer twee tokens in aangrenzende zeshoeken van dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', + 'Wanneer een pagina of spel wordt gekopieerd, krijgen de zeshoeken nieuwe ID’s. Voer Opnieuw scannen uit op de pagina om ze weer op te pikken, samen met hun naamlabels en locatietokens.', + ], + }, + upgrading: { + heading: 'Upgraden vanaf versie 1', + points: [ + 'Versie 2 heeft niet langer PathMath, MatrixMath, Vector Math of HTML Builder nodig. Je kunt ze verwijderen, tenzij een andere mod ze gebruikt.', + 'Bestaande hexkaarten, namen, locatietokens en instellingen worden bij de eerste start automatisch bijgewerkt.', + 'De opdrachten van versie 1, inclusief de macro Hexploration_menu, werken nog steeds.', + 'In versie 1 kon elk token dat een personage voorstelde zeshoeken onthullen. Stel Tokens die onthullen in op Personagetokens om dat gedrag te behouden.', + ], + colV1: 'Versie 1-opdracht', + colV2: 'Versie 2-opdracht', + }, + troubleshooting: { + heading: 'Problemen oplossen', + points: [ + 'Er gebeurt niets wanneer een token beweegt: controleer of het token op de tokenlaag staat en overeenkomt met Tokens die onthullen, en of de pagina zeshoeken heeft (!hexploration status).', + 'Zeshoeken zijn verschoven ten opzichte van het raster: gebruik Kalibreren en controleer daarna met een token op een paar zeshoeken verspreid over de kaart.', + 'Zeshoeken worden niet meer onthuld na het kopiëren van een pagina of spel: voer Opnieuw scannen uit op de pagina.', + 'Vullen meldt dat het gebied geen middelpunten van zeshoeken bevat: de vorm moet het middelpunt van ten minste één zeshoek bevatten.', + 'Voor al het andere kunt u het logboek van de API-console raadplegen en de berichten erbij vermelden als u om hulp vraagt.', + ], + }, + languages: { + heading: 'Talen', + body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + colLanguage: 'Taal', + colNative: 'Eigen naam', + colCode: 'Code', + }, + credits: { + heading: 'Kredieten', + original: 'Originele mod door', + maintainer: 'Versie 2 onderhouden door', + marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", + support: + 'Als je een bug vindt of een idee hebt, plaats dan een bericht op het Roll20 Mod-forum of open een probleem op GitHub, en voeg eventuele berichten uit het API-consolelogboek toe.', + }, + }, + }; + + var localeEnUS = { + titles: { + ready: 'Hexploration is ready.', + settings: 'Hexploration Settings', + languages: 'Choose a Language', + pageSettings: 'Page Settings: {page}', + status: 'Hexploration Status: {page}', + help: 'Hexploration Commands', + confirm: 'Please Confirm', + }, + discovery: { + title: 'Location Discovered', + }, + menu: { + draw: 'Draw', + reveal: 'Reveal and Hide', + locations: 'Locations', + tools: 'Tools', + layerInUse: 'New hexes are being drawn on the {layer}.', + pageSettingsHelp: + 'These settings apply to this page only. Settings marked ★ override the global settings.', + }, + buttons: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + undo: 'Undo Fill', + reveal: 'Reveal', + conceal: 'Conceal', + explore: 'Explore', + revealPage: 'Reveal Page', + resetPage: 'Reset Page', + mark: 'Mark Location', + unmark: 'Unmark', + name: 'Name Hex', + settings: 'Settings', + pageSettings: 'Page Settings', + status: 'Status', + rescan: 'Rescan', + calibrate: 'Calibrate', + calibrateReset: 'Reset Calibration', + help: 'Help', + change: 'Change', + menu: 'Menu', + clearOverrides: 'Clear Overrides', + confirmReset: 'Yes, Remove All Hexes', + }, + prompts: { + name: 'Location name (leave empty to clear)', + }, + values: { + on: 'On', + off: 'Off', + none: 'None', + hexLayer: { + auto: 'Auto (foreground if available)', + foreground: 'foreground layer', + objects: 'token layer', + }, + revealBy: { + players: 'Player tokens', + characters: 'Character tokens', + all: 'All tokens', + }, + revealMode: { + clear: 'Clear', + glimpse: 'Glimpse', + }, + announce: { + all: 'Everyone', + gm: 'GM only', + off: 'Off', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fill', + fillInverse: 'Inverse Fill', + conceal: 'Conceal', + }, + }, + settings: { + language: { + label: 'Language', + desc: 'Language for menus, messages and handouts.', + }, + hexLayer: { + label: 'Hex Layer', + desc: 'Where new hexes are drawn. Auto tries the foreground layer (above tokens) and falls back to the token layer if the game does not support it.', + }, + fillColor: { + label: 'Fill Colour', + desc: 'Colour of new hexes. Use rgba() for see-through hexes, for example rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Border Colour', + desc: 'Colour of the outline of new hexes.', + }, + labelColor: { + label: 'Label Colour', + desc: 'Colour of the GM-only name labels on named hexes.', + }, + glimpseColor: { + label: 'Glimpse Colour', + desc: 'Colour hexes change to when glimpsed (Glimpse reveal mode). Use a see-through rgba() colour.', + }, + strokeWidth: { + label: 'Border Width', + desc: 'Width of the outline of new hexes, in pixels (0 to 20).', + }, + maxDistance: { + label: 'Hex Reveal Distance', + desc: 'Stored on hexes when they are filled, so set it before filling: changing it later does not affect hexes already on the map. A token must be within this many hexes to reveal them, however far it can see; with 0 they are only revealed by entering them. Use it for mountains or forests. Leave empty for no limit.', + }, + revealDistance: { + label: 'Sight Distance', + desc: 'How many hexes around a moving token are revealed (0 to 20). 0 reveals only the hexes the token passes through.', + }, + lineOfSight: { + label: 'Line of Sight', + desc: 'When on, hexes that stay covered, such as mountains filled with a Hex Reveal Distance, hide the hexes behind them. It only makes a difference with a Sight Distance of 2 or more.', + }, + revealPath: { + label: 'Reveal Along Path', + desc: 'When on, every hex a token passes through while being dragged (including waypoints) is revealed, not just where it stops.', + }, + revealBy: { + label: 'Tokens That Reveal', + desc: 'Which tokens on the token layer reveal hexes: tokens controlled by a player, tokens that represent any character, or every token.', + }, + revealMode: { + label: 'Reveal Mode', + desc: 'Clear removes hexes within sight. Glimpse makes them see-through instead; they are removed when a token enters them.', + }, + announce: { + label: 'Announce Discoveries', + desc: 'Who sees the chat message when a named location is discovered.', + }, + pingDiscoveries: { + label: 'Ping Discoveries', + desc: 'When on, players are pinged to a named location when it is discovered.', + }, + hideCoveredTokens: { + label: 'Hide Covered Tokens', + desc: 'Roll20 draws names, bars and auras above hexes. When on, tokens under a covered hex have their player-visible name, bars and auras switched off, and switched back on when they are uncovered.', + }, + }, + status: { + engine: 'Game engine', + grid: 'Grid', + layer: 'Hex layer', + hexes: 'Hexes', + named: 'Named hexes', + icons: 'Location tokens', + glimpsed: 'Glimpsed hexes', + pending: 'Locations waiting for a fill', + calibrated: 'Calibrated', + overrides: 'Page overrides', + undo: 'Undo available', + }, + messages: { + filled: + 'Fill complete. Hexes drawn: {created}. Restyled: {restyled}. Locations hidden: {icons}.', + revealed: 'Hexes revealed: {count}.', + revealedPage: 'Every hex on the page revealed ({count}).', + confirmReset: + 'Remove every hex from "{page}" ({count})? Location tokens return to the token layer. Undo cannot reverse this.', + resetPage: 'Hexes removed from the page: {count}.', + undone: 'Last fill undone. Hexes removed: {removed}. Restyled hexes restored: {restored}.', + named: 'Hexes named "{name}": {count}.', + unnamed: 'Names cleared: {count}.', + marked: + 'Locations hidden in existing hexes: {attached}. Waiting for the next fill that covers them: {pending}.', + unmarked: 'Tokens that are no longer locations: {count}.', + settingChanged: '{setting} set to {value}.', + rescanned: + 'Rescan complete. Kept: {kept}. Adopted: {adopted}. Re-filed: {moved}. Missing and forgotten: {dropped}. Labels re-linked: {labels}. Location tokens re-linked: {icons}.', + calibrated: + 'Grid calibrated (column step {colStep}px, row step {rowStep}px). Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + calibrationReset: + 'Calibration removed. Rescan: kept {kept}, re-filed {moved}, adopted {adopted}.', + journalRebuilt: 'The "{help}" and "{deck}" handouts have been rebuilt.', + migrated: + 'Your Hexploration 1.x hex maps have been upgraded. If this game was copied from a Legacy game, run Rescan on each hex map page.', + pruned: + 'Saved hexes that no longer exist and were forgotten: {dropped}. If this game or page was copied, run Rescan on the page to pick its hexes up again.', + readyHint: + 'Type !hexploration for the menu, or open the "Hexploration - Command Deck" handout.', + }, + warnings: { + foregroundUnavailable: + 'This game does not support drawing on the foreground layer, so hexes were drawn on the token layer.', + someFailed: 'Hexes that could not be drawn: {count}. Check the API console for details.', + }, + errors: { + noPage: 'Could not find the page to work on.', + notHex: 'This page does not use a hex grid.', + noPolygons: 'Select one or more drawn shapes to fill.', + emptyArea: 'The selected area does not contain any hex centres.', + tooMany: 'That would create too many hexes in one go ({count}).', + nothingToConceal: 'Select drawn shapes or tokens to conceal.', + nothingToReveal: 'Select hexes, drawn shapes or tokens to reveal.', + noTokens: 'Select one or more tokens first.', + noHexes: 'Select one or more hexes (or tokens standing on hexes) first.', + nothingToUndo: 'There is no fill to undo.', + unknownCommand: 'Unknown command: {command}', + unknownSetting: 'Unknown setting: {key}', + unknownPageSetting: 'Settings that can be set per page: {keys}', + invalidValue: '"{value}" is not a valid value for {key}.', + calibrateNeedsTokens: 'Select one or two tokens snapped to hex centres.', + calibrateFailed: 'Those tokens cannot be used to calibrate.', + unexpected: 'Something went wrong: {message}', + }, + hints: { + noPage: 'Open the page you want to work on, or select something on it.', + notHex: 'Set the page grid to Hex (V) or Hex (H) in Page Settings.', + noPolygons: + 'Draw a polygon, rectangle, ellipse or freehand shape around the area, select it, then try again.', + emptyArea: 'Draw a larger shape, or check the page grid settings.', + tooMany: 'Fill a smaller area, or split the area into several shapes.', + noHexes: 'Hexes are on the foreground or token layer; switch to that layer to select them.', + unknownCommand: 'Type !hexploration help to list the commands.', + unknownSetting: 'Type !hexploration set to see every setting.', + calibrateNeedsTokens: + 'Snap a token to the centre of a hex and select it. Select a second token snapped to a neighbouring hex in the same row (Hex V) or column (Hex H) to correct the hex size too.', + calibrateFailed: + 'Two tokens must be in the same row (Hex V) or the same column (Hex H), at least one hex apart.', + unexpected: 'Details are in the API console log.', + }, + help: { + menu: 'Show the menu.', + fill: 'Cover the selected drawn shapes with hexes.', + fillInverse: 'Cover the whole page except inside the selected shapes.', + undo: 'Undo the last fill, inverse fill or conceal, and restore the shapes it used.', + reveal: 'Reveal the selected hexes, and the hexes under the selected shapes and tokens.', + revealPage: 'Reveal every hex on the page without announcements.', + conceal: 'Cover the area under the selected shapes and tokens with hexes again.', + explore: 'Reveal around the selected tokens as if they had just moved there.', + resetPage: 'Remove every hex on the page (asks first).', + name: 'Name the selected hexes, or the hexes under the selected tokens. Leave the name empty to clear it.', + mark: 'Turn the selected tokens into hidden locations.', + unmark: 'Stop the selected tokens being hidden locations.', + set: 'Change a setting, or show all settings.', + pageSet: 'Override a reveal setting on the current page only.', + pageClear: 'Remove the current page’s overrides.', + rescan: 'Rebuild the page’s hex list, for example after copying a page or game.', + calibrate: 'Line the hex grid up with one or two selected tokens snapped to hex centres.', + calibrateReset: 'Remove the current page’s calibration.', + status: 'Show what Hexploration knows about the current page.', + journal: 'Rebuild the Help and Command Deck handouts.', + help: 'Show this list.', + handout: 'Full instructions are in the "{name}" handout.', + }, + deck: { + drawDesc: 'Draw shapes around an area, select them, then fill. Undo reverses the last fill.', + revealDesc: + 'Select hexes, shapes or tokens to reveal or cover them again. Explore reveals around selected tokens as if they had moved.', + locationsDesc: + 'Select tokens to hide them as locations under hexes. Select hexes or tokens to name a hex.', + toolsDesc: + 'Settings, page overrides, status, rescanning copied pages and calibrating the grid.', + footer: 'See the "{help}" handout for full instructions.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex exploration for Roll20', + footer: 'Use the "{deck}" handout for one-click controls.', + overview: { + heading: 'Overview', + body: 'Hexploration covers a hex map with opaque hexes. As the party moves, the hexes they pass through (and, if you like, the hexes around them) are removed, so the map is uncovered one hex at a time. Hidden locations can be placed under hexes and are announced when found. It works in Jumpgate and Legacy games, on Hex (V) and Hex (H) grids of any size.', + demo: 'Watch a short demo (from version 1)', + }, + quickStart: { + heading: 'Quick Start', + steps: [ + 'Open a page whose grid is set to Hex (V) or Hex (H).', + 'Draw one or more shapes (polygon, rectangle, ellipse or freehand) around the area to hide.', + 'Select the shapes and click Fill in the Command Deck (or type !hexploration fill). The shapes are replaced by hexes.', + 'Optional: before filling, select tokens for important places and click Mark Location. They are hidden under the hexes and announced when discovered.', + 'Move a player token. Every hex it passes through, and the hexes within its Sight Distance, are revealed.', + ], + }, + commands: { + heading: 'Commands', + intro: + 'Only GMs can use these commands. Most act on the selected objects; the rest act on the page you are viewing.', + colCommand: 'Command', + colDesc: 'What it does', + }, + revealing: { + heading: 'How Revealing Works', + points: [ + 'Only tokens on the token layer reveal hexes. Which tokens count is set by Tokens That Reveal: player tokens by default, so the GM can move monsters without uncovering the map.', + 'A token reveals every hex it covers (large tokens cover several) and, with Reveal Along Path on, every hex on the route it was dragged along, including waypoints.', + 'Sight Distance reveals the hexes around each of those hexes, nearest first. With Line of Sight on, a hex is not revealed while a covered hex lies between it and the token. Nearer hexes are usually revealed first, so in open country Line of Sight changes nothing: it only matters with a Sight Distance of 2 or more and hexes that stay covered, such as terrain filled with a Hex Reveal Distance.', + 'Hex Reveal Distance is stored on each hex when it is filled, so set it before filling; changing it later does not affect hexes already on the map. A token must be within that many hexes to reveal them, however far it can see, and with 0 they are only revealed by entering them. For a mountain range: set Hex Reveal Distance to 0, fill the mountains, set it back to none, then fill the land beyond. With Sight Distance 3 and Line of Sight on, the party sees the open ground around them, but not the mountains or what lies behind them. Each mountain hex is revealed when a token walks into it.', + 'In Glimpse mode, hexes within sight become see-through instead of disappearing, and are removed when a token enters them. Glimpsed hexes do not block Line of Sight.', + 'Roll20 draws token names, bars and auras above hexes. With Hide Covered Tokens on, a token under a covered hex has its player-visible name, bars and auras switched off until it is uncovered, so hidden monsters do not give themselves away. If you switch one of them on while the token is covered, it stays hidden and is switched on when the token is uncovered.', + 'The API does not report moves made by other mods. TokenMod moves are picked up automatically; for other mods, select the tokens and click Explore, or call Hexploration.revealAround(token) from your own mod.', + ], + }, + locations: { + heading: 'Named Hexes and Locations', + points: [ + 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', + 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', + 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed. Jumpgate draws the GM layer below the foreground layer, so in Jumpgate the labels only show when Hex Layer is set to the token layer.', + 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', + ], + }, + settings: { + heading: 'Settings', + intro: + 'Change settings with !hexploration set (or the Settings button). Hex Layer, Tokens That Reveal and Language can also be set on the Mod’s settings page.', + colKey: 'Key', + colName: 'Setting', + colDesc: 'Description', + perPage: '(Can be set per page.)', + }, + jumpgate: { + heading: 'Jumpgate and Legacy', + points: [ + 'Hexploration works out which engine the game uses and draws the matching kind of shape. Shapes drawn in either editor can be filled.', + 'With Hex Layer set to Auto, hexes are drawn on the foreground layer, above tokens, so players cannot see what is underneath. If the foreground layer is not available, the token layer is used instead.', + 'Jumpgate draws mathematically regular hexes, which are a slightly different shape from Legacy hexes. If the hexes do not line up with a page’s grid, snap a token to a hex centre, select it and click Calibrate. Select two tokens in neighbouring hexes of the same row (Hex V) or column (Hex H) to correct the hex size too.', + 'When a page or game is copied, its hexes get new IDs. Run Rescan on the page to pick them up again, together with their name labels and location tokens.', + ], + }, + upgrading: { + heading: 'Upgrading from Version 1', + points: [ + 'Version 2 no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. You can remove them unless another mod uses them.', + 'Existing hex maps, names, location tokens and settings are upgraded automatically on the first start.', + 'The version 1 commands, including the Hexploration_menu macro, still work.', + 'Version 1 let any token that represented a character reveal hexes. Set Tokens That Reveal to Character tokens to keep that behaviour.', + ], + colV1: 'Version 1 command', + colV2: 'Version 2 command', + }, + troubleshooting: { + heading: 'Troubleshooting', + points: [ + 'Nothing happens when a token moves: check the token is on the token layer and matches Tokens That Reveal, and that the page has hexes (!hexploration status).', + 'Hexes are offset from the grid: use Calibrate, then check with a token on a few hexes across the map.', + 'Hexes stopped revealing after copying a page or game: run Rescan on the page.', + 'Fill says the area has no hex centres: the shape must contain the centre of at least one hex.', + 'For anything else, check the API console log and include its messages when asking for help.', + ], + }, + languages: { + heading: 'Languages', + body: 'Choose a language with !hexploration set language. Available languages:', + colLanguage: 'Language', + colNative: 'Native name', + colCode: 'Code', + }, + credits: { + heading: 'Credits', + original: 'Original mod by', + maintainer: 'Version 2 maintained by', + marketplace: 'Ada’s art packs on the Roll20 Marketplace', + support: + 'If you find a bug or have an idea, post in the Roll20 Mod forum or open an issue on GitHub, and include any messages from the API console log.', + }, + }, + }; + + const TRANSLATION$g = { + titles: { + ready: 'Hexploration on valmis.', + settings: 'Hexploration-asetukset', + languages: 'Valitse kieli', + pageSettings: 'Sivuasetukset: {page}', + status: 'Hexploration-tila: {page}', + help: 'Hexploration-komennot', + confirm: 'Vahvista', + }, + discovery: { + title: 'Sijainti löydetty', + }, + menu: { + draw: 'Piirto', + reveal: 'Paljasta ja piilota', + locations: 'Sijainnit', + tools: 'Työkalut', + layerInUse: 'Uudet heksat piirretään tasolle: {layer}.', + pageSettingsHelp: + 'Nämä asetukset koskevat vain tätä sivua. ★-merkityt asetukset ohittavat yleiset asetukset.', + }, + buttons: { + fill: 'Täytä', + fillInverse: 'Käänteinen täyttö', + undo: 'Kumoa täyttö', + reveal: 'Paljasta', + conceal: 'Peitä', + explore: 'Tutki', + revealPage: 'Paljasta sivu', + resetPage: 'Nollaa sivu', + mark: 'Merkitse sijainti', + unmark: 'Poista merkintä', + name: 'Nimeä heksa', + settings: 'Asetukset', + pageSettings: 'Sivuasetukset', + status: 'Tila', + rescan: 'Skannaa uudelleen', + calibrate: 'Kalibroi', + calibrateReset: 'Nollaa kalibrointi', + help: 'Ohje', + change: 'Muuta', + menu: 'Valikko', + clearOverrides: 'Tyhjennä ohitukset', + confirmReset: 'Kyllä, poista kaikki heksat', + }, + prompts: { + name: 'Sijainnin nimi (jätä tyhjäksi tyhjentääksesi)', + }, + values: { + on: 'Päällä', + off: 'Pois', + none: 'Ei mitään', + hexLayer: { + auto: 'Automaattinen (etuala, jos saatavilla)', + foreground: 'etualan taso', + objects: 'merkkitaso', + }, + revealBy: { + players: 'Pelaajien merkit', + characters: 'Hahmojen merkit', + all: 'Kaikki merkit', + }, + revealMode: { + clear: 'Poisto', + glimpse: 'Vilkaisu', + }, + announce: { + all: 'Kaikki', + gm: 'Vain GM', + off: 'Pois', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Täyttö', + fillInverse: 'Käänteinen täyttö', + conceal: 'Peitto', + }, + }, + settings: { + language: { + label: 'Kieli', + desc: 'Valikkojen, viestien ja monisteiden kieli.', + }, + hexLayer: { + label: 'Heksataso', + desc: 'Mihin uudet heksat piirretään. Automaattinen kokeilee etualan tasoa (merkkien yläpuolella) ja käyttää merkkitasoa, jos peli ei tue sitä.', + }, + fillColor: { + label: 'Täyttöväri', + desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Reunan väri', + desc: 'Uusien kuusioiden ääriviivan väri.', + }, + labelColor: { + label: 'Nimilappujen väri', + desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + }, + glimpseColor: { + label: 'Vilkaisun väri', + desc: 'Väri, jonka heksat saavat Vilkaisu-tilassa. Käytä läpikuultavaa rgba()-väriä.', + }, + strokeWidth: { + label: 'Reunan leveys', + desc: 'Uusien heksojen ääriviivan leveys pikseleinä (0 - 20).', + }, + maxDistance: { + label: 'Heksojen paljastusetäisyys', + desc: 'Tallennetaan heksoihin, kun ne täytetään, joten aseta se ennen täyttämistä: myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, riippumatta siitä, kuinka kauas se näkee; arvolla 0 ne paljastuvat vain, kun niihin astutaan. Käytä sitä vuorille tai metsille. Jätä tyhjäksi, jos rajaa ei haluta.', + }, + revealDistance: { + label: 'Näköetäisyys', + desc: 'Kuinka monta heksaa liikkuvan merkin ympärillä paljastetaan (0 - 20). 0 paljastaa vain ne heksat, joiden läpi merkki kulkee.', + }, + lineOfSight: { + label: 'Näköyhteys', + desc: 'Kun asetus on päällä, peitettyinä pysyvät heksat, kuten Heksojen paljastusetäisyys -asetuksella täytetyt vuoret, kätkevät takanaan olevat heksat. Sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän.', + }, + revealPath: { + label: 'Paljasta reitin varrelta', + desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + }, + revealBy: { + label: 'Paljastavat merkit', + desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + }, + revealMode: { + label: 'Paljastustila', + desc: 'Poisto poistaa näköetäisyydellä olevat heksat. Vilkaisu tekee niistä sen sijaan läpikuultavia; ne poistetaan, kun merkki astuu niihin.', + }, + announce: { + label: 'Ilmoita löydöt', + desc: 'Kuka näkee chat-viestin, kun nimetty sijainti löydetään.', + }, + pingDiscoveries: { + label: 'Pingaa löydöt', + desc: 'Kun se on päällä, pelaajat pingoidaan nimettyyn paikkaan, kun se löydetään.', + }, + hideCoveredTokens: { + label: 'Piilota peitetyt merkit', + desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + }, + }, + status: { + engine: 'Pelimoottori', + grid: 'Ruudukko', + layer: 'Heksataso', + hexes: 'Heksat', + named: 'Nimetyt heksat', + icons: 'Sijaintimerkit', + glimpsed: 'Vilkaistut heksat', + pending: 'Täyttöä odottavat sijainnit', + calibrated: 'Kalibroitu', + overrides: 'Sivun ohitukset', + undo: 'Kumoaminen käytettävissä', + }, + messages: { + filled: + 'Täyttö valmis. Heksat piirretty: {created}. Uudelleen muotoiltu: {restyled}. Piilotetut sijainnit: {icons}.', + revealed: 'Heksat paljastettiin: {count}.', + revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', + confirmReset: + 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Heksit poistettu sivulta: {count}.', + undone: + 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksaalit nimeltä "{name}": {count}.', + unnamed: 'Poistetut nimet: {count}.', + marked: + 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + settingChanged: '{setting} asetettu arvoon {value}.', + rescanned: + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + calibrated: + 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + calibrationReset: + 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', + migrated: + 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', + pruned: + 'Tallennetut heksat, joita ei enää ole ja jotka unohdettiin: {dropped}. Jos tämä peli tai sivu kopioitiin, suorita sivulla Skannaa uudelleen, jotta sen heksat löytyvät taas.', + readyHint: + 'Kirjoita !hexploration avataksesi valikon, tai avaa moniste "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', + }, + errors: { + noPage: 'Työstettävää sivua ei löytynyt.', + notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', + emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', + tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', + nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + noTokens: 'Valitse ensin yksi tai useampi merkki.', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + nothingToUndo: 'Kumoavaa täyttöä ei ole.', + unknownCommand: 'Tuntematon komento: {command}', + unknownSetting: 'Tuntematon asetus: {key}', + unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', + invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', + calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', + calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + unexpected: 'Jotain meni pieleen: {message}', + }, + hints: { + noPage: 'Avaa sivu, jota haluat käsitellä, tai valitse siitä jotain.', + notHex: 'Aseta sivun ruudukoksi Hex (V) tai Hex (H) sivun asetuksista.', + noPolygons: + 'Piirrä alueen ympärille monikulmio, suorakulmio, ellipsi tai vapaalla kädellä oleva muoto, valitse se ja yritä sitten uudelleen.', + emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', + tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', + noHexes: + 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', + unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', + calibrateNeedsTokens: + 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', + calibrateFailed: + 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', + }, + help: { + menu: 'Näytä valikko.', + fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', + reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + explore: + 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', + resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', + mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', + unmark: 'Estä valittujen merkkien piilottaminen.', + set: 'Muuta asetusta tai näytä kaikki asetukset.', + pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', + pageClear: 'Poista nykyisen sivun ohitukset.', + rescan: + 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', + calibrate: + 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + calibrateReset: 'Poista nykyisen sivun kalibrointi.', + status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', + journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', + help: 'Näytä tämä luettelo.', + handout: 'Täydelliset ohjeet ovat monisteessa "{name}".', + }, + deck: { + drawDesc: + 'Piirrä muotoja alueen ympärille, valitse ne ja napsauta Täytä. Kumoa täyttö peruu viimeisimmän täytön.', + revealDesc: + 'Valitse heksoja, muotoja tai merkkejä paljastaaksesi ne tai peittääksesi ne uudelleen. Tutki paljastaa valittujen merkkien ympäristön ikään kuin ne olisivat juuri siirtyneet sinne.', + locationsDesc: + 'Valitse merkit piilottaaksesi ne sijainneiksi heksojen alle. Valitse heksoja tai merkkejä nimetäksesi heksan.', + toolsDesc: + 'Asetukset, sivujen ohitukset, tila, kopioitujen sivujen uudelleenskannaus ja ruudukon kalibrointi.', + footer: 'Katso täydelliset ohjeet monisteesta "{help}".', + }, + handout: { + versionLabel: 'Versio', + subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', + overview: { + heading: 'Yleiskatsaus', + body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + demo: 'Katso lyhyt esittely (versiosta 1)', + }, + quickStart: { + heading: 'Pika-aloitus', + steps: [ + 'Avaa sivu, jonka ruudukkoasetuksena on Hex (V) tai Hex (H).', + 'Piirrä piilotettavan alueen ympärille yksi tai useampi muoto (monikulmio, suorakaide, ellipsi tai vapaalla kädellä).', + 'Valitse muodot ja napsauta Command Deck -monisteessa Täytä (tai kirjoita !hexploration fill). Muodot korvataan heksoilla.', + 'Valinnainen: valitse ennen täyttöä merkit tärkeille paikoille ja napsauta Merkitse sijainti. Ne piilotetaan heksojen alle, ja niistä ilmoitetaan, kun ne löydetään.', + 'Siirrä pelaajan merkkiä. Jokainen heksa, jonka läpi se kulkee, ja sen Näköetäisyyden sisällä olevat heksat paljastetaan.', + ], + }, + commands: { + heading: 'komennot', + intro: + 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', + colCommand: 'Komento', + colDesc: 'Mitä se tekee', + }, + revealing: { + heading: 'Kuinka paljastaminen toimii', + points: [ + 'Heksoja paljastavat vain merkkitason merkit. Asetus Paljastavat merkit määrää, mitkä merkit lasketaan: oletuksena pelaajien merkit, joten GM voi siirtää hirviöitä paljastamatta karttaa.', + 'Merkki paljastaa jokaisen heksan, jonka se peittää (suuret merkit peittävät useita), ja kun Paljasta reitin varrelta on päällä, jokaisen heksan reitillä, jota pitkin sitä vedettiin, välipisteet mukaan lukien.', + 'Näköetäisyys paljastaa kunkin näiden heksojen ympärillä olevat heksat, lähimmät ensin. Kun Näköyhteys on päällä, heksaa ei paljasteta niin kauan kuin sen ja merkin välissä on peitetty heksa. Lähemmät heksat paljastuvat yleensä ensin, joten avoimessa maastossa Näköyhteys ei muuta mitään: sillä on merkitystä vain, kun Näköetäisyys on 2 tai enemmän ja jotkin heksat pysyvät peitettyinä, kuten Heksojen paljastusetäisyys -asetuksella täytetty maasto.', + 'Heksojen paljastusetäisyys tallennetaan jokaiseen heksaan, kun se täytetään, joten aseta se ennen täyttämistä; myöhempi muutos ei vaikuta kartalla jo oleviin heksoihin. Merkin on oltava enintään näin monen heksan päässä paljastaakseen ne, vaikka se näkisi kauemmas, ja arvolla 0 ne paljastuvat vain, kun niihin astutaan. Vuorijonoa varten: aseta Heksojen paljastusetäisyys arvoon 0, täytä vuoret, palauta asetus tyhjäksi ja täytä sitten takana oleva maa. Kun Näköetäisyys on 3 ja Näköyhteys on päällä, seurue näkee ympärillään olevan avoimen maaston mutta ei vuoria eikä sitä, mitä niiden takana on. Kukin vuoriheksa paljastuu, kun merkki astuu siihen.', + 'Vilkaisu-tilassa näköetäisyydellä olevat heksat muuttuvat läpikuultaviksi katoamisen sijaan, ja ne poistetaan, kun merkki astuu niihin. Vilkaisun läpikuultavat heksat eivät estä näkyvyyttä Näköyhteys-asetuksessa.', + 'Roll20 piirtää merkkien nimet, palkit ja aurat heksojen päälle. Kun Piilota peitetyt merkit on päällä, peitetyn heksan alla olevan merkin pelaajille näkyvä nimi, palkit ja aurat kytketään pois, kunnes se paljastuu, joten piilotetut hirviöt eivät paljasta itseään. Jos kytket jonkin niistä päälle merkin ollessa peitettynä, se pysyy piilossa ja kytkeytyy päälle, kun merkki paljastuu.', + 'API ei ilmoita muiden modien tekemistä siirroista. TokenModin siirrot huomataan automaattisesti; muiden modien kohdalla valitse merkit ja napsauta Tutki tai kutsu Hexploration.revealAround(token) omasta modistasi.', + ], + }, + locations: { + heading: 'Nimetty Heksit ja sijainnit', + points: [ + 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', + 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', + 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', + ], + }, + settings: { + heading: 'Asetukset', + intro: + 'Muuta asetuksia komennolla !hexploration set (tai Asetukset-painikkeella). Heksatason, Paljastavat merkit ja Kielen voi asettaa myös modin asetussivulla.', + colKey: 'Avain', + colName: 'Asetus', + colDesc: 'Kuvaus', + perPage: '(Voidaan asettaa sivukohtaisesti.)', + }, + jumpgate: { + heading: 'Jumpgate ja Legacy', + points: [ + 'Hexploration selvittää, mitä moottoria peli käyttää, ja piirtää vastaavan muodon. Kummassakin editorissa piirretyt muodot voidaan täyttää.', + 'Kun Heksataso on Automaattinen, heksat piirretään etualan tasolle merkkien yläpuolelle, joten pelaajat eivät näe, mitä alla on. Jos etualan taso ei ole käytettävissä, käytetään merkkitasoa.', + 'Jumpgate piirtää matemaattisesti säännöllisiä heksoja, jotka ovat hieman eri muotoisia kuin Legacy-heksat. Jos heksat eivät osu sivun ruudukkoon, kiinnitä merkki heksan keskipisteeseen, valitse se ja napsauta Kalibroi. Korjaa myös heksan koko valitsemalla kaksi merkkiä saman rivin (Hex V) tai sarakkeen (Hex H) vierekkäisistä heksoista.', + 'Kun sivu tai peli kopioidaan, sen heksat saavat uudet tunnisteet. Suorita sivulla Skannaa uudelleen, jotta ne löytyvät taas nimilappuineen ja sijaintimerkkeineen.', + ], + }, + upgrading: { + heading: 'Päivitys versiosta 1', + points: [ + 'Versio 2 ei enää tarvitse PathMath-, MatrixMath-, Vector Math- tai HTML Builder -sovellusta. Voit poistaa ne, ellei toinen mod käytä niitä.', + 'Nykyiset heksakartat, nimet, sijaintimerkit ja asetukset päivitetään automaattisesti ensimmäisellä käynnistyksellä.', + 'Version 1 komennot, mukaan lukien Hexploration_menu-makro, toimivat edelleen.', + 'Versiossa 1 mikä tahansa hahmoa edustava merkki paljasti heksoja. Säilytä tämä toiminta asettamalla Paljastavat merkit arvoon Hahmojen merkit.', + ], + colV1: 'Version 1 komento', + colV2: 'Version 2 komento', + }, + troubleshooting: { + heading: 'Vianetsintä', + points: [ + 'Mitään ei tapahdu, kun merkki liikkuu: tarkista, että merkki on merkkitasolla ja vastaa Paljastavat merkit -asetusta ja että sivulla on heksoja (!hexploration status).', + 'Heksat ovat siirtyneet ruudukosta: käytä Kalibroi-toimintoa ja tarkista sitten merkillä muutama heksa eri puolilta karttaa.', + 'Heksat lakkasivat paljastumasta sivun tai pelin kopioinnin jälkeen: suorita sivulla Skannaa uudelleen.', + 'Täytä ilmoittaa, ettei alueella ole heksojen keskipisteitä: muodon on sisällettävä vähintään yhden heksan keskipiste.', + 'Jos haluat lisätietoja, tarkista API-konsolin loki ja sisällytä sen viestit, kun pyydät apua.', + ], + }, + languages: { + heading: 'Kielet', + body: 'Valitse kieli komennolla !hexploration set language. Käytettävissä olevat kielet:', + colLanguage: 'Kieli', + colNative: 'Oma nimi', + colCode: 'Koodi', + }, + credits: { + heading: 'Krediitit', + original: 'Alkuperäisen modin tekijä', + maintainer: 'Versio 2 ylläpitäjä', + marketplace: 'Adan taidepaketit Roll20 Marketplacessa', + support: + 'Jos löydät virheen tai sinulla on idea, kirjoita viesti Roll20 Mod -foorumille tai avaa ongelma GitHubissa ja sisällytä kaikki viestit API-konsolin lokista.', + }, + }, + }; + + const TRANSLATION$f = { + titles: { + ready: 'Hexploration est prêt.', + settings: "Paramètres d'Hexploration", + languages: 'Choisissez une langue', + pageSettings: 'Paramètres de la page : {page}', + status: "État d'Hexploration : {page}", + help: "Commandes d'Hexploration", + confirm: 'Veuillez confirmer', + }, + discovery: { + title: 'Emplacement découvert', + }, + menu: { + draw: 'Dessiner', + reveal: 'Révéler et masquer', + locations: 'Emplacements', + tools: 'Outils', + layerInUse: 'De nouveaux hexagones sont dessinés sur le {layer}.', + pageSettingsHelp: + "Ces paramètres s'appliquent uniquement à cette page. Les paramètres marqués ★ remplacent les paramètres globaux.", + }, + buttons: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + undo: 'Annuler le remplissage', + reveal: 'Révéler', + conceal: 'Cacher', + explore: 'Explorer', + revealPage: 'Révéler la page', + resetPage: 'Réinitialiser la page', + mark: "Marquer l'emplacement", + unmark: 'Démarquer', + name: "Nommer l'hexagone", + settings: 'Paramètres', + pageSettings: 'Paramètres de la page', + status: 'Statut', + rescan: 'Nouvelle analyse', + calibrate: 'Calibrer', + calibrateReset: 'Réinitialiser le calibrage', + help: 'Aide', + change: 'Modifier', + menu: 'Menu', + clearOverrides: 'Effacer les remplacements', + confirmReset: 'Oui, supprimer tous les hexagones', + }, + prompts: { + name: 'Nom du lieu (laissez vide pour effacer)', + }, + values: { + on: 'Activé', + off: 'Désactivé', + none: 'Aucun', + hexLayer: { + auto: 'Auto (premier plan si disponible)', + foreground: 'calque de premier plan', + objects: 'calque des jetons', + }, + revealBy: { + players: 'Jetons de joueur', + characters: 'Jetons de personnage', + all: 'Tous les jetons', + }, + revealMode: { + clear: 'Effacer', + glimpse: 'Aperçu', + }, + announce: { + all: 'Tout le monde', + gm: 'MJ uniquement', + off: 'Désactivé', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Remplir', + fillInverse: 'Remplissage inversé', + conceal: 'Cacher', + }, + }, + settings: { + language: { + label: 'Langue', + desc: 'Langue des menus, des messages et des documents.', + }, + hexLayer: { + label: 'Calque des hexagones', + desc: 'Où de nouveaux hexagones sont dessinés. Auto essaie la couche de premier plan (au-dessus des jetons) et revient à la couche de jetons si le jeu ne la prend pas en charge.', + }, + fillColor: { + label: 'Couleur de remplissage', + desc: 'Couleur des nouveaux hexagones. Utilisez rgba() pour les hexagones transparents, par exemple rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Couleur de la bordure', + desc: 'Couleur du contour des nouveaux hexagones.', + }, + labelColor: { + label: "Couleur de l'étiquette", + desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + }, + glimpseColor: { + label: "Couleur d'aperçu", + desc: 'Couleur que prennent les hexagones aperçus (mode de révélation Aperçu). Utilisez une couleur rgba() transparente.', + }, + strokeWidth: { + label: 'Largeur de la bordure', + desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + }, + maxDistance: { + label: 'Distance de révélation des hexagones', + desc: "Enregistrée sur les hexagones au moment où ils sont remplis, donc réglez-la avant de remplir : la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir ; avec 0, ils ne sont révélés qu'en y entrant. Utilisez-la pour des montagnes ou des forêts. Laissez vide pour ne fixer aucune limite.", + }, + revealDistance: { + label: 'Distance de vue', + desc: "Combien d'hexagones autour d'un jeton en mouvement sont révélés (0 à 20). 0 révèle uniquement les hexagones traversés par le jeton.", + }, + lineOfSight: { + label: 'Ligne de vue', + desc: "Lorsque cette option est activée, les hexagones qui restent couverts, comme des montagnes remplies avec une Distance de révélation des hexagones, cachent les hexagones situés derrière eux. Elle n'a d'effet qu'avec une Distance de vue de 2 ou plus.", + }, + revealPath: { + label: 'Révéler le long du chemin', + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + }, + revealBy: { + label: 'Jetons révélateurs', + desc: "Quels jetons sur la couche de jetons révèlent des hexagones : jetons contrôlés par un joueur, jetons qui représentent n'importe quel personnage ou chaque jeton.", + }, + revealMode: { + label: 'Mode de révélation', + desc: "Effacer supprime les hexagones à portée de vue. Aperçu les rend plutôt transparents ; ils sont supprimés lorsqu'un jeton y entre.", + }, + announce: { + label: 'Annoncer les découvertes', + desc: "Qui voit le message de discussion lorsqu'un emplacement nommé est découvert.", + }, + pingDiscoveries: { + label: 'Pinger les découvertes', + desc: "Lorsque cette option est activée, les joueurs reçoivent un ping vers un emplacement nommé lorsqu'il est découvert.", + }, + hideCoveredTokens: { + label: 'Masquer les jetons couverts', + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + }, + }, + status: { + engine: 'Moteur de jeu', + grid: 'Grille', + layer: 'Calque des hexagones', + hexes: 'Hexagones', + named: 'Hexagones nommés', + icons: "Jetons d'emplacement", + glimpsed: 'Hexagones aperçus', + pending: 'Emplacements en attente de remplissage', + calibrated: 'Calibré', + overrides: 'Remplacements de page', + undo: 'Annulation disponible', + }, + messages: { + filled: + 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', + revealed: 'Hexs révélés : {count}.', + revealedPage: 'Chaque hexagone de la page révélé ({count}).', + confirmReset: + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', + resetPage: 'Hexs supprimés de la page : {count}.', + undone: + 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', + named: 'Hexs nommés "{name}" : {count}.', + unnamed: 'Noms effacés : {count}.', + marked: + 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', + settingChanged: '{setting} défini sur {value}.', + rescanned: + 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + calibrated: + 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + calibrationReset: + 'Calibrage supprimé. Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', + journalRebuilt: 'Les documents « {help} » et « {deck} » ont été reconstruits.', + migrated: + "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", + pruned: + "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + readyHint: + 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', + someFailed: + "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + }, + errors: { + noPage: 'Impossible de trouver la page sur laquelle travailler.', + notHex: "Cette page n'utilise pas de grille hexadécimale.", + noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', + emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", + tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", + nothingToConceal: 'Sélectionnez des formes dessinées ou des jetons à masquer.', + nothingToReveal: 'Sélectionnez des hexagones, des formes dessinées ou des jetons à révéler.', + noTokens: "Sélectionnez d'abord un ou plusieurs jetons.", + noHexes: + "Sélectionnez d'abord un ou plusieurs hexagones (ou des jetons placés sur des hexagones).", + nothingToUndo: "Il n'y a aucun remplissage à défaire.", + unknownCommand: 'Commande inconnue : {command}', + unknownSetting: 'Paramètre inconnu : {key}', + unknownPageSetting: 'Paramètres pouvant être définis par page : {keys}', + invalidValue: '"{value}" n\'est pas une valeur valide pour {key}.', + calibrateNeedsTokens: 'Sélectionnez un ou deux jetons accrochés aux centres des hexagones.', + calibrateFailed: 'Ces jetons ne peuvent pas être utilisés pour calibrer.', + unexpected: "Un problème s'est produit : {message}", + }, + hints: { + noPage: + 'Ouvrez la page sur laquelle vous souhaitez travailler ou sélectionnez quelque chose dessus.', + notHex: 'Définissez la grille de la page sur Hex (V) ou Hex (H) dans Paramètres de page.', + noPolygons: + 'Dessinez un polygone, un rectangle, une ellipse ou une forme à main levée autour de la zone, sélectionnez-le, puis réessayez.', + emptyArea: + 'Dessinez une forme plus grande ou vérifiez les paramètres de la grille de la page.', + tooMany: 'Remplissez une zone plus petite ou divisez la zone en plusieurs formes.', + noHexes: + 'Les hexagones sont au premier plan ou sur la couche de jetons ; passez à ce calque pour les sélectionner.', + unknownCommand: 'Tapez !hexploration help pour lister les commandes.', + unknownSetting: 'Tapez !hexploration set pour voir tous les paramètres.', + calibrateNeedsTokens: + "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + calibrateFailed: + "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + unexpected: 'Les détails se trouvent dans le journal de la console API.', + }, + help: { + menu: 'Afficher le menu.', + fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', + fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", + undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + reveal: + 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', + revealPage: 'Révélez chaque hexagone de la page sans annonce.', + conceal: + 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', + explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", + mark: 'Transformez les jetons sélectionnés en emplacements cachés.', + unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", + set: 'Modifiez un paramètre ou affichez tous les paramètres.', + pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', + pageClear: 'Supprimez les remplacements de la page actuelle.', + rescan: + 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + calibrate: + 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', + calibrateReset: 'Supprimez le calibrage de la page actuelle.', + status: 'Montre ce que Hexploration sait de la page actuelle.', + journal: 'Reconstruisez les documents Help et Command Deck.', + help: 'Montrez cette liste.', + handout: 'Les instructions complètes se trouvent dans le document « {name} ».', + }, + deck: { + drawDesc: + "Dessinez des formes autour d'une zone, sélectionnez-les, puis remplissez. Annuler le remplissage annule le dernier remplissage.", + revealDesc: + "Sélectionnez des hexagones, des formes ou des jetons pour les révéler ou les recouvrir. Explorer révèle les alentours des jetons sélectionnés comme s'ils venaient de s'y déplacer.", + locationsDesc: + "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", + toolsDesc: + 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Exploration hex par hex pour Roll20', + footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', + overview: { + heading: 'Aperçu', + body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + demo: 'Regardez une courte démo (à partir de la version 1)', + }, + quickStart: { + heading: 'Démarrage rapide', + steps: [ + 'Ouvrez une page dont la grille est définie sur Hex (V) ou Hex (H).', + 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', + 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', + "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", + "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + ], + }, + commands: { + heading: 'Commandes', + intro: + 'Seuls les MJ peuvent utiliser ces commandes. La plupart agissent sur les objets sélectionnés ; le reste agit sur la page que vous consultez.', + colCommand: 'Commande', + colDesc: 'Ce que ça fait', + }, + revealing: { + heading: 'Comment fonctionne la révélation', + points: [ + 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', + "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", + "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", + "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", + "Roll20 dessine les noms, les barres et les auras des jetons au-dessus des hexagones. Avec Masquer les jetons couverts activé, un jeton sous un hexagone couvert voit son nom, ses barres et ses auras visibles par les joueurs désactivés jusqu'à ce qu'il soit découvert, afin que les monstres cachés ne se trahissent pas. Si vous en réactivez un pendant que le jeton est couvert, il reste masqué et sera activé lorsque le jeton sera découvert.", + "L'API ne signale pas les mouvements effectués par d'autres mods. Les mouvements TokenMod sont récupérés automatiquement ; pour les autres mods, sélectionnez les jetons et cliquez sur Explorer, ou appelez Hexploration.revealAround(token) depuis votre propre mod.", + ], + }, + locations: { + heading: 'Hexs et emplacements nommés', + points: [ + "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", + 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', + "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", + "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", + ], + }, + settings: { + heading: 'Paramètres', + intro: + 'Modifiez les paramètres avec !hexploration set (ou le bouton Paramètres). Calque des hexagones, Jetons révélateurs et Langue peuvent aussi être définis sur la page de paramètres du mod.', + colKey: 'Clé', + colName: 'Paramètre', + colDesc: 'Description', + perPage: '(Peut être défini par page.)', + }, + jumpgate: { + heading: 'Jumpgate et héritage', + points: [ + "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", + "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", + "Jumpgate dessine des hexagones mathématiquement réguliers, qui ont une forme légèrement différente des hexagones Legacy. Si les hexagones ne s’alignent pas avec la grille d’une page, placez un jeton au centre d’un hexagone, sélectionnez-le et cliquez sur Calibrer. Sélectionnez deux jetons dans des hexagones voisins de la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", + "Lorsqu'une page ou un jeu est copié, ses hexagones obtiennent de nouveaux identifiants. Exécutez une nouvelle analyse sur la page pour les récupérer, ainsi que leurs étiquettes de nom et leurs jetons de localisation.", + ], + }, + upgrading: { + heading: 'Mise à niveau à partir de la version 1', + points: [ + "La version 2 n'a plus besoin de PathMath, MatrixMath, Vector Math ou HTML Builder. Vous pouvez les supprimer à moins qu'un autre mod ne les utilise.", + 'Les cartes hexagonales, les noms, les jetons de localisation et les paramètres existants sont automatiquement mis à niveau au premier démarrage.', + 'Les commandes de la version 1, dont la macro Hexploration_menu, fonctionnent toujours.', + 'La version 1 permettait à tout jeton représentant un personnage de révéler des hexagones. Réglez Jetons révélateurs sur Jetons de personnage pour conserver ce comportement.', + ], + colV1: 'Commande version 1', + colV2: 'Commande version 2', + }, + troubleshooting: { + heading: 'Dépannage', + points: [ + 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', + 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', + "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", + "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", + ], + }, + languages: { + heading: 'Langues', + body: 'Choisissez une langue avec !hexploration set language. Langues disponibles :', + colLanguage: 'Langue', + colNative: "Nom d'origine", + colCode: 'Code', + }, + credits: { + heading: 'Crédits', + original: 'Mod original par', + maintainer: 'Version 2 maintenue par', + marketplace: "Les packs artistiques d'Ada sur le Marketplace Roll20", + support: + 'Si vous trouvez un bug ou avez une idée, publiez-le sur le forum Roll20 Mod ou ouvrez un problème sur GitHub et incluez tous les messages du journal de la console API.', + }, + }, + }; + + const TRANSLATION$e = { + titles: { + ready: 'Hexploration ist bereit.', + settings: 'Hexploration-Einstellungen', + languages: 'Sprache wählen', + pageSettings: 'Seiteneinstellungen: {page}', + status: 'Hexploration-Status: {page}', + help: 'Hexploration-Befehle', + confirm: 'Bitte bestätigen', + }, + discovery: { + title: 'Standort entdeckt', + }, + menu: { + draw: 'Zeichnen', + reveal: 'Aufdecken und Verdecken', + locations: 'Standorte', + tools: 'Werkzeuge', + layerInUse: 'Neue Hexfelder werden auf der {layer} gezeichnet.', + pageSettingsHelp: + 'Diese Einstellungen gelten nur für diese Seite. Mit ★ gekennzeichnete Einstellungen überschreiben die globalen Einstellungen.', + }, + buttons: { + fill: 'Füllen', + fillInverse: 'Umgekehrt füllen', + undo: 'Füllung rückgängig machen', + reveal: 'Aufdecken', + conceal: 'Verbergen', + explore: 'Erkunden', + revealPage: 'Seite aufdecken', + resetPage: 'Seite zurücksetzen', + mark: 'Standort markieren', + unmark: 'Markierung aufheben', + name: 'Hexfeld benennen', + settings: 'Einstellungen', + pageSettings: 'Seiteneinstellungen', + status: 'Status', + rescan: 'Erneut scannen', + calibrate: 'Kalibrieren', + calibrateReset: 'Kalibrierung zurücksetzen', + help: 'Hilfe', + change: 'Ändern', + menu: 'Menü', + clearOverrides: 'Überschreibungen löschen', + confirmReset: 'Ja, alle Hexfelder entfernen', + }, + prompts: { + name: 'Standortname (zum Löschen leer lassen)', + }, + values: { + on: 'An', + off: 'Aus', + none: 'Keine', + hexLayer: { + auto: 'Auto (Vordergrund, falls verfügbar)', + foreground: 'Vordergrundebene', + objects: 'Token-Ebene', + }, + revealBy: { + players: 'Spielertoken', + characters: 'Charaktertoken', + all: 'Alle Token', + }, + revealMode: { + clear: 'Entfernen', + glimpse: 'Durchsicht', + }, + announce: { + all: 'Alle', + gm: 'Nur GM', + off: 'Aus', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Füllen', + fillInverse: 'Umgekehrt füllen', + conceal: 'Verbergen', + }, + }, + settings: { + language: { + label: 'Sprache', + desc: 'Sprache für Menüs, Nachrichten und Handouts.', + }, + hexLayer: { + label: 'Hexfeld-Ebene', + desc: 'Wo neue Hexfelder gezeichnet werden. „Auto“ versucht es mit der Vordergrundebene (über den Token) und weicht auf die Token-Ebene aus, wenn das Spiel sie nicht unterstützt.', + }, + fillColor: { + label: 'Füllfarbe', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Randfarbe', + desc: 'Farbe der Umrisse neuer Hexfelder.', + }, + labelColor: { + label: 'Beschriftungsfarbe', + desc: 'Farbe der Nur-GM-Namensschilder auf benannten Hexfeldern.', + }, + glimpseColor: { + label: 'Durchsicht-Farbe', + desc: 'Farbe, die Hexfelder annehmen, wenn sie durchsichtig werden (Aufdeckmodus „Durchsicht“). Verwenden Sie eine durchsichtige rgba()-Farbe.', + }, + strokeWidth: { + label: 'Randbreite', + desc: 'Breite des Umrisses neuer Hexfelder in Pixel (0 bis 20).', + }, + maxDistance: { + label: 'Aufdeckungsdistanz für Hexfelder', + desc: 'Wird beim Füllen in den Hexfeldern gespeichert, also vor dem Füllen festlegen: Spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Spielstein muss sich innerhalb dieser Anzahl von Hexfeldern befinden, um sie aufzudecken, egal wie weit er sehen kann; bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für Berge oder Wälder verwenden. Für keine Begrenzung leer lassen.', + }, + revealDistance: { + label: 'Sichtweite', + desc: 'Wie viele Hexfelder um einen beweglichen Spielstein herum angezeigt werden (0 bis 20). 0 zeigt nur die Hexfelder an, die der Token durchquert.', + }, + lineOfSight: { + label: 'Sichtlinie', + desc: 'Wenn diese Option aktiviert ist, verbergen Hexfelder, die verdeckt bleiben, etwa Berge, die mit einer Aufdeckungsdistanz für Hexfelder gefüllt wurden, die Hexfelder dahinter. Das macht nur bei einer Sichtweite von 2 oder mehr einen Unterschied.', + }, + revealPath: { + label: 'Entlang des Wegs aufdecken', + desc: 'Wenn diese Option aktiviert ist, wird jedes Hexfeld, das ein Spielstein beim Ziehen durchquert (einschließlich Wegpunkte), angezeigt, nicht nur die Stelle, an der er anhält.', + }, + revealBy: { + label: 'Aufdeckende Token', + desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + }, + revealMode: { + label: 'Aufdeckmodus', + desc: '„Entfernen“ entfernt Hexfelder in Sichtweite. „Durchsicht“ macht sie stattdessen durchsichtig; sie werden entfernt, sobald ein Token sie betritt.', + }, + announce: { + label: 'Entdeckungen ankündigen', + desc: 'Wer sieht die Chat-Nachricht, wenn ein benannter Ort entdeckt wird?', + }, + pingDiscoveries: { + label: 'Entdeckungen anpingen', + desc: 'Wenn diese Option aktiviert ist, werden Spieler an einen benannten Ort gepingt, wenn dieser entdeckt wird.', + }, + hideCoveredTokens: { + label: 'Verdeckte Token ausblenden', + desc: 'Roll20 zeichnet Namen, Balken und Auren über Hexfeldern. Wenn diese Option aktiviert ist, werden der für den Spieler sichtbare Name, die Balken und die Auren von Spielsteinen unter einem abgedeckten Hexfeld ausgeschaltet und wieder eingeschaltet, wenn sie aufgedeckt werden.', + }, + }, + status: { + engine: 'Spiel-Engine', + grid: 'Raster', + layer: 'Hexfeld-Ebene', + hexes: 'Hexfelder', + named: 'Benannte Hexfelder', + icons: 'Standort-Token', + glimpsed: 'Durchsichtige Hexfelder', + pending: 'Standorte, die auf eine Füllung warten', + calibrated: 'Kalibriert', + overrides: 'Seitenüberschreibungen', + undo: 'Rückgängig möglich', + }, + messages: { + filled: + 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', + revealed: 'Aufgedeckte Verhexungen: {count}.', + revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + confirmReset: + 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + undone: + 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexen mit dem Namen „{name}“: {count}.', + unnamed: 'Gelöschte Namen: {count}.', + marked: + 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', + unmarked: 'Token, die keine Standorte mehr sind: {count}.', + settingChanged: '{setting} wird auf {value} gesetzt.', + rescanned: + 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + calibrated: + 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + calibrationReset: + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', + migrated: + 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', + pruned: + 'Gespeicherte Hexfelder, die nicht mehr existieren und vergessen wurden: {dropped}. Wenn dieses Spiel oder diese Seite kopiert wurde, führen Sie auf der Seite „Erneut scannen“ aus, um ihre Hexfelder wieder zu erfassen.', + readyHint: + 'Geben Sie !hexploration ein, um das Menü aufzurufen, oder öffnen Sie das Handout "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', + someFailed: + 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + }, + errors: { + noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', + notHex: 'Diese Seite verwendet kein Hex-Raster.', + noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', + emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', + tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + nothingToConceal: + 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + nothingToReveal: + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', + noHexes: + 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', + nothingToUndo: 'Es gibt keine Füllung, die rückgängig gemacht werden könnte.', + unknownCommand: 'Unbekannter Befehl: {command}', + unknownSetting: 'Unbekannte Einstellung: {key}', + unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', + invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', + calibrateNeedsTokens: + 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', + unexpected: 'Es ist ein Fehler aufgetreten: {message}', + }, + hints: { + noPage: + 'Öffnen Sie die Seite, an der Sie arbeiten möchten, oder wählen Sie etwas darauf aus.', + notHex: + 'Stellen Sie das Seitenraster in den Seiteneinstellungen auf Hex (V) oder Hex (H) ein.', + noPolygons: + 'Zeichnen Sie ein Polygon, ein Rechteck, eine Ellipse oder eine Freihandform um den Bereich, wählen Sie es aus und versuchen Sie es erneut.', + emptyArea: + 'Zeichnen Sie eine größere Form oder überprüfen Sie die Seitenrastereinstellungen.', + tooMany: + 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', + noHexes: + 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', + unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', + calibrateNeedsTokens: + 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', + calibrateFailed: + 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + unexpected: 'Details finden Sie im API-Konsolenprotokoll.', + }, + help: { + menu: 'Zeigen Sie das Menü an.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', + undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + reveal: + 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', + revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + conceal: + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + explore: + 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', + set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', + pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', + rescan: + 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + calibrate: + 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', + status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', + journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', + help: 'Diese Liste anzeigen.', + handout: 'Vollständige Anweisungen finden Sie im Handout „{name}“.', + }, + deck: { + drawDesc: + 'Zeichnen Sie Formen um einen Bereich, wählen Sie sie aus und füllen Sie sie dann. „Füllung rückgängig machen“ macht die letzte Füllung rückgängig.', + revealDesc: + 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', + locationsDesc: + 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + toolsDesc: + 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', + footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-für-Hex-Erkundung für Roll20', + footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', + overview: { + heading: 'Überblick', + body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', + }, + quickStart: { + heading: 'Schnellstart', + steps: [ + 'Öffnen Sie eine Seite, deren Raster auf Hex (V) oder Hex (H) eingestellt ist.', + 'Zeichnen Sie eine oder mehrere Formen (Polygon, Rechteck, Ellipse oder Freihand) um den auszublendenden Bereich.', + 'Wählen Sie die Formen aus und klicken Sie im Command Deck auf Füllen (oder geben Sie !hexploration fill ein). Die Formen werden durch Hexfelder ersetzt.', + 'Optional: Wählen Sie vor dem Füllen Token für wichtige Orte aus und klicken Sie auf „Standort markieren“. Sie werden unter den Hexfeldern versteckt und bei ihrer Entdeckung angekündigt.', + 'Bewegen Sie einen Spieler-Token. Jedes Hexfeld, das er durchquert, und die Hexfelder innerhalb seiner Sichtweite werden aufgedeckt.', + ], + }, + commands: { + heading: 'Befehle', + intro: + 'Nur GMs können diese Befehle verwenden. Die meisten wirken auf die ausgewählten Objekte; Der Rest wirkt auf der Seite, die Sie gerade betrachten.', + colCommand: 'Befehl', + colDesc: 'Was es bewirkt', + }, + revealing: { + heading: 'Wie Offenlegung funktioniert', + points: [ + 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', + 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', + '„Sichtweite“ deckt die Hexfelder um jedes dieser Hexfelder auf, die nächstgelegenen zuerst. Ist „Sichtlinie“ aktiviert, wird ein Hexfeld nicht aufgedeckt, solange ein verdecktes Hexfeld zwischen ihm und dem Token liegt. Nähere Hexfelder werden meist zuerst aufgedeckt, daher ändert „Sichtlinie“ in offenem Gelände nichts: Sie spielt nur bei einer „Sichtweite“ von 2 oder mehr und bei Hexfeldern eine Rolle, die verdeckt bleiben, etwa Gelände, das mit einer „Aufdeckungsdistanz für Hexfelder“ gefüllt wurde.', + '„Aufdeckungsdistanz für Hexfelder“ wird beim Füllen in jedem Hexfeld gespeichert, legen Sie sie also vor dem Füllen fest; spätere Änderungen wirken sich nicht auf Hexfelder aus, die bereits auf der Karte liegen. Ein Token muss sich innerhalb so vieler Hexfelder befinden, um sie aufzudecken, egal wie weit es sehen kann, und bei 0 werden sie nur aufgedeckt, wenn man sie betritt. Für eine Bergkette: Setzen Sie „Aufdeckungsdistanz für Hexfelder“ auf 0, füllen Sie die Berge, setzen Sie den Wert wieder auf „keine“ zurück und füllen Sie dann das Land dahinter. Mit „Sichtweite“ 3 und aktivierter „Sichtlinie“ sieht die Gruppe das offene Gelände um sich herum, aber weder die Berge noch das, was dahinter liegt. Jedes Berg-Hexfeld wird aufgedeckt, wenn ein Token es betritt.', + 'Im Modus „Durchsicht“ werden Hexfelder in Sichtweite durchsichtig, statt zu verschwinden, und werden entfernt, sobald ein Token sie betritt. Durchsichtige Hexfelder blockieren die „Sichtlinie“ nicht.', + 'Roll20 zeichnet Token-Namen, Leisten und Auren über den Hexfeldern. Ist „Verdeckte Token ausblenden“ aktiviert, werden bei einem Token unter einem verdeckten Hexfeld der für Spieler sichtbare Name, die Leisten und die Auren ausgeschaltet, bis er aufgedeckt wird, damit versteckte Monster sich nicht verraten. Schalten Sie eines davon ein, während der Token verdeckt ist, bleibt es verborgen und wird eingeschaltet, sobald der Token aufgedeckt wird.', + 'Die API meldet keine Bewegungen anderer Mods. TokenMod-Bewegungen werden automatisch übernommen; Wählen Sie für andere Mods die Token aus und klicken Sie auf „Erkunden“ oder rufen Sie Hexploration.revealAround(token) von Ihrem eigenen Mod aus auf.', + ], + }, + locations: { + heading: 'Benannte Hexfelder und Orte', + points: [ + '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', + 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', + 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird. Jumpgate zeichnet die GM-Ebene unterhalb der Vordergrundebene, daher sind die Beschriftungen in Jumpgate nur sichtbar, wenn „Hexfeld-Ebene“ auf die Token-Ebene gesetzt ist.', + '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', + ], + }, + settings: { + heading: 'Einstellungen', + intro: + 'Ändern Sie Einstellungen mit !hexploration set (oder über die Schaltfläche „Einstellungen“). „Hexfeld-Ebene“, „Aufdeckende Token“ und „Sprache“ lassen sich auch auf der Einstellungsseite des Mods festlegen.', + colKey: 'Schlüssel', + colName: 'Einstellung', + colDesc: 'Beschreibung', + perPage: '(Kann pro Seite eingestellt werden.)', + }, + jumpgate: { + heading: 'Jumpgate und Legacy', + points: [ + 'Hexploration ermittelt, welche Engine das Spiel verwendet, und zeichnet die passende Form. In beiden Editoren gezeichnete Formen können gefüllt werden.', + 'Ist „Hexfeld-Ebene“ auf „Auto“ gesetzt, werden Hexfelder auf der Vordergrundebene über den Token gezeichnet, sodass Spieler nicht sehen können, was darunter liegt. Ist die Vordergrundebene nicht verfügbar, wird stattdessen die Token-Ebene verwendet.', + 'Jumpgate zeichnet mathematisch regelmäßige Hexfelder, deren Form leicht von Legacy-Hexfeldern abweicht. Wenn die Hexfelder nicht mit dem Raster einer Seite übereinstimmen, rasten Sie einen Token in der Mitte eines Hexfelds ein, wählen Sie ihn aus und klicken Sie auf „Kalibrieren“. Wählen Sie zwei Token in benachbarten Hexfeldern derselben Zeile (Hex V) oder Spalte (Hex H) aus, um auch die Hexfeldgröße zu korrigieren.', + 'Wenn eine Seite oder ein Spiel kopiert wird, erhalten ihre Hexfelder neue IDs. Führen Sie auf der Seite „Erneut scannen“ aus, um sie zusammen mit ihren Namensbeschriftungen und Standort-Token wieder zu erfassen.', + ], + }, + upgrading: { + heading: 'Upgrade von Version 1', + points: [ + 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', + 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', + 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', + ], + colV1: 'Befehl der Version 1', + colV2: 'Befehl der Version 2', + }, + troubleshooting: { + heading: 'Fehlerbehebung', + points: [ + 'Nichts passiert, wenn sich ein Token bewegt: Prüfen Sie, ob der Token auf der Token-Ebene liegt und zu „Aufdeckende Token“ passt und ob die Seite Hexfelder hat (!hexploration status).', + 'Hexfelder sind gegenüber dem Raster versetzt: Verwenden Sie „Kalibrieren“ und prüfen Sie dann mit einem Token einige Hexfelder auf der Karte.', + 'Hexfelder werden nach dem Kopieren einer Seite oder eines Spiels nicht mehr aufgedeckt: Führen Sie auf der Seite „Erneut scannen“ aus.', + '„Füllen“ meldet, dass der Bereich keine Hexfeld-Mittelpunkte enthält: Die Form muss den Mittelpunkt von mindestens einem Hexfeld enthalten.', + 'Überprüfen Sie für alles andere das API-Konsolenprotokoll und geben Sie die entsprechenden Meldungen an, wenn Sie um Hilfe bitten.', + ], + }, + languages: { + heading: 'Sprachen', + body: 'Wählen Sie eine Sprache mit !hexploration set language. Verfügbare Sprachen:', + colLanguage: 'Sprache', + colNative: 'Eigenbezeichnung', + colCode: 'Code', + }, + credits: { + heading: 'Credits', + original: 'Original-Mod von', + maintainer: 'Version 2 verwaltet von', + marketplace: 'Adas Kunstpakete auf dem Roll20-Marktplatz', + support: + 'Wenn Sie einen Fehler finden oder eine Idee haben, posten Sie im Roll20 Mod-Forum oder öffnen Sie ein Problem auf GitHub und fügen Sie alle Meldungen aus dem API-Konsolenprotokoll hinzu.', + }, + }, + }; + + const TRANSLATION$d = { + titles: { + ready: 'Το Hexploration είναι έτοιμο.', + settings: 'Ρυθμίσεις Hexploration', + languages: 'Επιλέξτε μια γλώσσα', + pageSettings: 'Ρυθμίσεις σελίδας: {page}', + status: 'Κατάσταση Hexploration: {page}', + help: 'Εντολές Hexploration', + confirm: 'Επιβεβαιώστε', + }, + discovery: { + title: 'Ανακαλύφθηκε τοποθεσία', + }, + menu: { + draw: 'Σχεδίαση', + reveal: 'Αποκάλυψη και απόκρυψη', + locations: 'Τοποθεσίες', + tools: 'Εργαλεία', + layerInUse: 'Νέα εξάγωνα σχεδιάζονται στο {layer}.', + pageSettingsHelp: + 'Αυτές οι ρυθμίσεις ισχύουν μόνο για αυτήν τη σελίδα. Οι ρυθμίσεις με την ένδειξη ★ αντικαθιστούν τις καθολικές ρυθμίσεις.', + }, + buttons: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + undo: 'Αναίρεση γεμίσματος', + reveal: 'Αποκάλυψη', + conceal: 'Απόκρυψη', + explore: 'Εξερεύνηση', + revealPage: 'Αποκάλυψη σελίδας', + resetPage: 'Επαναφορά σελίδας', + mark: 'Επισήμανση τοποθεσίας', + unmark: 'Κατάργηση επισήμανσης', + name: 'Ονομασία εξαγώνου', + settings: 'Ρυθμίσεις', + pageSettings: 'Ρυθμίσεις σελίδας', + status: 'Κατάσταση', + rescan: 'Επανασάρωση', + calibrate: 'Βαθμονόμηση', + calibrateReset: 'Επαναφορά βαθμονόμησης', + help: 'Βοήθεια', + change: 'Αλλαγή', + menu: 'Μενού', + clearOverrides: 'Κατάργηση παρακάμψεων', + confirmReset: 'Ναι, αφαίρεση όλων των εξαγώνων', + }, + prompts: { + name: 'Όνομα τοποθεσίας (αφήστε κενό για διαγραφή)', + }, + values: { + on: 'Ενεργό', + off: 'Ανενεργό', + none: 'Κανένα', + hexLayer: { + auto: 'Αυτόματο (πρώτο πλάνο, αν είναι διαθέσιμο)', + foreground: 'επίπεδο πρώτου πλάνου', + objects: 'επίπεδο διακριτικών', + }, + revealBy: { + players: 'Διακριτικά παικτών', + characters: 'Διακριτικά χαρακτήρων', + all: 'Όλα τα διακριτικά', + }, + revealMode: { + clear: 'Καθαρισμός', + glimpse: 'Ματιά', + }, + announce: { + all: 'Όλοι', + gm: 'Μόνο GM', + off: 'Ανενεργό', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Γέμισμα', + fillInverse: 'Αντίστροφο γέμισμα', + conceal: 'Απόκρυψη', + }, + }, + settings: { + language: { + label: 'Γλώσσα', + desc: 'Γλώσσα για μενού, μηνύματα και φυλλάδια.', + }, + hexLayer: { + label: 'Επίπεδο εξαγώνων', + desc: 'Πού σχεδιάζονται τα νέα εξάγωνα. Το «Αυτόματο» δοκιμάζει το επίπεδο πρώτου πλάνου (πάνω από τα διακριτικά) και, αν το παιχνίδι δεν το υποστηρίζει, χρησιμοποιεί το επίπεδο διακριτικών.', + }, + fillColor: { + label: 'Χρώμα πλήρωσης', + desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Χρώμα περιγράμματος', + desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + }, + labelColor: { + label: 'Χρώμα ετικετών', + desc: 'Χρώμα των ετικετών ονομάτων μόνο για GM στα επώνυμα εξάγωνα.', + }, + glimpseColor: { + label: 'Χρώμα Ματιάς', + desc: 'Το χρώμα που παίρνουν τα εξάγωνα στη λειτουργία «Ματιά». Χρησιμοποιήστε ένα διαφανές χρώμα rgba().', + }, + strokeWidth: { + label: 'Πλάτος περιγράμματος', + desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + }, + maxDistance: { + label: 'Απόσταση αποκάλυψης εξαγώνων', + desc: 'Αποθηκεύεται στα εξάγωνα όταν γεμίζονται, οπότε ορίστε το πριν από το γέμισμα: αν το αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει· με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Χρησιμοποιήστε το για βουνά ή δάση. Αφήστε το κενό για να μην υπάρχει όριο.', + }, + revealDistance: { + label: 'Απόσταση όρασης', + desc: 'Πόσα εξάγωνα γύρω από ένα κινούμενο διακριτικό αποκαλύπτονται (0 έως 20). Το 0 αποκαλύπτει μόνο τα εξάγωνα από τα οποία διέρχεται το διακριτικό.', + }, + lineOfSight: { + label: 'Γραμμή όρασης', + desc: 'Όταν είναι ενεργοποιημένο, τα εξάγωνα που παραμένουν καλυμμένα, όπως βουνά που γεμίστηκαν με «Απόσταση αποκάλυψης εξαγώνων», κρύβουν τα εξάγωνα πίσω τους. Κάνει διαφορά μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη.', + }, + revealPath: { + label: 'Αποκάλυψη κατά μήκος της διαδρομής', + desc: 'Όταν είναι ενεργοποιημένο, κάθε εξάγωνο από το οποίο περνάει ένα διακριτικό κατά τη μεταφορά (συμπεριλαμβανομένων των σημείων διαδρομής) αποκαλύπτεται, όχι μόνο το σημείο που σταματά.', + }, + revealBy: { + label: 'Διακριτικά που αποκαλύπτουν', + desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + }, + revealMode: { + label: 'Λειτουργία αποκάλυψης', + desc: "Ο «Καθαρισμός» αφαιρεί τα εξάγωνα εντός όρασης. Η «Ματιά» τα κάνει αντί γι' αυτό διαφανή· αφαιρούνται όταν μπει σε αυτά ένα διακριτικό.", + }, + announce: { + label: 'Ανακοίνωση ανακαλύψεων', + desc: 'Ποιος βλέπει το μήνυμα συνομιλίας όταν ανακαλύπτεται μια τοποθεσία με όνομα.', + }, + pingDiscoveries: { + label: 'Ping στις ανακαλύψεις', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + }, + hideCoveredTokens: { + label: 'Απόκρυψη καλυμμένων διακριτικών', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + }, + }, + status: { + engine: 'Μηχανή παιχνιδιού', + grid: 'Πλέγμα', + layer: 'Επίπεδο εξαγώνων', + hexes: 'Εξάγωνα', + named: 'Ονομασμένα εξάγωνα', + icons: 'Διακριτικά τοποθεσιών', + glimpsed: 'Εξάγωνα σε Ματιά', + pending: 'Τοποθεσίες που περιμένουν γέμισμα', + calibrated: 'Βαθμονομημένο', + overrides: 'Παρακάμψεις σελίδας', + undo: 'Αναίρεση διαθέσιμη', + }, + messages: { + filled: + 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', + revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + confirmReset: + 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', + resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', + undone: + 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', + named: 'Hexes με όνομα "{name}": {count}.', + unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', + marked: + 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', + settingChanged: 'Το {setting} ορίστηκε σε {value}.', + rescanned: + 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + calibrated: + 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + calibrationReset: + 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', + migrated: + 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', + pruned: + 'Αποθηκευμένα εξάγωνα που δεν υπάρχουν πια και ξεχάστηκαν: {dropped}. Αν αυτό το παιχνίδι ή η σελίδα αντιγράφηκε, εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά τα εξάγωνά της.', + readyHint: + 'Πληκτρολογήστε !hexploration για να ανοίξει το μενού ή ανοίξτε το φυλλάδιο "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + someFailed: + 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + }, + errors: { + noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', + notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', + tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', + unknownCommand: 'Άγνωστη εντολή: {command}', + unknownSetting: 'Άγνωστη ρύθμιση: {key}', + unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', + invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', + unexpected: 'Κάτι πήγε στραβά: {message}', + }, + hints: { + noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', + notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + noPolygons: + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', + noHexes: + 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', + unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', + calibrateNeedsTokens: + 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + calibrateFailed: + 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', + }, + help: { + menu: 'Εμφάνιση του μενού.', + fill: 'Καλύψτε τα επιλεγμένα σχεδιασμένα σχήματα με εξάγωνα.', + fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', + undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', + reveal: + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', + conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', + name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', + mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', + unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', + pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', + pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', + rescan: + 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', + calibrate: + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', + status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', + journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', + help: 'Εμφάνιση αυτής της λίστας.', + handout: 'Πλήρεις οδηγίες βρίσκονται στο φυλλάδιο "{name}".', + }, + deck: { + drawDesc: + 'Σχεδιάστε σχήματα γύρω από μια περιοχή, επιλέξτε τα και κάντε «Γέμισμα». Η «Αναίρεση γεμίσματος» αναιρεί το τελευταίο γέμισμα.', + revealDesc: + 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', + locationsDesc: + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + toolsDesc: + 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', + footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', + }, + handout: { + versionLabel: 'Εκδοχή', + subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', + overview: { + heading: 'Επισκόπηση', + body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', + }, + quickStart: { + heading: 'Γρήγορη εκκίνηση', + steps: [ + 'Ανοίξτε μια σελίδα της οποίας το πλέγμα έχει οριστεί σε Hex (V) ή Hex (H).', + 'Σχεδιάστε ένα ή περισσότερα σχήματα (πολύγωνο, ορθογώνιο, έλλειψη ή με ελεύθερο χέρι) γύρω από την περιοχή για να κρύψετε.', + 'Επιλέξτε τα σχήματα και κάντε κλικ στο Γέμισμα στο Command Deck (ή πληκτρολογήστε !hexploration fill). Τα σχήματα αντικαθίστανται από εξάγωνα.', + 'Προαιρετικά: πριν από το γέμισμα, επιλέξτε διακριτικά για σημαντικά μέρη και κάντε κλικ στην «Επισήμανση τοποθεσίας». Κρύβονται κάτω από τα εξάγωνα και ανακοινώνονται όταν ανακαλυφθούν.', + 'Μετακινήστε ένα διακριτικό παίκτη. Κάθε εξάγωνο από το οποίο περνά, και τα εξάγωνα εντός της «Απόστασης όρασης» του, αποκαλύπτονται.', + ], + }, + commands: { + heading: 'Εντολές', + intro: + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + colCommand: 'Εντολή', + colDesc: 'Τι κάνει', + }, + revealing: { + heading: 'Πώς λειτουργεί η αποκάλυψη', + points: [ + 'Εξάγωνα αποκαλύπτουν μόνο τα διακριτικά στο επίπεδο διακριτικών. Ποια διακριτικά μετράνε ορίζεται από τη ρύθμιση «Διακριτικά που αποκαλύπτουν»: από προεπιλογή τα διακριτικά παικτών, ώστε ο GM να μπορεί να μετακινεί τέρατα χωρίς να αποκαλύπτει τον χάρτη.', + 'Ένα διακριτικό αποκαλύπτει κάθε εξάγωνο που καλύπτει (τα μεγάλα διακριτικά καλύπτουν πολλά) και, με ενεργή την «Αποκάλυψη κατά μήκος της διαδρομής», κάθε εξάγωνο της διαδρομής στην οποία σύρθηκε, μαζί με τα ενδιάμεσα σημεία.', + 'Η «Απόσταση όρασης» αποκαλύπτει τα εξάγωνα γύρω από καθένα από αυτά τα εξάγωνα, ξεκινώντας από τα πλησιέστερα. Με ενεργή τη «Γραμμή όρασης», ένα εξάγωνο δεν αποκαλύπτεται όσο παρεμβάλλεται καλυμμένο εξάγωνο ανάμεσα σε αυτό και στο διακριτικό. Τα πλησιέστερα εξάγωνα συνήθως αποκαλύπτονται πρώτα, οπότε σε ανοιχτό έδαφος η «Γραμμή όρασης» δεν αλλάζει τίποτα: έχει σημασία μόνο με «Απόσταση όρασης» 2 ή μεγαλύτερη και εξάγωνα που παραμένουν καλυμμένα, όπως έδαφος που γεμίστηκε με «Απόσταση αποκάλυψης εξαγώνων».', + 'Η «Απόσταση αποκάλυψης εξαγώνων» αποθηκεύεται σε κάθε εξάγωνο όταν γεμίζεται, οπότε ορίστε την πριν από το γέμισμα· αν την αλλάξετε αργότερα, δεν επηρεάζονται τα εξάγωνα που υπάρχουν ήδη στον χάρτη. Ένα διακριτικό πρέπει να βρίσκεται σε απόσταση έως τόσα εξάγωνα για να τα αποκαλύψει, όσο μακριά κι αν βλέπει, και με 0 αποκαλύπτονται μόνο όταν μπει σε αυτά. Για μια οροσειρά: ορίστε την «Απόσταση αποκάλυψης εξαγώνων» σε 0, γεμίστε τα βουνά, επαναφέρετέ την σε καμία τιμή και μετά γεμίστε τη γη πέρα από αυτά. Με «Απόσταση όρασης» 3 και ενεργή τη «Γραμμή όρασης», η ομάδα βλέπει το ανοιχτό έδαφος γύρω της, αλλά όχι τα βουνά ή ό,τι βρίσκεται πίσω τους. Κάθε ορεινό εξάγωνο αποκαλύπτεται όταν ένα διακριτικό μπει σε αυτό.', + 'Στη λειτουργία «Ματιά», τα εξάγωνα εντός όρασης γίνονται διαφανή αντί να εξαφανίζονται και αφαιρούνται όταν μπει σε αυτά ένα διακριτικό. Τα εξάγωνα σε κατάσταση «Ματιά» δεν εμποδίζουν τη «Γραμμή όρασης».', + 'Το Roll20 σχεδιάζει τα ονόματα, τις μπάρες και τις αύρες των διακριτικών πάνω από τα εξάγωνα. Με ενεργή την «Απόκρυψη καλυμμένων διακριτικών», ένα διακριτικό κάτω από καλυμμένο εξάγωνο έχει απενεργοποιημένα το ορατό στους παίκτες όνομα, τις μπάρες και τις αύρες μέχρι να αποκαλυφθεί, ώστε τα κρυμμένα τέρατα να μην προδίδονται. Αν ενεργοποιήσετε κάποιο από αυτά ενώ το διακριτικό είναι καλυμμένο, παραμένει κρυφό και ενεργοποιείται όταν το διακριτικό αποκαλυφθεί.', + 'Το API δεν αναφέρει κινήσεις που κάνουν άλλα mods. Οι κινήσεις του TokenMod εντοπίζονται αυτόματα· για άλλα mods, επιλέξτε τα διακριτικά και κάντε κλικ στην «Εξερεύνηση» ή καλέστε το Hexploration.revealAround(token) από το δικό σας mod.', + ], + }, + locations: { + heading: 'Με όνομα Hexes and Locations', + points: [ + 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', + 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', + ], + }, + settings: { + heading: 'Ρυθμίσεις', + intro: + 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', + colKey: 'Κλειδί', + colName: 'Σύνθεση', + colDesc: 'Περιγραφή', + perPage: '(Μπορεί να οριστεί ανά σελίδα.)', + }, + jumpgate: { + heading: 'Jumpgate και Legacy', + points: [ + 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', + 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', + 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', + ], + }, + upgrading: { + heading: 'Αναβάθμιση από την έκδοση 1', + points: [ + 'Η έκδοση 2 δεν χρειάζεται πλέον PathMath, MatrixMath, Vector Math ή HTML Builder. Μπορείτε να τα αφαιρέσετε εκτός εάν τα χρησιμοποιεί άλλο mod.', + 'Οι υπάρχοντες εξαγωνικοί χάρτες, τα ονόματα, τα διακριτικά τοποθεσιών και οι ρυθμίσεις αναβαθμίζονται αυτόματα στην πρώτη εκκίνηση.', + 'Οι εντολές έκδοσης 1, συμπεριλαμβανομένης της μακροεντολής Hexploration_menu, εξακολουθούν να λειτουργούν.', + 'Η έκδοση 1 επέτρεπε σε κάθε διακριτικό που αντιπροσώπευε χαρακτήρα να αποκαλύπτει εξάγωνα. Ορίστε τα «Διακριτικά που αποκαλύπτουν» σε «Διακριτικά χαρακτήρων» για να διατηρήσετε αυτή τη συμπεριφορά.', + ], + colV1: 'Εντολή έκδοσης 1', + colV2: 'Εντολή έκδοσης 2', + }, + troubleshooting: { + heading: 'Αντιμετώπιση προβλημάτων', + points: [ + 'Δεν συμβαίνει τίποτα όταν μετακινείται ένα διακριτικό: ελέγξτε ότι το διακριτικό βρίσκεται στο επίπεδο διακριτικών και ταιριάζει με τη ρύθμιση «Διακριτικά που αποκαλύπτουν», και ότι η σελίδα έχει εξάγωνα (!hexploration status).', + 'Τα εξάγωνα είναι μετατοπισμένα από το πλέγμα: χρησιμοποιήστε τη «Βαθμονόμηση» και μετά ελέγξτε με ένα διακριτικό μερικά εξάγωνα σε διάφορα σημεία του χάρτη.', + 'Τα εξάγωνα σταμάτησαν να αποκαλύπτονται μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού: εκτελέστε «Επανασάρωση» στη σελίδα.', + 'Το «Γέμισμα» αναφέρει ότι η περιοχή δεν έχει κέντρα εξαγώνων: το σχήμα πρέπει να περιέχει το κέντρο τουλάχιστον ενός εξαγώνου.', + 'Για οτιδήποτε άλλο, ελέγξτε το αρχείο καταγραφής της κονσόλας API και συμπεριλάβετε τα μηνύματά του όταν ζητάτε βοήθεια.', + ], + }, + languages: { + heading: 'Γλώσσες', + body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', + colLanguage: 'Γλώσσα', + colNative: 'Όνομα στη γλώσσα της', + colCode: 'Κώδικας', + }, + credits: { + heading: 'Πιστώσεις', + original: 'Πρωτότυπο mod από', + maintainer: 'Έκδοση 2 που διατηρείται από', + marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', + support: + 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', + }, + }, + }; + + const TRANSLATION$c = { + titles: { + ready: 'Hexploration מוכן.', + settings: 'הגדרות Hexploration', + languages: 'בחירת שפה', + pageSettings: 'הגדרות דף: {page}', + status: 'מצב Hexploration: {page}', + help: 'פקודות Hexploration', + confirm: 'נא לאשר', + }, + discovery: { + title: 'מיקום התגלה', + }, + menu: { + draw: 'ציור', + reveal: 'חשיפה והסתרה', + locations: 'מיקומים', + tools: 'כלים', + layerInUse: 'משושים חדשים מצוירים על {layer}.', + pageSettingsHelp: + 'הגדרות אלו חלות על דף זה בלבד. הגדרות המסומנות ★ עוקפות את ההגדרות הגלובליות.', + }, + buttons: { + fill: 'מילוי', + fillInverse: 'מילוי הפוך', + undo: 'ביטול מילוי', + reveal: 'חשיפה', + conceal: 'הסתרה', + explore: 'חקירה', + revealPage: 'חשיפת הדף', + resetPage: 'איפוס הדף', + mark: 'סימון מיקום', + unmark: 'ביטול סימון', + name: 'מתן שם למשושה', + settings: 'הגדרות', + pageSettings: 'הגדרות דף', + status: 'מצב', + rescan: 'סריקה מחדש', + calibrate: 'כיול', + calibrateReset: 'אפס כיול', + help: 'עזרה', + change: 'שינוי', + menu: 'תפריט', + clearOverrides: 'ניקוי עקיפות', + confirmReset: 'כן, הסר את כל המשושים', + }, + prompts: { + name: 'שם המיקום (השאירו ריק כדי לנקות)', + }, + values: { + on: 'מופעל', + off: 'כבוי', + none: 'ללא', + hexLayer: { + auto: 'אוטומטי (שכבת החזית אם זמינה)', + foreground: 'שכבת החזית', + objects: 'שכבת האסימונים', + }, + revealBy: { + players: 'אסימוני שחקנים', + characters: 'אסימוני דמויות', + all: 'כל האסימונים', + }, + revealMode: { + clear: 'הסרה', + glimpse: 'הצצה', + }, + announce: { + all: 'כולם', + gm: 'GM בלבד', + off: 'כבוי', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'מילוי', + fillInverse: 'מילוי הפוך', + conceal: 'הסתרה', + }, + }, + settings: { + language: { + label: 'שפה', + desc: 'שפה לתפריטים, הודעות ודפי מידע.', + }, + hexLayer: { + label: 'שכבת המשושים', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + }, + fillColor: { + label: 'צבע מילוי', + desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'צבע מסגרת', + desc: 'צבע קווי המתאר של משושות חדשות.', + }, + labelColor: { + label: 'צבע תווית', + desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + }, + glimpseColor: { + label: 'צבע הצצה', + desc: 'הצבע שאליו משושים משתנים בעת הצצה (מצב החשיפה הצצה). השתמש בצבע rgba() שקוף.', + }, + strokeWidth: { + label: 'עובי מסגרת', + desc: 'רוחב קווי המתאר של משושים חדשים, בפיקסלים (0 עד 20).', + }, + maxDistance: { + label: 'מרחק חשיפת משושים', + desc: 'נשמר על המשושים בעת מילוים, לכן הגדר אותו לפני המילוי: שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות; עם 0 הם נחשפים רק כשנכנסים אליהם. השתמש בו להרים או ליערות. השאר ריק ללא הגבלה.', + }, + revealDistance: { + label: 'מרחק ראייה', + desc: 'כמה משושים סביב אסימון נע נחשפים (0 עד 20). 0 חושף רק את המשושים שהאסימון עובר דרכם.', + }, + lineOfSight: { + label: 'קו ראייה', + desc: 'כאשר מופעל, משושים שנשארים מכוסים, כמו הרים שמולאו עם מרחק חשיפת משושים, מסתירים את המשושים שמאחוריהם. יש לכך השפעה רק עם מרחק ראייה של 2 ומעלה.', + }, + revealPath: { + label: 'חשיפה לאורך המסלול', + desc: 'כאשר הוא פועל, כל משושה שאסימון עובר דרכו בזמן גרירה (כולל נקודות ציון) מתגלה, לא רק היכן שהוא עוצר.', + }, + revealBy: { + label: 'אסימונים חושפים', + desc: 'אילו אסימונים בשכבת האסימון חושפים משושים: אסימונים הנשלטים על ידי שחקן, אסימונים המייצגים כל דמות או כל אסימון.', + }, + revealMode: { + label: 'מצב חשיפה', + desc: 'הסרה מסירה משושים שבטווח הראייה. הצצה הופכת אותם לשקופים במקום זאת; הם מוסרים כאשר אסימון נכנס אליהם.', + }, + announce: { + label: 'הכרזה על תגליות', + desc: "מי רואה את הודעת הצ'אט כאשר מתגלה מיקום בעל שם.", + }, + pingDiscoveries: { + label: 'פינג לתגליות', + desc: 'כאשר הוא פועל, שחקנים מקבלים פינג למיקום בעל שם כאשר הוא מתגלה.', + }, + hideCoveredTokens: { + label: 'הסתר אסימונים מכוסים', + desc: 'Roll20 מצייר שמות, פסים והילות מעל משושים. כשההגדרה מופעלת, השם, הפסים וההילות הגלויים לשחקנים של אסימונים שמתחת למשושה מכוסה נכבים, ומופעלים שוב כשהם נחשפים.', + }, + }, + status: { + engine: 'מנוע משחק', + grid: 'רשת', + layer: 'שכבת המשושים', + hexes: 'משושים', + named: 'משושים עם שם', + icons: 'אסימוני מיקום', + glimpsed: 'משושים בהצצה', + pending: 'מיקומים ממתינים למילוי', + calibrated: 'מכויל', + overrides: 'עקיפות דף', + undo: 'ניתן לבטל', + }, + messages: { + filled: + 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', + revealed: 'נחשפו משושים: {count}.', + revealedPage: 'כל hex בדף נחשף ({count}).', + confirmReset: + 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', + resetPage: 'הקסים הוסרו מהדף: {count}.', + undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', + named: 'hexes בשם "{name}": {count}.', + unnamed: 'שמות נוקו: {count}.', + marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', + settingChanged: '{setting} מוגדר ל-{value}.', + rescanned: + 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + calibrated: + 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + calibrationReset: + 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', + migrated: + 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', + pruned: + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + readyHint: + 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', + someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + }, + errors: { + noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', + notHex: 'דף זה אינו משתמש ברשת משושה.', + noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', + tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', + nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', + noTokens: 'תחילה בחר אסימון אחד או יותר.', + noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + nothingToUndo: 'אין מילוי לבטל.', + unknownCommand: 'פקודה לא ידועה: {command}', + unknownSetting: 'הגדרה לא ידועה: {key}', + unknownPageSetting: 'הגדרות שניתן להגדיר לכל עמוד: {keys}', + invalidValue: '"{value}" אינו ערך חוקי עבור {key}.', + calibrateNeedsTokens: 'בחר אסימון אחד או שניים שהוצמדו למרכזי משושה.', + calibrateFailed: 'לא ניתן להשתמש באסימונים האלה לכיול.', + unexpected: 'משהו השתבש: {message}', + }, + hints: { + noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', + notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + noPolygons: + 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', + noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', + unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', + unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', + calibrateNeedsTokens: + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + calibrateFailed: + 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', + }, + help: { + menu: 'הצג את התפריט.', + fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', + undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', + revealPage: 'חשוף כל קסם בדף ללא הודעות.', + conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', + resetPage: 'הסר כל hex בדף (שואל תחילה).', + name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', + unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + set: 'שנה הגדרה או הצג את כל ההגדרות.', + pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', + pageClear: 'הסר את העקיפות של הדף הנוכחי.', + rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', + calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + calibrateReset: 'הסר את הכיול של הדף הנוכחי.', + status: 'הצג מה Hexploration יודע על הדף הנוכחי.', + journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', + help: 'הצג רשימה זו.', + handout: 'ההנחיות המלאות נמצאות בדף "{name}".', + }, + deck: { + drawDesc: 'צייר צורות סביב אזור, בחר אותן ולאחר מכן מלא. ביטול מילוי מבטל את המילוי האחרון.', + revealDesc: + 'בחר משושים, צורות או אסימונים כדי לחשוף אותם או לכסות אותם שוב. חקירה חושפת את הסביבה של האסימונים הנבחרים כאילו הם זזו לשם.', + locationsDesc: + 'בחר אסימונים כדי להסתיר אותם כמיקומים מתחת למשושים. בחר משושים או אסימונים כדי לתת שם למשושה.', + toolsDesc: 'הגדרות, עקיפות עמודים, מצב, סריקה מחדש של דפים שהועתקו וכיול הרשת.', + footer: 'עיין בדף "{help}" להנחיות מלאות.', + }, + handout: { + versionLabel: 'גִרְסָה', + subtitle: 'חקירה משושה אחר קסם עבור Roll20', + footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', + overview: { + heading: 'סקירה כללית', + body: 'Hexploration מכסה מפת משושים במשושים אטומים. כשהחבורה זזה, המשושים שהיא עוברת דרכם (ואם תרצו, גם המשושים שסביבה) מוסרים, כך שהמפה נחשפת משושה אחר משושה. אפשר להציב מיקומים מוסתרים מתחת למשושים, והם מוכרזים כשהם נמצאים. הכלי עובד במשחקי Jumpgate ו-Legacy, על רשתות Hex (V) ו-Hex (H) בכל גודל.', + demo: 'צפו בהדגמה קצרה (מגרסה 1)', + }, + quickStart: { + heading: 'התחלה מהירה', + steps: [ + 'פתח עמוד שהרשת שלו מוגדרת ל- Hex (V) או Hex (H).', + 'צייר צורה אחת או יותר (מצולע, מלבן, אליפסה או ביד חופשית) סביב האזור כדי להסתיר.', + 'בחר את הצורות ולחץ על מילוי ב-Command Deck (או הקלד !hexploration fill). הצורות מוחלפות במשושים.', + 'אופציונלי: לפני המילוי, בחר אסימונים למקומות חשובים ולחץ על סימון מיקום. הם מוסתרים מתחת למשושים ומוכרזים כשהם מתגלים.', + 'הזז אסימון שחקן. כל משושה שהוא עובר דרכו, והמשושים שבתוך מרחק הראייה שלו, נחשפים.', + ], + }, + commands: { + heading: 'פקודות', + intro: + 'רק GMs יכולים להשתמש בפקודות אלה. רובם פועלים על האובייקטים שנבחרו; השאר פועלים בדף שבו אתה צופה.', + colCommand: 'פְּקוּדָה', + colDesc: 'מה זה עושה', + }, + revealing: { + heading: 'איך עובד גילוי', + points: [ + 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', + 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', + 'מרחק ראייה חושף את המשושים סביב כל אחד מאותם משושים, מהקרוב ביותר תחילה. כשקו ראייה מופעל, משושה אינו נחשף כל עוד יש משושה מכוסה בינו לבין האסימון. משושים קרובים יותר נחשפים בדרך כלל ראשונים, ולכן בשטח פתוח קו ראייה אינו משנה דבר: יש לו השפעה רק עם מרחק ראייה של 2 ומעלה ומשושים שנשארים מכוסים, כמו שטח שמולא עם מרחק חשיפת משושים.', + 'מרחק חשיפת משושים נשמר על כל משושה בעת מילויו, לכן הגדר אותו לפני המילוי; שינוי מאוחר יותר אינו משפיע על משושים שכבר נמצאים במפה. אסימון חייב להיות בטווח של מספר המשושים הזה כדי לחשוף אותם, לא משנה כמה רחוק הוא יכול לראות, ועם 0 הם נחשפים רק כשנכנסים אליהם. לרכס הרים: הגדר את מרחק חשיפת משושים ל-0, מלא את ההרים, החזר אותו ל"ללא", ואז מלא את השטח שמעבר להם. עם מרחק ראייה 3 וקו ראייה מופעל, החבורה רואה את השטח הפתוח סביבה, אך לא את ההרים או את מה שמאחוריהם. כל משושה הר נחשף כאשר אסימון נכנס אליו.', + 'במצב הצצה, משושים בטווח ראייה הופכים שקופים במקום להיעלם, והם מוסרים כאשר אסימון נכנס אליהם. משושים במצב הצצה אינם חוסמים קו ראייה.', + 'Roll20 מצייר את שמות האסימונים, הפסים וההילות מעל משושים. כשהסתר אסימונים מכוסים מופעל, לאסימון שמתחת למשושה מכוסה נכבים השם, הפסים וההילות הגלויים לשחקנים עד שהוא נחשף, כך שמפלצות מוסתרות לא מסגירות את עצמן. אם תפעיל אחד מהם בזמן שהאסימון מכוסה, הוא יישאר מוסתר ויופעל כשהאסימון ייחשף.', + 'ה-API אינו מדווח על תזוזות שבוצעו על ידי מודים אחרים. תזוזות של TokenMod נקלטות אוטומטית; עבור מודים אחרים, בחר את האסימונים ולחץ על חקירה, או קרא ל-Hexploration.revealAround(token) מהמוד שלך.', + ], + }, + locations: { + heading: 'בשם משושים ומיקומים', + points: [ + 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', + 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', + 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', + 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', + ], + }, + settings: { + heading: 'הגדרות', + intro: + 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', + colKey: 'מַפְתֵחַ', + colName: 'סְבִיבָה', + colDesc: 'תֵאוּר', + perPage: '(ניתן להגדיר לכל עמוד.)', + }, + jumpgate: { + heading: 'Jumpgate ו-Legacy', + points: [ + 'Hexploration מזהה באיזה מנוע המשחק משתמש ומצייר את סוג הצורה המתאים. אפשר למלא צורות שצוירו בכל אחד משני העורכים.', + 'כששכבת המשושים מוגדרת לאוטומטי, משושים מצוירים בשכבת החזית, מעל האסימונים, כך ששחקנים לא יכולים לראות מה יש מתחת. אם שכבת החזית אינה זמינה, נעשה שימוש בשכבת האסימונים במקום זאת.', + 'Jumpgate מצייר משושים משוכללים מתמטית, שצורתם שונה מעט ממשושי Legacy. אם המשושים אינם מתיישרים עם הרשת של הדף, הצמד אסימון למרכז משושה, בחר אותו ולחץ על כיול. בחר שני אסימונים במשושים שכנים באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', + 'כאשר עמוד או משחק מועתקים, המשושים שלו מקבלים מזהים חדשים. הפעל סריקה מחדש בדף כדי לאסוף אותם שוב, יחד עם תוויות השם ואסימוני המיקום שלהם.', + ], + }, + upgrading: { + heading: 'משדרג מגרסה 1', + points: [ + 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', + 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', + 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', + ], + colV1: 'פקודה גרסה 1', + colV2: 'פקודה גרסה 2', + }, + troubleshooting: { + heading: 'פתרון בעיות', + points: [ + 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', + 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', + 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', + 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', + ], + }, + languages: { + heading: 'שפות', + body: 'בחר שפה עם !hexploration set language. שפות זמינות:', + colLanguage: 'שָׂפָה', + colNative: 'שם בשפת המקור', + colCode: 'קוד', + }, + credits: { + heading: 'קרדיטים', + original: 'מוד מקורי מאת', + maintainer: 'גרסה 2 מתוחזקת על ידי', + marketplace: 'חבילות האמנות של עדה ב-Roll20 Marketplace', + support: + 'אם אתה מוצא באג או יש לך רעיון, פרסם בפורום Roll20 Mod או פתח בעיה ב-GitHub, וכלול הודעות כלשהן מיומן מסוף ה-API.', + }, + }, + }; + + const TRANSLATION$b = { + titles: { + ready: 'A Hexploration készen áll.', + settings: 'Hexploration-beállítások', + languages: 'Válasszon nyelvet', + pageSettings: 'Oldalbeállítások: {page}', + status: 'Hexploration-állapot: {page}', + help: 'Hexploration parancsok', + confirm: 'Kérjük, erősítse meg', + }, + discovery: { + title: 'Helyszín felfedezve', + }, + menu: { + draw: 'Rajzolás', + reveal: 'Felfedés és elrejtés', + locations: 'Helyszínek', + tools: 'Eszközök', + layerInUse: 'Az új hatszögek ide kerülnek: {layer}.', + pageSettingsHelp: + 'Ezek a beállítások csak erre az oldalra vonatkoznak. A ★ jelű beállítások felülírják a globális beállításokat.', + }, + buttons: { + fill: 'Kitöltés', + fillInverse: 'Inverz kitöltés', + undo: 'Kitöltés visszavonása', + reveal: 'Felfedés', + conceal: 'Lefedés', + explore: 'Felderítés', + revealPage: 'Oldal felfedése', + resetPage: 'Oldal visszaállítása', + mark: 'Helyszín megjelölése', + unmark: 'Jelölés törlése', + name: 'Hatszög elnevezése', + settings: 'Beállítások', + pageSettings: 'Oldalbeállítások', + status: 'Állapot', + rescan: 'Újraszkennelés', + calibrate: 'Kalibrálás', + calibrateReset: 'Kalibrálás visszaállítása', + help: 'Segítség', + change: 'Módosítás', + menu: 'Menü', + clearOverrides: 'Felülbírálások törlése', + confirmReset: 'Igen, minden hatszög eltávolítása', + }, + prompts: { + name: 'Helynév (a törléshez hagyja üresen)', + }, + values: { + on: 'Be', + off: 'Ki', + none: 'Nincs', + hexLayer: { + auto: 'Automatikus (előtér, ha elérhető)', + foreground: 'előtérréteg', + objects: 'tokenréteg', + }, + revealBy: { + players: 'Játékos tokenek', + characters: 'Karakter tokenek', + all: 'Minden token', + }, + revealMode: { + clear: 'Eltávolítás', + glimpse: 'Bepillantás', + }, + announce: { + all: 'Mindenki', + gm: 'Csak a GM', + off: 'Ki', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Kitöltés', + fillInverse: 'Inverz kitöltés', + conceal: 'Lefedés', + }, + }, + settings: { + language: { + label: 'Nyelv', + desc: 'A menük, üzenetek és tájékoztatók nyelve.', + }, + hexLayer: { + label: 'Hatszögek rétege', + desc: 'Hová kerülnek az új hatszögek. Az Automatikus az előtérréteggel próbálkozik (a tokenek fölött), és ha a játék ezt nem támogatja, a tokenréteget használja.', + }, + fillColor: { + label: 'Kitöltés színe', + desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + }, + strokeColor: { + label: 'Szegély színe', + desc: 'Az új hatszögek körvonalának színe.', + }, + labelColor: { + label: 'Címke színe', + desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + }, + glimpseColor: { + label: 'Bepillantás színe', + desc: 'Az a szín, amelyre a hatszögek bepillantáskor váltanak (Bepillantás felfedési mód). Használjon átlátszó rgba() színt.', + }, + strokeWidth: { + label: 'Szegély szélessége', + desc: 'Az új hatszögek körvonalának szélessége pixelben (0-tól 20-ig).', + }, + maxDistance: { + label: 'Hatszögek felfedési távolsága', + desc: 'A hatszögek kitöltésekor kerül tárolásra rajtuk, ezért a kitöltés előtt állítsa be: a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is; 0 esetén csak akkor fedődnek fel, ha belépnek beléjük. Hegyekhez vagy erdőkhöz használja. Hagyja üresen, ha nem kíván korlátozást.', + }, + revealDistance: { + label: 'Látótávolság', + desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + }, + lineOfSight: { + label: 'Látóvonal', + desc: 'Ha be van kapcsolva, a fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött hegyek, eltakarják a mögöttük lévő hatszögeket. Csak akkor számít, ha a Látótávolság legalább 2.', + }, + revealPath: { + label: 'Felfedés az útvonal mentén', + desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + }, + revealBy: { + label: 'Felfedő tokenek', + desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + }, + revealMode: { + label: 'Felfedési mód', + desc: 'Az Eltávolítás mód eltávolítja a látótávolságon belüli hatszögeket. A Bepillantás mód ehelyett átlátszóvá teszi őket; akkor tűnnek el, amikor egy token belép beléjük.', + }, + announce: { + label: 'Felfedezések bejelentése', + desc: 'Ki látja a csevegőüzenetet, ha egy megnevezett helyet felfedeznek.', + }, + pingDiscoveries: { + label: 'Felfedezések pingelése', + desc: 'Ha be van kapcsolva, a játékosok egy megnevezett helyre pingelődnek, amikor felfedezik.', + }, + hideCoveredTokens: { + label: 'Lefedett tokenek elrejtése', + desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + }, + }, + status: { + engine: 'Játékmotor', + grid: 'Rács', + layer: 'Hatszögek rétege', + hexes: 'Hatszögek', + named: 'Elnevezett hatszögek', + icons: 'Helyszíntokenek', + glimpsed: 'Bepillantott hatszögek', + pending: 'Kitöltésre váró helyszínek', + calibrated: 'Kalibrálva', + overrides: 'Oldalszintű felülbírálások', + undo: 'Visszavonható', + }, + messages: { + filled: + 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', + revealed: 'Felfedezett hatszögek: {count}.', + revealedPage: 'Az oldalon minden hex látható ({count}).', + confirmReset: + 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + resetPage: 'Az oldalról eltávolított hatszögek: {count}.', + undone: + 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', + named: '"{name}" nevű hatszögek: {count}.', + unnamed: 'Törölt nevek: {count}.', + marked: + 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + unmarked: 'Tokenek, amelyek már nem helyek: {count}.', + settingChanged: '{setting} értéke {value}.', + rescanned: + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + calibrated: + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + calibrationReset: + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', + journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + migrated: + 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', + pruned: + 'Mentett hatszögek, amelyek már nem léteznek, és törlődtek a nyilvántartásból: {dropped}. Ha ezt a játékot vagy oldalt másolták, futtassa az Újraszkennelést az oldalon, hogy újra felvegye a hatszögeit.', + readyHint: + 'A menühöz írja be a !hexploration parancsot, vagy nyissa meg a "Hexploration - Command Deck" tájékoztatót.', + }, + warnings: { + foregroundUnavailable: + 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', + }, + errors: { + noPage: 'Nem található az oldal, amelyen dolgozni kellene.', + notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', + emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', + tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', + nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + nothingToReveal: + 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + noTokens: 'Először válasszon ki egy vagy több tokent.', + noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + nothingToUndo: 'Nincs visszavonható kitöltés.', + unknownCommand: 'Ismeretlen parancs: {command}', + unknownSetting: 'Ismeretlen beállítás: {key}', + unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', + invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', + calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', + unexpected: 'Hiba történt: {message}', + }, + hints: { + noPage: 'Nyissa meg azt az oldalt, amelyen dolgozni szeretne, vagy válasszon rajta valamit.', + notHex: 'Állítsa az oldalrácsot Hex (V) vagy Hex (H) értékre az Oldalbeállításokban.', + noPolygons: + 'Rajzoljon sokszöget, téglalapot, ellipszist vagy szabadkézi alakzatot a terület köré, jelölje ki, majd próbálkozzon újra.', + emptyArea: 'Rajzoljon nagyobb alakzatot, vagy ellenőrizze az oldalrács beállításait.', + tooMany: 'Töltsön ki egy kisebb területet, vagy ossza fel több formára.', + noHexes: + 'A hatszögek az előtérben vagy a token rétegben vannak; váltson át arra a rétegre a kijelölésükhöz.', + unknownCommand: 'Írja be a !hexploration help parancsot a parancsok listázásához.', + unknownSetting: 'Minden beállítás megtekintéséhez írja be a !hexploration set parancsot.', + calibrateNeedsTokens: + 'Illesszen egy tokent egy hatszög közepére, és jelölje ki. Válasszon ki egy második tokent, amely egy szomszédos hatszögre van illesztve ugyanabban a sorban (Hex V) vagy oszlopban (Hex H), hogy a hatszög méretét is javítsa.', + calibrateFailed: + 'A két tokennek ugyanabban a sorban (Hex V) vagy ugyanabban az oszlopban (Hex H) kell lennie, egymástól legalább egy hatszögnyire.', + unexpected: 'A részletek az API-konzol naplójában találhatók.', + }, + help: { + menu: 'Mutasd a menüt.', + fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', + undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', + reveal: + 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', + revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + conceal: + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', + resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', + name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', + unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', + set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', + pageSet: 'Felfedezési beállítás felülírása csak az aktuális oldalon.', + pageClear: 'Távolítsa el az aktuális oldal felülírásait.', + rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', + calibrate: + 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', + status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', + journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', + help: 'Mutasd ezt a listát.', + handout: 'A teljes utasítás a „{name}” tájékoztatóban található.', + }, + deck: { + drawDesc: + 'Rajzoljon alakzatokat egy terület köré, jelölje ki őket, majd töltse ki. A visszavonás megfordítja az utolsó kitöltést.', + revealDesc: + 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', + locationsDesc: + 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + toolsDesc: + 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', + footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', + }, + handout: { + versionLabel: 'Változat', + subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', + overview: { + heading: 'Áttekintés', + body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + }, + quickStart: { + heading: 'Gyors kezdés', + steps: [ + 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', + 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', + 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', + 'Mozgass egy játékos tokent. Minden hatszög, amelyen áthalad, és a látótávolságon belüli hatszögek feltárulnak.', + ], + }, + commands: { + heading: 'Parancsok', + intro: + 'Csak a GM-ek használhatják ezeket a parancsokat. A legtöbb a kiválasztott objektumokra hat; a többi az éppen megtekintett oldalon működik.', + colCommand: 'Parancs', + colDesc: 'Mit csinál', + }, + revealing: { + heading: 'Hogyan működik a feltárás', + points: [ + 'Csak a tokenrétegen lévő tokenek fednek fel hatszögeket. Hogy mely tokenek számítanak, azt a Felfedő tokenek beállítás határozza meg: alapértelmezés szerint a játékosok tokenjei, így a GM a térkép felfedése nélkül mozgathatja a szörnyeket.', + 'Egy token felfed minden hatszöget, amelyet lefed (a nagy tokenek többet is), és ha a Felfedés az útvonal mentén be van kapcsolva, minden hatszöget azon az útvonalon is, amelyen végighúzták, az útpontokat is beleértve.', + 'A Látótávolság az egyes ilyen hatszögek körüli hatszögeket fedi fel, a legközelebbiekkel kezdve. Ha a Látóvonal be van kapcsolva, egy hatszög nem fedődik fel, amíg közte és a token között lefedett hatszög van. A közelebbi hatszögek általában előbb fedődnek fel, így nyílt terepen a Látóvonal semmin sem változtat: csak akkor számít, ha a Látótávolság legalább 2, és vannak fedve maradó hatszögek, például a Hatszögek felfedési távolsága beállítással kitöltött terep.', + 'A Hatszögek felfedési távolsága minden hatszögön a kitöltésekor kerül tárolásra, ezért a kitöltés előtt állítsa be; a későbbi módosítás nem hat a térképen már meglévő hatszögekre. Egy tokennek ennyi hatszögön belül kell lennie ahhoz, hogy felfedje őket, bármilyen messzire lát is, 0 esetén pedig csak akkor fedődnek fel, ha belépnek beléjük. Hegyvonulathoz: állítsa a Hatszögek felfedési távolsága értékét 0-ra, töltse ki a hegyeket, állítsa vissza üresre (korlátozás nélkül), majd töltse ki a mögöttük lévő vidéket. Ha a Látótávolság 3 és a Látóvonal be van kapcsolva, a csapat látja a körülötte lévő nyílt terepet, de a hegyeket és azt, ami mögöttük van, nem. Minden hegyi hatszög akkor fedődik fel, amikor egy token belép bele.', + 'Bepillantás módban a látótávolságon belüli hatszögek eltűnés helyett átlátszóvá válnak, és eltávolításra kerülnek, amikor egy token belép beléjük. A Bepillantás módban látott hatszögek a Látóvonal szempontjából nem számítanak takarásnak.', + 'A Roll20 a tokenek nevét, sávjait és auráit a hatszögek fölé rajzolja. Ha a Lefedett tokenek elrejtése be van kapcsolva, a lefedett hatszög alatti token játékosok által látható neve, sávjai és aurái kikapcsolnak, amíg fel nem fedik, így a rejtett szörnyek nem árulják el magukat. Ha ezek közül bármelyiket bekapcsolja, amíg a token le van fedve, rejtve marad, és a token felfedésekor kapcsol be.', + 'Az API nem jelzi a más modok által végrehajtott mozgásokat. A TokenMod mozgásait a rendszer automatikusan észleli; más modok esetén jelölje ki a tokeneket, és kattintson a Felderítés gombra, vagy hívja meg a Hexploration.revealAround(token) függvényt a saját modjából.', + ], + }, + locations: { + heading: 'Hexák és helyek neve', + points: [ + 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', + 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', + 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', + ], + }, + settings: { + heading: 'Beállítások elemre', + intro: + 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', + colKey: 'Kulcsfontosságú', + colName: 'Beállítás', + colDesc: 'Leírás', + perPage: '(Oldalonként beállítható.)', + }, + jumpgate: { + heading: 'Jumpgate és Legacy', + points: [ + 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', + 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', + 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', + ], + }, + upgrading: { + heading: 'Frissítés az 1-es verzióról', + points: [ + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', + 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', + ], + colV1: '1-es verzió parancs', + colV2: '2-es verzió parancs', + }, + troubleshooting: { + heading: 'Hibaelhárítás', + points: [ + 'Semmi sem történik, amikor egy token mozog: ellenőrizze, hogy a token a tokenrétegen van-e, megfelel-e a Felfedő tokenek beállításnak, és vannak-e hatszögek az oldalon (!hexploration status).', + 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', + 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', + 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', + 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + ], + }, + languages: { + heading: 'Nyelvek', + body: 'Nyelvet a !hexploration set language paranccsal választhat. Elérhető nyelvek:', + colLanguage: 'Nyelv', + colNative: 'Saját név', + colCode: 'Kód', + }, + credits: { + heading: 'Kredit', + original: 'Az eredeti mod szerzője', + maintainer: 'A 2-es verziót karbantartja', + marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', + support: + 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + }, + }, + }; + + const TRANSLATION$a = { + titles: { + ready: 'Hexploration è pronto.', + settings: 'Impostazioni di Hexploration', + languages: 'Scegli una lingua', + pageSettings: 'Impostazioni pagina: {page}', + status: 'Stato di Hexploration: {page}', + help: 'Comandi di Hexploration', + confirm: 'Conferma', + }, + discovery: { + title: 'Posizione scoperta', + }, + menu: { + draw: 'Disegna', + reveal: 'Rivela e nascondi', + locations: 'Posizioni', + tools: 'Strumenti', + layerInUse: 'I nuovi esagoni vengono disegnati sul {layer}.', + pageSettingsHelp: + 'Queste impostazioni si applicano solo a questa pagina. Le impostazioni contrassegnate con ★ sovrascrivono le impostazioni globali.', + }, + buttons: { + fill: 'Riempi', + fillInverse: 'Riempimento inverso', + undo: 'Annulla riempimento', + reveal: 'Rivela', + conceal: 'Nascondi', + explore: 'Esplora', + revealPage: 'Rivela pagina', + resetPage: 'Reimposta pagina', + mark: 'Segna posizione', + unmark: 'Rimuovi segno', + name: 'Nomina esagono', + settings: 'Impostazioni', + pageSettings: 'Impostazioni pagina', + status: 'Stato', + rescan: 'Nuova scansione', + calibrate: 'Calibra', + calibrateReset: 'Ripristina calibrazione', + help: 'Aiuto', + change: 'Modifica', + menu: 'Menu', + clearOverrides: 'Cancella sostituzioni', + confirmReset: 'Sì, rimuovi tutti gli esagoni', + }, + prompts: { + name: 'Nome della posizione (lascia vuoto per cancellare)', + }, + values: { + on: 'Attivo', + off: 'Disattivo', + none: 'Nessuno', + hexLayer: { + auto: 'Automatico (in primo piano se disponibile)', + foreground: 'livello in primo piano', + objects: 'livello dei segnalini', + }, + revealBy: { + players: 'Segnalini dei giocatori', + characters: 'Segnalini dei personaggi', + all: 'Tutti i segnalini', + }, + revealMode: { + clear: 'Elimina', + glimpse: 'Intravedi', + }, + announce: { + all: 'Tutti', + gm: 'Solo il GM', + off: 'Disattivo', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Riempi', + fillInverse: 'Riempimento inverso', + conceal: 'Nascondi', + }, + }, + settings: { + language: { + label: 'Lingua', + desc: 'Lingua per menu, messaggi e dispense.', + }, + hexLayer: { + label: 'Livello degli esagoni', + desc: 'Dove vengono disegnati i nuovi esagoni. Automatico prova il livello in primo piano (sopra i segnalini) e ripiega sul livello dei segnalini se il gioco non lo supporta.', + }, + fillColor: { + label: 'Colore riempimento', + desc: 'Colore dei nuovi esagoni. Usa rgba() per esagoni trasparenti, ad esempio rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Colore del bordo', + desc: 'Colore del contorno dei nuovi esagoni.', + }, + labelColor: { + label: "Colore dell'etichetta", + desc: 'Colore delle etichette con i nomi riservati ai GM sugli esagoni con nome.', + }, + glimpseColor: { + label: 'Colore degli esagoni intravisti', + desc: 'Colore che assumono gli esagoni intravisti (modalità di rivelazione Intravedi). Usa un colore rgba() trasparente.', + }, + strokeWidth: { + label: 'Larghezza del bordo', + desc: 'Larghezza del contorno dei nuovi esagoni, in pixel (da 0 a 20).', + }, + maxDistance: { + label: 'Distanza di rivelazione degli esagoni', + desc: 'Memorizzata sugli esagoni quando vengono riempiti, quindi impostala prima di riempire: modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro questo numero di esagoni per rivelarli, per quanto lontano possa vedere; con 0 vengono rivelati solo entrandoci. Usala per montagne o foreste. Lascia vuoto per nessun limite.', + }, + revealDistance: { + label: 'Distanza di vista', + desc: 'Quanti esagoni vengono rivelati attorno a un segnalino in movimento (da 0 a 20). 0 rivela solo gli esagoni attraversati dal segnalino.', + }, + lineOfSight: { + label: 'Linea di vista', + desc: 'Quando è attivo, gli esagoni che restano coperti, come le montagne riempite con una Distanza di rivelazione degli esagoni, nascondono gli esagoni dietro di essi. Fa differenza solo con una Distanza di vista di 2 o più.', + }, + revealPath: { + label: 'Rivela lungo il percorso', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + }, + revealBy: { + label: 'Segnalini che rivelano', + desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + }, + revealMode: { + label: 'Modalità di rivelazione', + desc: 'Elimina rimuove gli esagoni in vista. Intravedi invece li rende trasparenti; vengono rimossi quando un segnalino vi entra.', + }, + announce: { + label: 'Annuncia le scoperte', + desc: 'Chi vede il messaggio di chat quando viene scoperta una posizione denominata.', + }, + pingDiscoveries: { + label: 'Ping sulle scoperte', + desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + }, + hideCoveredTokens: { + label: 'Nascondi i segnalini coperti', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + }, + }, + status: { + engine: 'Motore di gioco', + grid: 'Griglia', + layer: 'Livello degli esagoni', + hexes: 'Esagoni', + named: 'Esagoni con nome', + icons: 'Segnalini di posizione', + glimpsed: 'Esagoni intravisti', + pending: 'Posizioni in attesa di riempimento', + calibrated: 'Calibrato', + overrides: 'Sostituzioni di pagina', + undo: 'Annullamento disponibile', + }, + messages: { + filled: + 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + revealed: 'Esagoni rivelati: {count}.', + revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', + confirmReset: + 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + resetPage: 'Esagoni rimossi dalla pagina: {count}.', + undone: + 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', + named: 'Esagoni denominati "{name}": {count}.', + unnamed: 'Nomi cancellati: {count}.', + marked: + 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', + unmarked: 'Token che non rappresentano più posizioni: {count}.', + settingChanged: '{setting} impostato su {value}.', + rescanned: + 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + calibrated: + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + calibrationReset: + 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', + migrated: + 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', + pruned: + 'Esagoni salvati che non esistono più e sono stati dimenticati: {dropped}. Se questo gioco o questa pagina sono stati copiati, esegui Nuova scansione sulla pagina per riprenderne gli esagoni.', + readyHint: + 'Digita !hexploration per il menu, oppure apri la dispensa "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + someFailed: + 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', + }, + errors: { + noPage: 'Impossibile trovare la pagina su cui lavorare.', + notHex: 'Questa pagina non usa una griglia esagonale.', + noPolygons: 'Seleziona una o più forme disegnate da riempire.', + emptyArea: "L'area selezionata non contiene alcun centro di esagono.", + tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', + nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', + noTokens: 'Seleziona prima uno o più token.', + noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToUndo: "Non c'è nessun riempimento da annullare.", + unknownCommand: 'Comando sconosciuto: {command}', + unknownSetting: 'Impostazione sconosciuta: {key}', + unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', + invalidValue: '"{value}" non è un valore valido per {key}.', + calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', + calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + unexpected: 'Qualcosa è andato storto: {message}', + }, + hints: { + noPage: 'Apri la pagina su cui vuoi lavorare o seleziona qualcosa al suo interno.', + notHex: 'Imposta la griglia della pagina su Hex (V) o Hex (H) nelle Impostazioni pagina.', + noPolygons: + "Disegna un poligono, un rettangolo, un'ellisse o una forma a mano libera attorno all'area, selezionala e riprova.", + emptyArea: + 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', + tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", + noHexes: + 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + unknownCommand: 'Digita !hexploration help per elencare i comandi.', + unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', + calibrateNeedsTokens: + 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + calibrateFailed: + 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + unexpected: 'I dettagli si trovano nel registro della console API.', + }, + help: { + menu: 'Mostra il menù.', + fill: 'Copri le forme disegnate selezionate con esagoni.', + fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", + undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + reveal: + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', + conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", + explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', + unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + set: "Modifica un'impostazione o mostra tutte le impostazioni.", + pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageClear: 'Rimuovi le sostituzioni della pagina corrente.', + rescan: + "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", + calibrate: + 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', + status: 'Mostra cosa sa Hexploration sulla pagina corrente.', + journal: 'Ricostruisci le dispense Help e Command Deck.', + help: 'Mostra questo elenco.', + handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + }, + deck: { + drawDesc: + "Disegna forme attorno a un'area, selezionale, quindi riempi. Annulla riempimento annulla l'ultimo riempimento.", + revealDesc: + 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', + locationsDesc: + 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + toolsDesc: + 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', + footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + }, + handout: { + versionLabel: 'Versione', + subtitle: 'Esplorazione esagono per esagono per Roll20', + footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + overview: { + heading: 'Panoramica', + body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + demo: 'Guarda una breve demo (dalla versione 1)', + }, + quickStart: { + heading: 'Avvio rapido', + steps: [ + 'Apri una pagina la cui griglia è impostata su Hex (V) o Hex (H).', + "Disegna una o più forme (poligono, rettangolo, ellisse o a mano libera) attorno all'area da nascondere.", + 'Seleziona le forme e fai clic su Riempi nel Command Deck (oppure digita !hexploration fill). Le forme vengono sostituite da esagoni.', + 'Facoltativo: prima di riempire, seleziona i segnalini dei luoghi importanti e fai clic su Segna posizione. Vengono nascosti sotto gli esagoni e annunciati quando vengono scoperti.', + 'Muovi un segnalino giocatore. Ogni esagono che attraversa, e gli esagoni entro la sua Distanza di vista, vengono rivelati.', + ], + }, + commands: { + heading: 'Comandi', + intro: + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + colCommand: 'Comando', + colDesc: 'Cosa fa', + }, + revealing: { + heading: 'Come funziona la rivelazione', + points: [ + 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', + "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", + 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', + 'Roll20 disegna nomi, barre e aure dei segnalini sopra gli esagoni. Con Nascondi i segnalini coperti attivo, un segnalino sotto un esagono coperto ha nome, barre e aure visibili ai giocatori disattivati finché non viene scoperto, così i mostri nascosti non si tradiscono. Se ne attivi uno mentre il segnalino è coperto, resta nascosto e viene attivato quando il segnalino viene scoperto.', + "L'API non segnala gli spostamenti effettuati da altre mod. Gli spostamenti di TokenMod vengono rilevati automaticamente; per altre mod, seleziona i segnalini e fai clic su Esplora, oppure chiama Hexploration.revealAround(token) dalla tua mod.", + ], + }, + locations: { + heading: 'Esagoni e posizioni con nome', + points: [ + 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', + "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", + 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", + "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", + ], + }, + settings: { + heading: 'Impostazioni', + intro: + 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', + colKey: 'Chiave', + colName: 'Collocamento', + colDesc: 'Descrizione', + perPage: '(Può essere impostato per pagina.)', + }, + jumpgate: { + heading: 'Jumpgate e Legacy', + points: [ + "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", + 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', + 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', + ], + }, + upgrading: { + heading: 'Aggiornamento dalla versione 1', + points: [ + 'La versione 2 non necessita più di PathMath, MatrixMath, Vector Math o HTML Builder. Puoi rimuoverli a meno che un altro mod non li utilizzi.', + 'Le mappe a esagoni, i nomi, i segnalini di posizione e le impostazioni esistenti vengono aggiornati automaticamente al primo avvio.', + 'I comandi della versione 1, inclusa la macro Hexploration_menu, funzionano ancora.', + 'La versione 1 permetteva a qualsiasi segnalino che rappresentasse un personaggio di rivelare esagoni. Imposta Segnalini che rivelano su Segnalini dei personaggi per mantenere quel comportamento.', + ], + colV1: 'Comando della versione 1', + colV2: 'Comando della versione 2', + }, + troubleshooting: { + heading: 'Risoluzione dei problemi', + points: [ + 'Non succede nulla quando un segnalino si muove: controlla che il segnalino sia sul livello dei segnalini e corrisponda a Segnalini che rivelano, e che la pagina abbia esagoni (!hexploration status).', + 'Gli esagoni sono sfalsati rispetto alla griglia: usa Calibra, poi controlla con un segnalino su alcuni esagoni in vari punti della mappa.', + 'Gli esagoni non vengono più rivelati dopo aver copiato una pagina o un gioco: esegui Nuova scansione sulla pagina.', + "Riempi indica che l'area non contiene centri di esagono: la forma deve contenere il centro di almeno un esagono.", + 'Per qualsiasi altra cosa, controlla il registro della console API e includi i suoi messaggi quando chiedi aiuto.', + ], + }, + languages: { + heading: 'Lingue', + body: 'Scegli una lingua con !hexploration set language. Lingue disponibili:', + colLanguage: 'Lingua', + colNative: 'Nome originale', + colCode: 'Codice', + }, + credits: { + heading: 'Crediti', + original: 'Mod originale di', + maintainer: 'Versione 2 mantenuta da', + marketplace: 'I pacchetti artistici di Ada sul Marketplace Roll20', + support: + "Se trovi un bug o hai un'idea, pubblica un post nel forum Roll20 Mod o apri un problema su GitHub e includi eventuali messaggi dal registro della console API.", + }, + }, + }; + + const TRANSLATION$9 = { + titles: { + ready: 'Hexploration の準備ができました。', + settings: 'Hexploration 設定', + languages: '言語の選択', + pageSettings: 'ページ設定: {page}', + status: 'Hexploration ステータス: {page}', + help: 'Hexploration コマンド', + confirm: 'ご確認ください', + }, + discovery: { + title: '場所が発見されました', + }, + menu: { + draw: '描画', + reveal: '表示と非表示', + locations: '場所', + tools: 'ツール', + layerInUse: '新しいヘクスが {layer} に描画されています。', + pageSettingsHelp: + 'これらの設定は、このページにのみ適用されます。 ★ のマークが付いた設定は、グローバル設定をオーバーライドします。', + }, + buttons: { + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', + undo: '塗りつぶしを元に戻す', + reveal: '表示', + conceal: '隠す', + explore: '探索', + revealPage: 'ページを全表示', + resetPage: 'ページをリセット', + mark: '場所としてマーク', + unmark: 'マーク解除', + name: 'ヘクスに名前を付ける', + settings: '設定', + pageSettings: 'ページ設定', + status: 'ステータス', + rescan: '再スキャン', + calibrate: '調整', + calibrateReset: '調整をリセット', + help: 'ヘルプ', + change: '変更', + menu: 'メニュー', + clearOverrides: '上書きを解除', + confirmReset: 'はい、すべてのヘクスを削除', + }, + prompts: { + name: '場所の名前 (クリアするには空白のままにします)', + }, + values: { + on: 'オン', + off: 'オフ', + none: 'なし', + hexLayer: { + auto: '自動（可能なら前景レイヤー）', + foreground: '前景レイヤー', + objects: 'トークンレイヤー', + }, + revealBy: { + players: 'プレイヤートークン', + characters: 'キャラクタートークン', + all: 'すべてのトークン', + }, + revealMode: { + clear: '除去', + glimpse: '透過', + }, + announce: { + all: '全員', + gm: 'GMのみ', + off: 'オフ', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '塗りつぶし', + fillInverse: '反転塗りつぶし', + conceal: '隠す', + }, + }, + settings: { + language: { + label: '言語', + desc: 'メニュー、メッセージ、配布資料の言語。', + }, + hexLayer: { + label: 'ヘクスのレイヤー', + desc: '新しいヘクスを描画する場所。自動では前景レイヤー（トークンの上）を試し、ゲームが対応していない場合はトークンレイヤーを使用します。', + }, + fillColor: { + label: '塗りつぶしの色', + desc: '新しいヘクスの色。シースルー ヘクスには rgba() を使用します (例: rgba(0,0,0,0.8))。', + }, + strokeColor: { + label: '枠線の色', + desc: '新しいヘクスの輪郭の色。', + }, + labelColor: { + label: 'ラベルの色', + desc: '名前付きヘクス上の GM 専用の名前ラベルの色。', + }, + glimpseColor: { + label: '透過色', + desc: '透過したときにヘクスが変わる色（表示モード「透過」）。半透明の rgba() カラーを使用してください。', + }, + strokeWidth: { + label: '枠線の幅', + desc: '新しいヘクスのアウトラインの幅 (ピクセル単位) (0 ～ 20)。', + }, + maxDistance: { + label: 'ヘクスの公開距離', + desc: 'ヘクスを塗りつぶすときにヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはこの数のヘクス以内にいる必要があります。0の場合、ヘクスに入ったときにのみ公開されます。山や森に使用します。制限を設けない場合は空のままにします。', + }, + revealDistance: { + label: '視界距離', + desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + }, + lineOfSight: { + label: '視線', + desc: 'オンの場合、「ヘクスの公開距離」を設定して塗りつぶした山など、覆われたままのヘクスが、その背後のヘクスを隠します。「視界距離」が2以上の場合にのみ違いが出ます。', + }, + revealPath: { + label: '経路に沿って表示', + desc: 'オンの場合、トークンが停止する場所だけでなく、ドラッグ中にトークンが通過するすべてのヘクス (ウェイポイントを含む) が表示されます。', + }, + revealBy: { + label: '公開するトークン', + desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + }, + revealMode: { + label: '公開モード', + desc: '除去は視界内のヘクスを取り除きます。透過は代わりにヘクスを半透明にし、トークンが入ると取り除きます。', + }, + announce: { + label: '発見を通知', + desc: '名前付きの場所が発見されたときにチャット メッセージを表示する人。', + }, + pingDiscoveries: { + label: '発見地点をピン', + desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + }, + hideCoveredTokens: { + label: '覆われたトークンを隠す', + desc: 'Roll20 はヘクスの上に名前、バー、オーラを描画します。オンの場合、覆われたヘクスの下にあるトークンは、プレイヤーに表示される名前、バー、オーラがオフになり、覆われていないと再びオンになります。', + }, + }, + status: { + engine: 'ゲームエンジン', + grid: 'グリッド', + layer: 'ヘクスレイヤー', + hexes: 'ヘクス', + named: '名前付きヘクス', + icons: '場所トークン', + glimpsed: '透過中のヘクス', + pending: '塗りつぶし待ちの場所', + calibrated: '調整済み', + overrides: 'ページの上書き', + undo: '元に戻せる操作', + }, + messages: { + filled: + '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + revealed: '明らかになったヘクス: {count}。', + revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', + confirmReset: + '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + resetPage: 'ページから削除されたヘクス: {count}。', + undone: + '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', + named: '「{name}」という名前のヘクス: {count}。', + unnamed: '削除された名前: {count}。', + marked: + '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + unmarked: '場所ではなくなったトークン: {count}。', + settingChanged: '{setting} を {value} に設定します。', + rescanned: + '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + calibrated: + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + calibrationReset: + 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', + migrated: + 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + pruned: + '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', + readyHint: + 'メニューを開くには !hexploration と入力するか、配布資料 "Hexploration - Command Deck" を開きます。', + }, + warnings: { + foregroundUnavailable: + 'このゲームは前景レイヤーでの描画をサポートしていないため、ヘクスはトークン レイヤーに描画されました。', + someFailed: + '描画できなかったヘクス: {count}。詳細については API コンソールを確認してください。', + }, + errors: { + noPage: '作業するページが見つかりませんでした。', + notHex: 'このページはヘクスグリッドを使用していません。', + noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', + emptyArea: '選択した領域には六角中心が含まれていません。', + tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', + nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', + nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', + noTokens: '最初に 1 つ以上のトークンを選択します。', + noHexes: '最初に 1 つ以上のヘクス (またはヘクス上にあるトークン) を選択します。', + nothingToUndo: '元に戻す塗りつぶしはありません。', + unknownCommand: '不明なコマンド: {command}', + unknownSetting: '不明な設定: {key}', + unknownPageSetting: 'ページごとに設定できる設定: {keys}', + invalidValue: '「{value}」は、{key} の有効な値ではありません。', + calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateFailed: 'これらのトークンは調整には使用できません。', + unexpected: '問題が発生しました: {message}', + }, + hints: { + noPage: '作業したいページを開くか、ページ上で何かを選択します。', + notHex: 'ページ設定でページのグリッドを Hex (V) または Hex (H) に設定してください。', + noPolygons: + '領域の周囲に多角形、長方形、楕円、またはフリーハンド形状を描画し、それを選択してから、再試行してください。', + emptyArea: 'より大きな図形を描画するか、ページ グリッドの設定を確認してください。', + tooMany: 'より小さい領域を塗りつぶすか、領域をいくつかの形状に分割します。', + noHexes: 'ヘクスは前景またはトークン層にあります。そのレイヤーに切り替えて選択します。', + unknownCommand: '「!hexploration help」と入力してコマンドをリストします。', + unknownSetting: 'すべての設定を表示するには、「!hexploration set」と入力します。', + calibrateNeedsTokens: + 'トークンをヘクスの中心にスナップして選択します。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにスナップした 2 つ目のトークンも選択すると、ヘクスのサイズも補正されます。', + calibrateFailed: + '2 つのトークンは同じ行 (Hex V) または同じ列 (Hex H) にあり、少なくとも 1 ヘクス離れている必要があります。', + unexpected: '詳細は API コンソールのログに記載されています。', + }, + help: { + menu: 'メニューを表示します。', + fill: '選択した描画形状を六角形で覆います。', + fillInverse: '選択した図形の内側を除いてページ全体を覆います。', + undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', + revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', + conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', + resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', + name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', + mark: '選択したトークンを非表示の場所に変更します。', + unmark: '選択したトークンが非表示の場所になるのを停止します。', + set: '設定を変更するか、すべての設定を表示します。', + pageSet: '現在のページでのみ公開設定をオーバーライドします。', + pageClear: '現在のページのオーバーライドを削除します。', + rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', + calibrate: + '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + calibrateReset: '現在のページの調整を削除します。', + status: '現在のページについて Hexploration が知っていることを表示します。', + journal: 'ヘルプと Command Deck の配布資料を再構築します。', + help: 'このリストを表示します。', + handout: '完全な手順は配布資料「{name}」に記載されています。', + }, + deck: { + drawDesc: + '領域の周囲に図形を描き、選択して塗りつぶします。「塗りつぶしを元に戻す」で最後の塗りつぶしを取り消せます。', + revealDesc: + 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', + locationsDesc: + 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + toolsDesc: + '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', + footer: '完全な手順については、配布資料「{help}」を参照してください。', + }, + handout: { + versionLabel: 'バージョン', + subtitle: 'Roll20 のヘクスごとの探索', + footer: 'ワンクリック コントロールについては、配布資料「{deck}」を使用してください。', + overview: { + heading: '概要', + body: 'Hexploration は、ヘクスマップを不透明なヘクスで覆います。パーティが移動すると、通過したヘクス（必要に応じてその周囲のヘクスも）が取り除かれ、マップが 1 ヘクスずつ明らかになります。隠し場所をヘクスの下に配置でき、見つかるとアナウンスされます。Jumpgate と Legacy の両方のゲームで、任意のサイズの Hex (V) および Hex (H) グリッドで動作します。', + demo: '短いデモを見る (バージョン 1 から)', + }, + quickStart: { + heading: 'クイックスタート', + steps: [ + 'グリッドが Hex (V) または Hex (H) に設定されたページを開きます。', + '非表示にする領域の周囲に 1 つ以上の形状 (多角形、長方形、楕円、またはフリーハンド) を描画します。', + '図形を選択し、Command Deck の「塗りつぶし」をクリックします（または !hexploration fill と入力します）。図形がヘクスに置き換わります。', + '任意: 塗りつぶす前に、重要な場所のトークンを選択して「場所としてマーク」をクリックします。それらはヘクスの下に隠され、発見されるとアナウンスされます。', + 'プレイヤートークンを移動します。通過したすべてのヘクスと、その視界距離内のヘクスが表示されます。', + ], + }, + commands: { + heading: 'コマンド', + intro: + 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', + colCommand: '指示', + colDesc: '何をするのか', + }, + revealing: { + heading: '暴露の仕組み', + points: [ + 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', + 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', + '「視界距離」は、それらの各ヘクスの周囲のヘクスを近い順に公開します。「視線」がオンの場合、ヘクスとトークンの間に覆われたヘクスがある間は、そのヘクスは公開されません。通常は近いヘクスから先に公開されるため、開けた土地では「視線」は何も変えません。意味を持つのは、「視界距離」が2以上で、「ヘクスの公開距離」を設定して塗りつぶした地形など、覆われたままのヘクスがある場合だけです。', + '「ヘクスの公開距離」は、ヘクスを塗りつぶすときに各ヘクスに保存されるため、塗りつぶす前に設定してください。後から変更しても、すでにマップ上にあるヘクスには影響しません。トークンがどれだけ遠くまで見えても、ヘクスを公開するにはその数のヘクス以内にいる必要があり、0の場合はヘクスに入ったときにのみ公開されます。山脈の場合：「ヘクスの公開距離」を0に設定して山を塗りつぶし、設定をなしに戻してから、その先の土地を塗りつぶします。「視界距離」を3にして「視線」をオンにすると、パーティーは周囲の開けた土地は見えますが、山やその背後にあるものは見えません。各山岳ヘクスは、トークンがその中に入ったときに公開されます。', + '「透過」モードでは、視界内のヘクスは消えずに半透明になり、トークンが入ると取り除かれます。透過状態のヘクスは「視線」を遮りません。', + 'Roll20 はトークンの名前、バー、オーラをヘクスの上に描画します。「覆われたトークンを隠す」がオンの場合、覆われたヘクスの下にあるトークンは、覆いが外れるまでプレイヤーに見える名前、バー、オーラがオフになるため、隠れたモンスターの存在がばれません。トークンが覆われている間にそれらのいずれかをオンにしても隠されたままになり、覆いが外れたときにオンになります。', + 'API は他の Mod による移動を報告しません。TokenMod による移動は自動的に検出されます。その他の Mod の場合は、トークンを選択して「探索」をクリックするか、独自の Mod から Hexploration.revealAround(token) を呼び出してください。', + ], + }, + locations: { + heading: '名前付きヘクスと場所', + points: [ + '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', + 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', + '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', + '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', + ], + }, + settings: { + heading: '設定', + intro: + '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', + colKey: '鍵', + colName: '設定', + colDesc: '説明', + perPage: '（ページごとに設定可能）', + }, + jumpgate: { + heading: 'Jumpgate と Legacy', + points: [ + 'Hexploration は、ゲームがどのエンジンを使用しているかを判断し、一致する種類の形状を描画します。どちらのエディタでも描画された形状を塗りつぶすことができます。', + '「ヘクスのレイヤー」が「自動」の場合、ヘクスは前景レイヤー（トークンの上）に描画されるため、プレイヤーはその下にあるものを見ることができません。前景レイヤーが使用できない場合は、代わりにトークンレイヤーが使用されます。', + 'Jumpgate は数学的に正確な正六角形のヘクスを描画するため、Legacy のヘクスとは形状がわずかに異なります。ヘクスがページのグリッドと揃わない場合は、ヘクスの中心にトークンをスナップし、それを選択して「調整」をクリックします。同じ行 (Hex V) または列 (Hex H) の隣接するヘクスにある 2 つのトークンを選択すると、ヘクスのサイズも補正されます。', + 'ページまたはゲームがコピーされると、そのヘクスは新しい ID を取得します。ページで再スキャンを実行して、名前ラベルと場所トークンとともにそれらを再度取得します。', + ], + }, + upgrading: { + heading: 'バージョン1からのアップグレード', + points: [ + 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', + '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', + 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', + ], + colV1: 'バージョン1のコマンド', + colV2: 'バージョン 2 コマンド', + }, + troubleshooting: { + heading: 'トラブルシューティング', + points: [ + 'トークンを動かしても何も起こらない: トークンがトークンレイヤー上にあり「公開するトークン」の設定に合っていること、ページにヘクスがあること（!hexploration status）を確認してください。', + 'ヘクスがグリッドからずれている: 「調整」を使い、マップ上のいくつかのヘクスにトークンを置いて確認してください。', + 'ページまたはゲームをコピーした後、ヘクスが表示されなくなりました。ページで再スキャンを実行してください。', + '「塗りつぶし」で領域にヘクスの中心がないと表示される: 図形には少なくとも 1 つのヘクスの中心が含まれている必要があります。', + 'その他の場合は、API コンソール ログを確認し、ヘルプを求めるときにそのメッセージを含めてください。', + ], + }, + languages: { + heading: '言語', + body: '!hexploration set language で言語を選択します。利用可能な言語:', + colLanguage: '言語', + colNative: '現地語での名称', + colCode: 'コード', + }, + credits: { + heading: 'クレジット', + original: 'オリジナル版の作者', + maintainer: 'バージョン 2 の保守者', + marketplace: 'Roll20 マーケットプレイスのエイダのアート パック', + support: + 'バグを見つけた場合やアイデアがある場合は、Roll20 Mod フォーラムに投稿するか、GitHub で問題を開いて、API コンソール ログからのメッセージを含めてください。', + }, + }, + }; + + const TRANSLATION$8 = { + titles: { + ready: 'Hexploration이 준비되었습니다.', + settings: 'Hexploration 설정', + languages: '언어 선택', + pageSettings: '페이지 설정: {page}', + status: 'Hexploration 상태: {page}', + help: 'Hexploration 명령어', + confirm: '확인해주세요', + }, + discovery: { + title: '위치 발견', + }, + menu: { + draw: '그리기', + reveal: '공개 및 숨기기', + locations: '위치', + tools: '도구', + layerInUse: '{layer}에 새로운 헥스가 그려지고 있습니다.', + pageSettingsHelp: + '이 설정은 이 페이지에만 적용됩니다. ★로 표시된 설정은 전역 설정보다 우선 적용됩니다.', + }, + buttons: { + fill: '채우기', + fillInverse: '반전 채우기', + undo: '채우기 취소', + reveal: '공개', + conceal: '숨기기', + explore: '탐색', + revealPage: '페이지 전체 공개', + resetPage: '페이지 초기화', + mark: '위치 표시', + unmark: '표시 해제', + name: '헥스 이름 지정', + settings: '설정', + pageSettings: '페이지 설정', + status: '상태', + rescan: '다시 스캔', + calibrate: '보정', + calibrateReset: '보정 초기화', + help: '도움말', + change: '변경', + menu: '메뉴', + clearOverrides: '재정의 지우기', + confirmReset: '예, 모든 헥스 제거', + }, + prompts: { + name: '위치 이름(지우려면 비워 두세요)', + }, + values: { + on: '켜짐', + off: '꺼짐', + none: '없음', + hexLayer: { + auto: '자동(사용 가능한 경우 전경)', + foreground: '전경 레이어', + objects: '토큰 레이어', + }, + revealBy: { + players: '플레이어 토큰', + characters: '캐릭터 토큰', + all: '모든 토큰', + }, + revealMode: { + clear: '제거', + glimpse: '반투명', + }, + announce: { + all: '모두', + gm: 'GM 전용', + off: '꺼짐', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: '채우기', + fillInverse: '반전 채우기', + conceal: '숨기기', + }, + }, + settings: { + language: { + label: '언어', + desc: '메뉴, 메시지, 유인물에 대한 언어입니다.', + }, + hexLayer: { + label: '헥스 레이어', + desc: '새 헥스를 그릴 위치입니다. 자동은 전경 레이어(토큰 위)를 먼저 시도하고, 게임이 지원하지 않으면 토큰 레이어를 사용합니다.', + }, + fillColor: { + label: '채우기 색상', + desc: '새 헥스의 색상입니다. 비쳐 보이는 헥스를 원하면 rgba()를 사용하세요(예: rgba(0,0,0,0.8)).', + }, + strokeColor: { + label: '테두리 색상', + desc: '새로운 육각형의 윤곽선 색상입니다.', + }, + labelColor: { + label: '라벨 색상', + desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + }, + glimpseColor: { + label: '반투명 색상', + desc: '반투명 상태가 된 헥스의 색상입니다(반투명 공개 모드). 비쳐 보이는 rgba() 색상을 사용하세요.', + }, + strokeWidth: { + label: '테두리 너비', + desc: '새 헥스의 윤곽선 너비(픽셀 단위)(0~20).', + }, + maxDistance: { + label: '헥스 공개 거리', + desc: '헥스를 채울 때 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 이 헥스 수 이내에 있어야 합니다. 0이면 헥스에 들어가야만 공개됩니다. 산이나 숲에 사용하세요. 제한이 없으면 비워 두세요.', + }, + revealDistance: { + label: '시야 거리', + desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + }, + lineOfSight: { + label: '시선', + desc: '켜져 있으면, 헥스 공개 거리로 채운 산처럼 계속 덮여 있는 헥스가 그 뒤의 헥스를 가립니다. 시야 거리가 2 이상일 때만 차이가 있습니다.', + }, + revealPath: { + label: '경로를 따라 표시', + desc: '켜져 있으면 토큰이 멈추는 위치뿐만 아니라 드래그되는 동안 토큰이 통과하는 모든 헥스(경유지 포함)가 표시됩니다.', + }, + revealBy: { + label: '공개하는 토큰', + desc: '토큰 레이어의 어떤 토큰이 헥스를 공개할지 정합니다: 플레이어가 조종하는 토큰, 캐릭터를 나타내는 토큰 또는 모든 토큰.', + }, + revealMode: { + label: '공개 모드', + desc: '제거는 시야 안의 헥스를 없앱니다. 반투명은 대신 헥스를 비쳐 보이게 하며, 토큰이 들어가면 제거합니다.', + }, + announce: { + label: '발견 알림', + desc: '이름이 지정된 위치가 발견되면 채팅 메시지를 볼 수 있는 사람입니다.', + }, + pingDiscoveries: { + label: '발견 위치 핑', + desc: '켜져 있으면 이름이 지정된 위치가 발견되면 플레이어에게 해당 위치로 핑이 전송됩니다.', + }, + hideCoveredTokens: { + label: '덮인 토큰 숨기기', + desc: 'Roll20은 이름, 막대, 오라를 헥스 위에 그립니다. 켜져 있으면 덮인 헥스 아래에 있는 토큰의 플레이어에게 보이는 이름, 막대, 오라를 끄고, 덮개가 벗겨지면 다시 켭니다.', + }, + }, + status: { + engine: '게임 엔진', + grid: '그리드', + layer: '헥스 레이어', + hexes: '헥스', + named: '명명된 헥스', + icons: '위치 토큰', + glimpsed: '반투명 헥스', + pending: '채우기를 기다리는 위치', + calibrated: '보정됨', + overrides: '페이지 재정의', + undo: '실행 취소 가능', + }, + messages: { + filled: + '채우기가 완료되었습니다. 그려진 헥스: {created}. 스타일이 변경되었습니다: {restyled}. 숨겨진 위치: {icons}.', + revealed: '공개된 헥스: {count}.', + revealedPage: '페이지의 모든 헥스를 공개했습니다({count}).', + confirmReset: + '"{page}"의 모든 헥스({count})를 제거하시겠습니까? 위치 토큰은 토큰 레이어로 돌아갑니다. 이 작업은 실행 취소로 되돌릴 수 없습니다.', + resetPage: '페이지에서 제거한 헥스: {count}.', + undone: + '마지막 채우기를 취소했습니다. 제거한 헥스: {removed}. 원래 스타일로 복원한 헥스: {restored}.', + named: '"{name}"이라는 헥스: {count}.', + unnamed: '지워진 이름: {count}.', + marked: + '기존 헥스 아래에 숨긴 위치: {attached}. 이 위치를 덮을 다음 채우기를 기다리는 위치: {pending}.', + unmarked: '더 이상 위치가 아닌 토큰: {count}.', + settingChanged: '{setting}이(가) {value}로 설정되었습니다.', + rescanned: + '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + calibrated: + '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + calibrationReset: + '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', + migrated: + 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', + pruned: + '더 이상 존재하지 않아 잊어버린 저장된 헥스: {dropped}. 이 게임이나 페이지를 복사했다면 해당 페이지에서 다시 스캔을 실행해 헥스를 다시 인식시키세요.', + readyHint: + '메뉴를 보려면 !hexploration을 입력하거나 "Hexploration - Command Deck" 유인물을 여세요.', + }, + warnings: { + foregroundUnavailable: + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', + someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + }, + errors: { + noPage: '작업할 페이지를 찾을 수 없습니다.', + notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', + emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', + tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', + nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', + nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + noTokens: '먼저 하나 이상의 토큰을 선택하세요.', + noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', + nothingToUndo: '실행 취소할 채우기가 없습니다.', + unknownCommand: '알 수 없는 명령: {command}', + unknownSetting: '알 수 없는 설정: {key}', + unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', + invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', + calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', + unexpected: '문제가 발생했습니다: {message}', + }, + hints: { + noPage: '작업하려는 페이지를 열거나 페이지에서 항목을 선택하세요.', + notHex: '페이지 설정에서 페이지 격자를 Hex (V) 또는 Hex (H)로 설정하세요.', + noPolygons: + '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', + emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', + tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', + noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', + unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', + calibrateNeedsTokens: + '토큰 하나를 헥스 중심에 스냅한 뒤 선택하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 스냅한 두 번째 토큰도 선택하면 헥스 크기까지 보정합니다.', + calibrateFailed: + '두 토큰은 같은 행(Hex V) 또는 같은 열(Hex H)에 있어야 하며, 적어도 헥스 한 칸 이상 떨어져 있어야 합니다.', + unexpected: '세부정보는 API 콘솔 로그에 있습니다.', + }, + help: { + menu: '메뉴를 보여주세요.', + fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', + undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', + reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', + conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', + explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', + resetPage: '페이지의 모든 헥스를 제거합니다(먼저 확인합니다).', + name: '선택한 헥스 또는 선택한 토큰 아래의 헥스의 이름을 지정합니다. 이름을 지우려면 이름을 비워 두세요.', + mark: '선택한 토큰을 숨겨진 위치로 바꿉니다.', + unmark: '선택한 토큰이 숨겨진 위치가 되는 것을 중지하세요.', + set: '설정을 변경하거나 모든 설정을 표시합니다.', + pageSet: '현재 페이지에서만 표시 설정을 재정의합니다.', + pageClear: '현재 페이지의 재정의를 제거합니다.', + rescan: + '페이지의 헥스 목록을 다시 만듭니다. 예를 들어 페이지나 게임을 복사한 뒤에 사용합니다.', + calibrate: '헥스 중심에 스냅된 토큰 한두 개를 선택해 헥스 격자를 맞춥니다.', + calibrateReset: '현재 페이지의 보정을 제거합니다.', + status: '현재 페이지에 대해 Hexploration이 알고 있는 내용을 보여줍니다.', + journal: '도움말 및 Command Deck 유인물을 다시 만듭니다.', + help: '이 목록을 보여주세요.', + handout: '전체 지침은 "{name}" 유인물에 있습니다.', + }, + deck: { + drawDesc: + '영역 주위에 도형을 그리고 선택한 다음 채웁니다. 채우기 취소는 마지막 채우기를 되돌립니다.', + revealDesc: + '헥스, 도형 또는 토큰을 선택해 공개하거나 다시 덮습니다. 탐색은 선택한 토큰이 그곳으로 막 이동한 것처럼 주변을 공개합니다.', + locationsDesc: + '토큰을 선택해 헥스 아래의 위치로 숨기세요. 헥스나 토큰을 선택해 헥스에 이름을 붙이세요.', + toolsDesc: '설정, 페이지 재정의, 상태, 복사된 페이지 다시 스캔 및 그리드 보정.', + footer: '전체 지침은 "{help}" 유인물을 참조하세요.', + }, + handout: { + versionLabel: '버전', + subtitle: 'Roll20용 헥스 단위 탐험', + footer: '원클릭 제어를 위해서는 "{deck}" 유인물을 사용하세요.', + overview: { + heading: '개요', + body: 'Hexploration은 헥스 지도를 불투명한 헥스로 덮습니다. 파티가 이동하면 지나간 헥스(원하면 주변 헥스도)가 제거되어 지도가 한 헥스씩 드러납니다. 숨겨진 위치를 헥스 아래에 둘 수 있으며, 발견되면 알려줍니다. Jumpgate와 Legacy 게임 모두에서, 모든 크기의 Hex (V) 및 Hex (H) 그리드에서 작동합니다.', + demo: '짧은 데모 보기(버전 1부터)', + }, + quickStart: { + heading: '빠른 시작', + steps: [ + '격자가 Hex (V) 또는 Hex (H)로 설정된 페이지를 엽니다.', + '숨길 영역 주위에 하나 이상의 도형(다각형, 직사각형, 타원 또는 자유형)을 그립니다.', + '모양을 선택하고 Command Deck에서 채우기를 클릭합니다(또는 !hexploration fill 입력). 모양이 헥스로 바뀝니다.', + '선택 사항: 채우기 전에 중요한 장소의 토큰을 선택하고 위치 표시를 클릭하세요. 토큰은 헥스 아래에 숨겨지고 발견되면 알려집니다.', + '플레이어 토큰을 움직입니다. 토큰이 지나가는 모든 헥스와 시야 거리 안의 헥스가 공개됩니다.', + ], + }, + commands: { + heading: '명령', + intro: + 'GM만이 이 명령을 사용할 수 있습니다. 대부분은 선택한 개체에 작용합니다. 나머지는 현재 보고 있는 페이지에서 수행됩니다.', + colCommand: '명령', + colDesc: '기능', + }, + revealing: { + heading: '공개 작동 방식', + points: [ + '토큰 레이어에 있는 토큰만 헥스를 공개합니다. 어떤 토큰이 해당되는지는 공개하는 토큰 설정으로 정합니다. 기본값은 플레이어 토큰이므로 GM은 지도를 드러내지 않고 몬스터를 움직일 수 있습니다.', + '토큰은 해당 토큰이 포함하는 모든 헥스를 표시하며(큰 토큰은 여러 개를 포함) 경로를 따라 표시를 설정하면 웨이포인트를 포함하여 드래그된 경로의 모든 헥스를 표시합니다.', + '시야 거리는 그 각 헥스 주변의 헥스를 가까운 것부터 공개합니다. 시선이 켜져 있으면, 헥스와 토큰 사이에 덮인 헥스가 있는 동안에는 그 헥스가 공개되지 않습니다. 보통 가까운 헥스가 먼저 공개되므로 탁 트인 지형에서는 시선이 아무것도 바꾸지 않습니다. 시야 거리가 2 이상이고, 헥스 공개 거리로 채운 지형처럼 계속 덮여 있는 헥스가 있을 때만 의미가 있습니다.', + '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', + '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', + 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + ], + }, + locations: { + heading: '명명된 육각형 및 위치', + points: [ + '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', + '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', + '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다. Jumpgate는 GM 레이어를 전경 레이어 아래에 그리므로, Jumpgate에서는 헥스 레이어 설정이 토큰 레이어로 되어 있을 때만 라벨이 표시됩니다.', + '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', + ], + }, + settings: { + heading: '설정', + intro: + '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', + colKey: '열쇠', + colName: '환경', + colDesc: '설명', + perPage: '(페이지별로 설정 가능합니다.)', + }, + jumpgate: { + heading: 'Jumpgate와 Legacy', + points: [ + 'Hexploration은 게임이 어떤 엔진을 사용하는지 알아내고 그에 맞는 모양을 그립니다. 어느 편집기에서 그린 도형이든 채울 수 있습니다.', + '헥스 레이어를 자동으로 설정하면 헥스가 토큰 위의 전경 레이어에 그려지므로 플레이어는 그 아래에 무엇이 있는지 볼 수 없습니다. 전경 레이어를 사용할 수 없으면 대신 토큰 레이어를 사용합니다.', + 'Jumpgate는 수학적으로 정확한 정육각형 헥스를 그리므로 Legacy 헥스와 모양이 약간 다릅니다. 헥스가 페이지 격자와 맞지 않으면 토큰 하나를 헥스 중심에 스냅하고 선택한 뒤 보정을 클릭하세요. 같은 행(Hex V) 또는 열(Hex H)의 이웃한 헥스에 있는 토큰 두 개를 선택하면 헥스 크기까지 보정합니다.', + '페이지나 게임이 복사되면 해당 헥스에 새 ID가 부여됩니다. 페이지에서 다시 스캔을 실행하여 이름 라벨 및 위치 토큰과 함께 다시 가져옵니다.', + ], + }, + upgrading: { + heading: '버전 1에서 업그레이드', + points: [ + '버전 2에는 더 이상 PathMath, MatrixMath, Vector Math 또는 HTML Builder가 필요하지 않습니다. 다른 모드에서 사용하지 않는 한 제거할 수 있습니다.', + '기존 헥스 지도, 이름, 위치 토큰과 설정은 처음 시작할 때 자동으로 업그레이드됩니다.', + 'Hexploration_menu 매크로를 포함한 버전 1 명령은 여전히 작동합니다.', + '버전 1에서는 캐릭터를 나타내는 토큰이면 무엇이든 헥스를 공개할 수 있었습니다. 이 동작을 유지하려면 공개하는 토큰을 캐릭터 토큰으로 설정하세요.', + ], + colV1: '버전 1 명령', + colV2: '버전 2 명령', + }, + troubleshooting: { + heading: '문제 해결', + points: [ + '토큰을 움직여도 아무 일도 일어나지 않음: 토큰이 토큰 레이어에 있고 공개하는 토큰 설정과 일치하는지, 페이지에 헥스가 있는지(!hexploration status) 확인하세요.', + '헥스가 격자에서 어긋남: 보정을 사용한 다음, 지도 곳곳의 몇몇 헥스에 토큰을 놓아 확인하세요.', + '페이지나 게임을 복사한 뒤 헥스가 더 이상 공개되지 않음: 해당 페이지에서 다시 스캔을 실행하세요.', + '채우기에서 영역에 헥스 중심이 없다고 나옴: 모양 안에 적어도 헥스 하나의 중심이 들어 있어야 합니다.', + '그 밖의 사항은 API 콘솔 로그를 확인하고 도움을 요청할 때 해당 메시지를 포함하세요.', + ], + }, + languages: { + heading: '언어', + body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', + colLanguage: '언어', + colNative: '현지어 이름', + colCode: '암호', + }, + credits: { + heading: '크레딧', + original: '원본 모드 제작자', + maintainer: '버전 2는 다음에 의해 유지 관리됩니다.', + marketplace: 'Roll20 마켓플레이스의 Ada 아트 팩', + support: + '버그를 발견하거나 아이디어가 있는 경우 Roll20 Mod 포럼에 게시하거나 GitHub에서 문제를 열고 API 콘솔 로그의 메시지를 포함하세요.', + }, + }, + }; + + const TRANSLATION$7 = { + titles: { + ready: 'Hexploration jest gotowy.', + settings: 'Ustawienia Hexploration', + languages: 'Wybierz język', + pageSettings: 'Ustawienia strony: {page}', + status: 'Stan Hexploration: {page}', + help: 'Polecenia Hexploration', + confirm: 'Proszę potwierdzić', + }, + discovery: { + title: 'Odkryto lokalizację', + }, + menu: { + draw: 'Rysowanie', + reveal: 'Odkrywanie i ukrywanie', + locations: 'Lokalizacje', + tools: 'Narzędzia', + layerInUse: 'Warstwa, na której rysowane są nowe heksy: {layer}.', + pageSettingsHelp: + 'Te ustawienia dotyczą tylko tej strony. Ustawienia oznaczone ★ zastępują ustawienia globalne.', + }, + buttons: { + fill: 'Wypełnij', + fillInverse: 'Odwrotne wypełnienie', + undo: 'Cofnij wypełnienie', + reveal: 'Odkryj', + conceal: 'Zakryj', + explore: 'Eksploruj', + revealPage: 'Odkryj stronę', + resetPage: 'Zresetuj stronę', + mark: 'Oznacz lokalizację', + unmark: 'Usuń oznaczenie', + name: 'Nazwij heks', + settings: 'Ustawienia', + pageSettings: 'Ustawienia strony', + status: 'Status', + rescan: 'Skanuj ponownie', + calibrate: 'Kalibruj', + calibrateReset: 'Zresetuj kalibrację', + help: 'Pomoc', + change: 'Zmień', + menu: 'Menu', + clearOverrides: 'Usuń nadpisania', + confirmReset: 'Tak, usuń wszystkie heksy', + }, + prompts: { + name: 'Nazwa lokalizacji (pozostaw puste, aby wyczyścić)', + }, + values: { + on: 'Włączone', + off: 'Wyłączone', + none: 'Brak', + hexLayer: { + auto: 'Auto (pierwszy plan, jeśli jest dostępny)', + foreground: 'warstwa pierwszego planu', + objects: 'warstwa żetonów', + }, + revealBy: { + players: 'Żetony graczy', + characters: 'Żetony postaci', + all: 'Wszystkie żetony', + }, + revealMode: { + clear: 'Usuwanie', + glimpse: 'Przebłysk', + }, + announce: { + all: 'Wszyscy', + gm: 'Tylko MG', + off: 'Wyłączone', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Wypełnij', + fillInverse: 'Odwrotne wypełnienie', + conceal: 'Zakryj', + }, + }, + settings: { + language: { + label: 'Język', + desc: 'Język menu, komunikatów i materiałów informacyjnych.', + }, + hexLayer: { + label: 'Warstwa heksagonów', + desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', + }, + fillColor: { + label: 'Kolor wypełnienia', + desc: 'Kolor nowych heksów. Użyj rgba() dla przezroczystych heksów, na przykład rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kolor obramowania', + desc: 'Kolor konturu nowych heksów.', + }, + labelColor: { + label: 'Kolor etykiety', + desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + }, + glimpseColor: { + label: 'Kolor przebłysku', + desc: 'Kolor, jaki przyjmują heksy objęte przebłyskiem (tryb odkrywania Przebłysk). Użyj przezroczystego koloru rgba().', + }, + strokeWidth: { + label: 'Szerokość obramowania', + desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', + }, + maxDistance: { + label: 'Odległość odkrywania heksagonów', + desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', + }, + revealDistance: { + label: 'Zasięg wzroku', + desc: 'Ile heksów wokół poruszającego się żetonu zostało odkrytych (od 0 do 20). 0 ujawnia tylko heksy, przez które przechodzi żeton.', + }, + lineOfSight: { + label: 'Linia wzroku', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', + }, + revealPath: { + label: 'Odkrywaj wzdłuż ścieżki', + desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + }, + revealBy: { + label: 'Żetony odkrywające', + desc: 'Które żetony na warstwie żetonów odsłaniają heksy: żetony kontrolowane przez gracza, żetony reprezentujące dowolną postać lub każdy żeton.', + }, + revealMode: { + label: 'Tryb odkrywania', + desc: 'Usuwanie usuwa heksy w zasięgu wzroku. Przebłysk zamiast tego czyni je przezroczystymi; są usuwane, gdy wejdzie na nie żeton.', + }, + announce: { + label: 'Ogłaszaj odkrycia', + desc: 'Kto widzi wiadomość na czacie po odkryciu nazwanej lokalizacji.', + }, + pingDiscoveries: { + label: 'Pinguj odkrycia', + desc: 'Gdy ta opcja jest włączona, gracze są wysyłani sygnałem ping do nazwanej lokalizacji po jej wykryciu.', + }, + hideCoveredTokens: { + label: 'Ukrywaj zakryte żetony', + desc: 'Roll20 rysuje nazwy, słupki i aury nad heksami. Kiedy jest włączone, żetony pod zakrytym heksem mają widoczną dla gracza nazwę, paski i aury wyłączone i włączane ponownie, gdy zostaną odkryte.', + }, + }, + status: { + engine: 'Silnik gry', + grid: 'Siatka', + layer: 'Warstwa heksagonów', + hexes: 'Heksy', + named: 'Nazwane heksy', + icons: 'Żetony lokalizacji', + glimpsed: 'Heksy w przebłysku', + pending: 'Lokalizacje czekające na wypełnienie', + calibrated: 'Skalibrowano', + overrides: 'Nadpisania strony', + undo: 'Można cofnąć', + }, + messages: { + filled: + 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + revealed: 'Ujawnione heksy: {count}.', + revealedPage: 'Każdy odkryty heks na stronie ({count}).', + confirmReset: + 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', + resetPage: 'Heksy usunięte ze strony: {count}.', + undone: + 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + named: 'Heksy o nazwie „{name}”: {count}.', + unnamed: 'Nazwy zostały usunięte: {count}.', + marked: + 'Lokalizacje ukryte na istniejących heksach: {attached}. Czekam na następne wypełnienie, które je obejmuje: {pending}.', + unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', + settingChanged: '{setting} ustawiony na {value}.', + rescanned: + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + calibrated: + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + calibrationReset: + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', + migrated: + 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', + pruned: + 'Zapisane heksy, które już nie istnieją i zostały zapomniane: {dropped}. Jeśli ta gra lub strona została skopiowana, uruchom „Skanuj ponownie” na stronie, aby ponownie odnaleźć jej heksy.', + readyHint: + 'Wpisz !hexploration, aby otworzyć menu, lub otwórz materiał informacyjny "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ta gra nie obsługuje rysowania na warstwie pierwszego planu, więc heksy zostały narysowane na warstwie żetonów.', + someFailed: + 'Heksy, których nie można narysować: {count}. Aby uzyskać szczegółowe informacje, sprawdź konsolę API.', + }, + errors: { + noPage: 'Nie udało się znaleźć strony, nad którą można pracować.', + notHex: 'Ta strona nie używa siatki heksowej.', + noPolygons: 'Wybierz jeden lub więcej narysowanych kształtów do wypełnienia.', + emptyArea: 'Zaznaczony obszar nie zawiera żadnych środków heksów.', + tooMany: 'Spowodowałoby to utworzenie zbyt wielu heksów za jednym razem ({count}).', + nothingToConceal: 'Wybierz narysowane kształty lub żetony do ukrycia.', + nothingToReveal: 'Wybierz heksy, narysowane kształty lub żetony do odsłonięcia.', + noTokens: 'Najpierw wybierz jeden lub więcej tokenów.', + noHexes: 'Najpierw wybierz jeden lub więcej heksów (lub żetonów stojących na heksach).', + nothingToUndo: 'Nie ma wypełnienia, które można cofnąć.', + unknownCommand: 'Nieznane polecenie: {command}', + unknownSetting: 'Nieznane ustawienie: {key}', + unknownPageSetting: 'Ustawienia, które można ustawić na stronie: {keys}', + invalidValue: '„{value}” nie jest prawidłową wartością dla {key}.', + calibrateNeedsTokens: 'Wybierz jeden lub dwa żetony przyciągnięte do środków heksów.', + calibrateFailed: 'Tych tokenów nie można używać do kalibracji.', + unexpected: 'Coś poszło nie tak: {message}', + }, + hints: { + noPage: 'Otwórz stronę, nad którą chcesz pracować, lub wybierz coś na niej.', + notHex: 'Ustaw siatkę strony na Hex (V) lub Hex (H) w Ustawieniach strony.', + noPolygons: + 'Narysuj wielokąt, prostokąt, elipsę lub odręczny kształt wokół obszaru, zaznacz go i spróbuj ponownie.', + emptyArea: 'Narysuj większy kształt lub sprawdź ustawienia siatki strony.', + tooMany: 'Wypełnij mniejszy obszar lub podziel obszar na kilka kształtów.', + noHexes: + 'Heksy znajdują się na pierwszym planie lub w warstwie żetonów; przejdź do tej warstwy, aby je wybrać.', + unknownCommand: 'Wpisz !hexploration help, aby wyświetlić listę poleceń.', + unknownSetting: 'Wpisz !hexploration set, aby zobaczyć wszystkie ustawienia.', + calibrateNeedsTokens: + 'Przyciągnij żeton do środka heksa i wybierz go. Wybierz drugi żeton przyciągnięty do sąsiedniego heksu w tym samym rzędzie (Hex V) lub kolumnie (Hex H), aby również skorygować rozmiar heksa.', + calibrateFailed: + 'Dwa żetony muszą znajdować się w tym samym rzędzie (Hex V) lub w tej samej kolumnie (Hex H), w odległości co najmniej jednego heksa od siebie.', + unexpected: 'Szczegóły znajdują się w dzienniku konsoli API.', + }, + help: { + menu: 'Pokaż menu.', + fill: 'Zakryj wybrane narysowane kształty heksami.', + fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', + undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', + revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', + conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', + explore: 'Odsłoń wokół wybranych żetonów tak, jakby właśnie się tam przesunęły.', + resetPage: 'Usuń wszystkie heksy na stronie (najpierw pyta).', + name: 'Nazwij wybrane heksy lub heksy pod wybranymi żetonami. Pozostaw nazwę pustą, aby ją wyczyścić.', + mark: 'Zamień wybrane żetony w ukryte lokalizacje.', + unmark: 'Spraw, by zaznaczone żetony przestały być ukrytymi lokalizacjami.', + set: 'Zmień ustawienie lub pokaż wszystkie ustawienia.', + pageSet: 'Zastąp ustawienie odkrywania tylko na bieżącej stronie.', + pageClear: 'Usuń zastąpienia bieżącej strony.', + rescan: 'Odbuduj listę heksów strony, na przykład po skopiowaniu strony lub gry.', + calibrate: + 'Wyrównaj siatkę heksów jednym lub dwoma wybranymi żetonami przyczepionymi do środków heksów.', + calibrateReset: 'Usuń kalibrację bieżącej strony.', + status: 'Pokaż, co Hexploration wie o bieżącej stronie.', + journal: 'Odbuduj materiały informacyjne „Pomoc” i „Command Deck”.', + help: 'Pokaż tę listę.', + handout: 'Pełne instrukcje znajdują się w ulotce „{name}”.', + }, + deck: { + drawDesc: + 'Narysuj kształty wokół obszaru, zaznacz je, a następnie wypełnij. Cofnij odwraca ostatnie wypełnienie.', + revealDesc: + 'Zaznacz heksy, kształty lub żetony, aby je odkryć lub ponownie zakryć. „Eksploruj” odkrywa okolicę zaznaczonych żetonów, jakby właśnie się przesunęły.', + locationsDesc: + 'Wybierz żetony, aby ukryć je jako lokalizacje pod heksami. Wybierz heksy lub żetony, aby nazwać heks.', + toolsDesc: + 'Ustawienia, nadpisania stron, status, ponowne skanowanie skopiowanych stron i kalibracja siatki.', + footer: 'Pełne instrukcje znajdziesz w ulotce „{help}”.', + }, + handout: { + versionLabel: 'Wersja', + subtitle: 'Eksploracja heks po heksie dla Roll20', + footer: + 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + overview: { + heading: 'Przegląd', + body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (od wersji 1)', + }, + quickStart: { + heading: 'Szybki start', + steps: [ + 'Otwórz stronę, której siatka jest ustawiona na Hex (V) lub Hex (H).', + 'Narysuj jeden lub więcej kształtów (wielokąt, prostokąt, elipsa lub odręcznie) wokół obszaru, który chcesz ukryć.', + 'Zaznacz kształty i kliknij „Wypełnij” w Command Deck (lub wpisz !hexploration fill). Kształty zostaną zastąpione heksami.', + 'Opcjonalnie: przed wypełnieniem zaznacz żetony ważnych miejsc i kliknij „Oznacz lokalizację”. Zostaną ukryte pod heksami i ogłoszone po odkryciu.', + 'Przesuń żeton gracza. Każdy heks, przez który przejdzie, oraz heksy w jego zasięgu wzroku (ustawienie „Zasięg wzroku”) zostaną odkryte.', + ], + }, + commands: { + heading: 'Polecenia', + intro: + 'Tylko MG mogą używać tych poleceń. Większość działa na wybrane obiekty; reszta działa na stronie, którą przeglądasz.', + colCommand: 'Polecenie', + colDesc: 'Co to robi', + }, + revealing: { + heading: 'Jak działa odkrywanie', + points: [ + 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', + 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', + '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', + 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', + 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', + ], + }, + locations: { + heading: 'Nazwane heksy i lokalizacje', + points: [ + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', + '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', + ], + }, + settings: { + heading: 'Ustawienia', + intro: + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + colKey: 'Klucz', + colName: 'Ustawienie', + colDesc: 'Opis', + perPage: '(Można ustawić na stronę.)', + }, + jumpgate: { + heading: 'Jumpgate i Dziedzictwo', + points: [ + 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', + 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', + ], + }, + upgrading: { + heading: 'Aktualizacja z wersji 1', + points: [ + 'Wersja 2 nie potrzebuje już PathMath, MatrixMath, Vector Math ani HTML Builder. Możesz je usunąć, chyba że użyje ich inny mod.', + 'Istniejące mapy heksów, nazwy, tokeny lokalizacji i ustawienia są aktualizowane automatycznie przy pierwszym uruchomieniu.', + 'Polecenia wersji 1, w tym makro Hexploration_menu, nadal działają.', + 'W wersji 1 heksy mógł odkrywać każdy żeton reprezentujący postać. Aby zachować to zachowanie, ustaw „Żetony odkrywające” na „Żetony postaci”.', + ], + colV1: 'Polecenie wersji 1', + colV2: 'Polecenie wersji 2', + }, + troubleshooting: { + heading: 'Rozwiązywanie problemów', + points: [ + 'Nic się nie dzieje, gdy żeton się porusza: sprawdź, czy żeton jest na warstwie żetonów i pasuje do ustawienia „Żetony odkrywające” oraz czy strona ma heksy (!hexploration status).', + 'Heksy są przesunięte względem siatki: użyj opcji Kalibruj, a następnie sprawdź za pomocą żetonu na kilku heksach na mapie.', + 'Heksy przestały się odkrywać po skopiowaniu strony lub gry: uruchom „Skanuj ponownie” na stronie.', + '„Wypełnij” zgłasza, że obszar nie zawiera środków heksów: kształt musi zawierać środek co najmniej jednego heksu.', + 'W innych przypadkach sprawdź dziennik konsoli API i dołącz zawarte w nim komunikaty, prosząc o pomoc.', + ], + }, + languages: { + heading: 'Języki', + body: 'Wybierz język poleceniem !hexploration set language. Dostępne języki:', + colLanguage: 'Język', + colNative: 'Nazwa rodzima', + colCode: 'Kod', + }, + credits: { + heading: 'Kredyty', + original: 'Oryginalny mod autorstwa', + maintainer: 'Wersja 2 obsługiwana przez', + marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', + support: + 'Jeśli znajdziesz błąd lub masz pomysł, opublikuj post na forum Roll20 Mod lub otwórz problem w GitHub i dołącz wszelkie komunikaty z dziennika konsoli API.', + }, + }, + }; + + const TRANSLATION$6 = { + titles: { + ready: 'O Hexploration está pronto.', + settings: 'Definições do Hexploration', + languages: 'Escolha um idioma', + pageSettings: 'Definições da página: {page}', + status: 'Estado do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Local descoberto', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Os novos hexágonos estão a ser desenhados na {layer}.', + pageSettingsHelp: + 'Estas definições aplicam-se somente a esta página. As definições marcadas com ★ substituem as definições globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar local', + unmark: 'Desmarcar', + name: 'Nomear hexágono', + settings: 'Definições', + pageSettings: 'Definições da página', + status: 'Estado', + rescan: 'Reanalisar', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Alterar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixar em branco para limpar)', + }, + values: { + on: 'Ligado', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de fichas', + }, + revealBy: { + players: 'Fichas de jogador', + characters: 'Fichas de personagem', + all: 'Todas as fichas', + }, + revealMode: { + clear: 'Limpar', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Toda a gente', + gm: 'Apenas o GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada dos hexágonos', + desc: 'Onde são desenhados os novos hexágonos. Automático tenta a camada de primeiro plano (acima das fichas) e recorre à camada de fichas se o jogo não a suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Utilize rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor da etiqueta', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Utilize uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixéis (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação dos hexágonos', + desc: 'Guardada nos hexágonos quando são preenchidos, por isso defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, este número de hexágonos para os revelar, por mais longe que consiga ver; com 0, só são revelados quando se entra neles. Utilize-a para montanhas ou florestas. Deixe em branco para não haver limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, os hexágonos que continuam cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos que estão por trás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', + }, + revealPath: { + label: 'Revelar ao longo do percurso', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + }, + revealBy: { + label: 'Fichas que revelam', + desc: 'Quais as fichas na camada de fichas que revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. Vislumbre torna-os transparentes; são removidos quando uma ficha entra neles.', + }, + announce: { + label: 'Anunciar descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Pingar descobertas', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando este é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar fichas cobertas', + desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grelha', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos nomeados', + icons: 'Fichas de local', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Locais a aguardar preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições da página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', + unmarked: 'Tokens que já não são locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + calibrated: + 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', + pruned: + 'Hexágonos guardados que já não existem e foram esquecidos: {dropped}. Se este jogo ou página tiver sido copiado, execute Reanalisar na página para recuperar os seus hexágonos.', + readyHint: + 'Escreva !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não utiliza uma grelha hexagonal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', + tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione primeiro um ou mais tokens.', + noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', + nothingToUndo: 'Não há enchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', + calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + unexpected: 'Algo correu mal: {message}', + }, + hints: { + noPage: 'Abra a página na qual pretende trabalhar ou selecione algo da mesma.', + notHex: 'Defina a grelha da página para Hex (V) ou Hex (H) nas Definições da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre à volta da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', + tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + unknownCommand: 'Introduza !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as definições.', + calibrateNeedsTokens: + 'Encaixe uma ficha no centro de um hexágono e selecione-a. Selecione uma segunda ficha encaixada num hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + calibrateFailed: + 'As duas fichas têm de estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', + unexpected: 'Os detalhes estão no log da consola da API.', + }, + help: { + menu: 'Mostre o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: + 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma definição ou mostre todas as definições.', + pageSet: 'Substituir uma configuração de revelação apenas na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', + calibrate: + 'Alinhe a grelha hexagonal com uma ou duas fichas selecionadas encaixadas em centros de hexágonos.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + drawDesc: + 'Desenhe formas à volta de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou fichas para os revelar ou voltar a cobrir. Explorar revela à volta das fichas selecionadas como se se tivessem movido.', + locationsDesc: + 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', + toolsDesc: + 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + footer: 'Consulte o folheto "{help}" para obter as instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexágono a hexágono para Roll20', + footer: 'Utilize o folheto "{deck}" para controlos de um clique.', + overview: { + heading: 'Visão geral', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se desloca, os hexágonos por onde passa (e, se quiser, os hexágonos à sua volta) são removidos, pelo que o mapa é descoberto um hexágono de cada vez. Podem ser colocados locais escondidos sob os hexágonos, que são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grelhas Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grelha esteja definida para Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) à volta da área a ocultar.', + 'Selecione as formas e clique em Preencher no Command Deck (ou escreva !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione fichas de locais importantes e clique em Marcar local. Ficam escondidas sob os hexágonos e são anunciadas quando descobertas.', + 'Mova uma ficha de jogador. Cada hexágono por onde passa e os hexágonos dentro da sua Distância de visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Apenas os GMs podem usar estes comandos. A maioria atua sobre os objetos selecionados; o resto atua na página que está a visualizar.', + colCommand: 'Comando', + colDesc: 'O que faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas as fichas na camada de fichas revelam hexágonos. Quais as fichas que contam é definido por Fichas que revelam: fichas de jogador por predefinição, para que o GM possa mover monstros sem descobrir o mapa.', + 'Uma ficha revela cada hexágono que cobre (as fichas grandes cobrem vários) e, com Revelar ao longo do percurso ativado, cada hexágono do percurso pelo qual foi arrastada, incluindo os pontos de passagem.', + 'A Distância de visão revela os hexágonos em torno de cada um destes hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto existir um hexágono coberto entre ele e a ficha. Os hexágonos mais próximos são normalmente revelados primeiro, por isso em terreno aberto a Linha de visão não altera nada: só tem importância com uma Distância de visão de 2 ou mais e hexágonos que continuam cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é guardada em cada hexágono quando este é preenchido, por isso defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha tem de estar a, no máximo, esse número de hexágonos para os revelar, por mais longe que consiga ver, e com 0 só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e depois preencha as terras mais além. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto à sua volta, mas não as montanhas nem o que está por trás delas. Cada hexágono de montanha é revelado quando uma ficha entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecerem e são removidos quando uma ficha entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', + 'O Roll20 desenha os nomes, barras e auras das fichas por cima dos hexágonos. Com Ocultar fichas cobertas ativado, uma ficha sob um hexágono coberto tem o nome, as barras e as auras visíveis para os jogadores desativados até ser descoberta, para que os monstros escondidos não se denunciem. Se ativar um deles enquanto a ficha estiver coberta, este continua oculto e é ativado quando a ficha for descoberta.', + 'A API não reporta movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione as fichas e clique em Explorar, ou chame Hexploration.revealAround(token) a partir do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', + 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as definições com !hexploration set (ou com o botão Definições). Camada dos hexágonos, Fichas que revelam e Idioma também podem ser definidos na página de definições do Mod.', + colKey: 'Chave', + colName: 'Definição', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com uma forma ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não ficarem alinhados com a grelha da página, encaixe uma ficha no centro de um hexágono, selecione-a e clique em Calibrar. Selecione duas fichas em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, os seus hexágonos recebem novos IDs. Execute Reanalisar na página para os voltar a apanhar, juntamente com as suas etiquetas de nome e fichas de local.', + ], + }, + upgrading: { + heading: 'Atualização da versão 1', + points: [ + 'A versão 2 já não precisa de PathMath, MatrixMath, Vector Math ou HTML Builder. Pode removê-los, a menos que outro mod os utilize.', + 'Os mapas de hexágonos, nomes, fichas de localização e definições existentes são atualizados automaticamente no primeiro arranque.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer ficha que representasse uma personagem revelasse hexágonos. Defina Fichas que revelam como Fichas de personagem para manter este comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando uma ficha se move: verifique se a ficha está na camada de fichas e corresponde a Fichas que revelam, e se a página tem hexágonos (!hexploration status).', + 'Os hexágonos estão desalinhados com a grelha: use Calibrar e verifique depois com uma ficha em alguns hexágonos do mapa.', + 'Os hexágonos deixaram de ser revelados após copiar uma página ou jogo: execute Reanalisar na página.', + 'Preencher indica que a área não tem centros de hexágonos: a forma tem de conter o centro de pelo menos um hexágono.', + 'Para qualquer outra coisa, verifique o registo da consola da API e inclua as suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Idioma', + colNative: 'Nome original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versão 2 mantida pela', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', + }, + }, + }; + + const TRANSLATION$5 = { + titles: { + ready: 'O Hexploration está pronto.', + settings: 'Configurações do Hexploration', + languages: 'Escolha um idioma', + pageSettings: 'Configurações da página: {page}', + status: 'Status do Hexploration: {page}', + help: 'Comandos do Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Local descoberto', + }, + menu: { + draw: 'Desenhar', + reveal: 'Revelar e ocultar', + locations: 'Locais', + tools: 'Ferramentas', + layerInUse: 'Novos hexágonos estão sendo desenhados na {layer}.', + pageSettingsHelp: + 'Essas configurações se aplicam somente a esta página. As configurações marcadas com ★ substituem as configurações globais.', + }, + buttons: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + undo: 'Desfazer preenchimento', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Redefinir página', + mark: 'Marcar local', + unmark: 'Desmarcar', + name: 'Nomear hexágono', + settings: 'Configurações', + pageSettings: 'Configurações da página', + status: 'Status', + rescan: 'Reescanear', + calibrate: 'Calibrar', + calibrateReset: 'Redefinir calibração', + help: 'Ajuda', + change: 'Alterar', + menu: 'Menu', + clearOverrides: 'Limpar substituições', + confirmReset: 'Sim, remover todos os hexágonos', + }, + prompts: { + name: 'Nome do local (deixe em branco para limpar)', + }, + values: { + on: 'Ligado', + off: 'Desligado', + none: 'Nenhum', + hexLayer: { + auto: 'Automático (primeiro plano, se disponível)', + foreground: 'camada de primeiro plano', + objects: 'camada de tokens', + }, + revealBy: { + players: 'Tokens de jogador', + characters: 'Tokens de personagem', + all: 'Todos os tokens', + }, + revealMode: { + clear: 'Limpar', + glimpse: 'Vislumbre', + }, + announce: { + all: 'Todos', + gm: 'Apenas GM', + off: 'Desligado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Preencher', + fillInverse: 'Preenchimento inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menus, mensagens e folhetos.', + }, + hexLayer: { + label: 'Camada dos hexágonos', + desc: 'Onde novos hexágonos são desenhados. Auto tenta a camada de primeiro plano (acima dos tokens) e volta para a camada de tokens se o jogo não suportar.', + }, + fillColor: { + label: 'Cor de preenchimento', + desc: 'Cor dos novos hexágonos. Use rgba() para hexágonos transparentes, por exemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Cor da borda', + desc: 'Cor do contorno dos novos hexágonos.', + }, + labelColor: { + label: 'Cor do rótulo', + desc: 'Cor dos rótulos de nomes exclusivos do GM em hexágonos nomeados.', + }, + glimpseColor: { + label: 'Cor do vislumbre', + desc: 'Cor que os hexágonos assumem quando vislumbrados (modo de revelação Vislumbre). Use uma cor rgba() transparente.', + }, + strokeWidth: { + label: 'Largura da borda', + desc: 'Largura do contorno dos novos hexágonos, em pixels (0 a 20).', + }, + maxDistance: { + label: 'Distância de revelação dos hexágonos', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', + }, + revealDistance: { + label: 'Distância de visão', + desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + }, + lineOfSight: { + label: 'Linha de visão', + desc: 'Quando ativado, os hexágonos que permanecem cobertos, como montanhas preenchidas com uma Distância de revelação dos hexágonos, escondem os hexágonos atrás deles. Só faz diferença com uma Distância de visão de 2 ou mais.', + }, + revealPath: { + label: 'Revelar ao longo do caminho', + desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + }, + revealBy: { + label: 'Tokens que revelam', + desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + }, + revealMode: { + label: 'Modo de revelação', + desc: 'Limpar remove os hexágonos à vista. Vislumbre os torna transparentes; eles são removidos quando um token entra neles.', + }, + announce: { + label: 'Anunciar descobertas', + desc: 'Quem vê a mensagem do chat quando um local nomeado é descoberto.', + }, + pingDiscoveries: { + label: 'Pingar descobertas', + desc: 'Quando ativado, os jogadores recebem um ping para um local nomeado quando ele é descoberto.', + }, + hideCoveredTokens: { + label: 'Ocultar tokens cobertos', + desc: 'Roll20 desenha nomes, barras e auras acima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm seu nome, barras e auras visíveis ao jogador desligados e ligados novamente quando são descobertos.', + }, + }, + status: { + engine: 'Motor de jogo', + grid: 'Grade', + layer: 'Camada dos hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos nomeados', + icons: 'Tokens de local', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Locais aguardando preenchimento', + calibrated: 'Calibrado', + overrides: 'Substituições da página', + undo: 'Desfazer disponível', + }, + messages: { + filled: + 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', + revealed: 'Feitiços revelados: {count}.', + revealedPage: 'Cada hexágono da página revelado ({count}).', + confirmReset: + 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', + resetPage: 'Hexágonos removidos da página: {count}.', + undone: + 'Último preenchimento desfeito. Hexágonos removidos: {removed}. Hexágonos reestilizados restaurados: {restored}.', + named: 'Hexágonos chamados "{name}": {count}.', + unnamed: 'Nomes apagados: {count}.', + marked: + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + unmarked: 'Tokens que não são mais locais: {count}.', + settingChanged: '{setting} definido como {value}.', + rescanned: + 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + calibrated: + 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + calibrationReset: + 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', + migrated: + 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', + pruned: + 'Hexágonos salvos que não existem mais e foram esquecidos: {dropped}. Se este jogo ou página foi copiado, execute Reescanear na página para recuperar seus hexágonos.', + readyHint: + 'Digite !hexploration para abrir o menu ou abra o folheto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + someFailed: + 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', + }, + errors: { + noPage: 'Não foi possível encontrar a página para trabalhar.', + notHex: 'Esta página não usa uma grade hexagonal.', + noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', + emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', + tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', + nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + noTokens: 'Selecione um ou mais tokens primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + nothingToUndo: 'Não há preenchimento para desfazer.', + unknownCommand: 'Comando desconhecido: {command}', + unknownSetting: 'Configuração desconhecida: {key}', + unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', + invalidValue: '"{value}" não é um valor válido para {key}.', + calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', + calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + unexpected: 'Algo deu errado: {message}', + }, + hints: { + noPage: 'Abra a página na qual deseja trabalhar ou selecione algo nela.', + notHex: 'Defina a grade da página como Hex (V) ou Hex (H) nas Configurações da página.', + noPolygons: + 'Desenhe um polígono, retângulo, elipse ou forma à mão livre ao redor da área, selecione-o e tente novamente.', + emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', + tooMany: 'Preencha uma área menor ou divida a área em várias formas.', + noHexes: + 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + unknownCommand: 'Digite !hexploration help para listar os comandos.', + unknownSetting: 'Digite !hexploration set para ver todas as configurações.', + calibrateNeedsTokens: + 'Encaixe um token no centro de um hexágono e selecione-o. Selecione um segundo token encaixado em um hexágono vizinho na mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + calibrateFailed: + 'Os dois tokens devem estar na mesma linha (Hex V) ou na mesma coluna (Hex H), a pelo menos um hexágono de distância.', + unexpected: 'Os detalhes estão no log do console da API.', + }, + help: { + menu: 'Mostrar o menu.', + fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', + fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', + undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + reveal: + 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + revealPage: 'Revele cada hexágono da página sem anúncios.', + conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + explore: + 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', + resetPage: 'Remova todos os hexágonos da página (pergunta antes).', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para limpá-lo.', + mark: 'Transforme os tokens selecionados em locais ocultos.', + unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + set: 'Altere uma configuração ou mostre todas as configurações.', + pageSet: 'Substituir uma configuração de revelação somente na página atual.', + pageClear: 'Remova as substituições da página atual.', + rescan: + 'Reconstrua a lista de hexágonos da página, por exemplo, depois de copiar uma página ou um jogo.', + calibrate: + 'Alinhe a grade hexagonal com um ou dois tokens selecionados encaixados em centros de hexágonos.', + calibrateReset: 'Remova a calibração da página atual.', + status: 'Mostre o que o Hexploration sabe sobre a página atual.', + journal: 'Reconstrua os folhetos de Ajuda e do Command Deck.', + help: 'Mostre esta lista.', + handout: 'As instruções completas estão no folheto "{name}".', + }, + deck: { + drawDesc: + 'Desenhe formas ao redor de uma área, selecione-as e preencha. Desfazer reverte o último preenchimento.', + revealDesc: + 'Selecione hexágonos, formas ou tokens para revelá-los ou cobri-los novamente. Explorar revela ao redor dos tokens selecionados como se eles tivessem se movido.', + locationsDesc: + 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', + toolsDesc: + 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + footer: 'Consulte o folheto "{help}" para obter instruções completas.', + }, + handout: { + versionLabel: 'Versão', + subtitle: 'Exploração hexágono a hexágono para Roll20', + footer: 'Use o folheto "{deck}" para controles de um clique.', + overview: { + heading: 'Visão geral', + body: 'O Hexploration cobre um mapa hexagonal com hexágonos opacos. À medida que o grupo se move, os hexágonos pelos quais ele passa (e, se você quiser, os hexágonos ao redor) são removidos, de modo que o mapa é descoberto um hexágono por vez. Locais ocultos podem ser colocados sob os hexágonos e são anunciados quando encontrados. Funciona em jogos Jumpgate e Legacy, em grades Hex (V) e Hex (H) de qualquer tamanho.', + demo: 'Assista a uma breve demonstração (da versão 1)', + }, + quickStart: { + heading: 'Início rápido', + steps: [ + 'Abra uma página cuja grade esteja definida como Hex (V) ou Hex (H).', + 'Desenhe uma ou mais formas (polígono, retângulo, elipse ou à mão livre) ao redor da área a ser ocultada.', + 'Selecione as formas e clique em Preencher no Command Deck (ou digite !hexploration fill). As formas são substituídas por hexágonos.', + 'Opcional: antes de preencher, selecione tokens de locais importantes e clique em Marcar local. Eles ficam ocultos sob os hexágonos e são anunciados quando descobertos.', + 'Mova um token de jogador. Cada hexágono pelo qual ele passa e os hexágonos dentro da sua Distância de visão são revelados.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Somente GMs podem usar esses comandos. A maioria atua nos objetos selecionados; o resto atua na página que você está visualizando.', + colCommand: 'Comando', + colDesc: 'O que isso faz', + }, + revealing: { + heading: 'Como funciona a revelação', + points: [ + 'Apenas tokens na camada de tokens revelam hexágonos. Quais tokens contam é definido por Tokens que revelam: tokens de jogador por padrão, para que o GM possa mover monstros sem descobrir o mapa.', + 'Um token revela cada hexágono que cobre (tokens grandes cobrem vários) e, com Revelar ao longo do caminho ativado, cada hexágono da rota pela qual foi arrastado, incluindo os pontos de passagem.', + 'A Distância de visão revela os hexágonos em torno de cada um desses hexágonos, começando pelos mais próximos. Com a Linha de visão ativada, um hexágono não é revelado enquanto houver um hexágono coberto entre ele e o token. Os hexágonos mais próximos costumam ser revelados primeiro, então em terreno aberto a Linha de visão não muda nada: ela só importa com uma Distância de visão de 2 ou mais e hexágonos que permanecem cobertos, como terreno preenchido com uma Distância de revelação dos hexágonos.', + 'A Distância de revelação dos hexágonos é gravada em cada hexágono quando ele é preenchido, então defina-a antes de preencher; alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo essa quantidade de hexágonos para revelá-los, por mais longe que consiga ver, e com 0 eles só são revelados quando se entra neles. Para uma cordilheira: defina a Distância de revelação dos hexágonos como 0, preencha as montanhas, volte a deixá-la sem limite e então preencha as terras mais adiante. Com Distância de visão 3 e Linha de visão ativada, o grupo vê o terreno aberto ao seu redor, mas não as montanhas nem o que há atrás delas. Cada hexágono de montanha é revelado quando um token entra nele.', + 'No modo Vislumbre, os hexágonos à vista tornam-se transparentes em vez de desaparecer e são removidos quando um token entra neles. Os hexágonos vislumbrados não bloqueiam a Linha de visão.', + 'O Roll20 desenha nomes, barras e auras de tokens acima dos hexágonos. Com Ocultar tokens cobertos ativado, um token sob um hexágono coberto tem o nome, as barras e as auras visíveis aos jogadores desativados até ser descoberto, para que monstros escondidos não se denunciem. Se você ativar um deles enquanto o token estiver coberto, ele continua oculto e é ativado quando o token for descoberto.', + 'A API não relata movimentos feitos por outros mods. Os movimentos do TokenMod são captados automaticamente; para outros mods, selecione os tokens e clique em Explorar ou chame Hexploration.revealAround(token) do seu próprio mod.', + ], + }, + locations: { + heading: 'Hexes e locais nomeados', + points: [ + 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', + 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', + 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', + 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', + ], + }, + settings: { + heading: 'Configurações', + intro: + 'Altere as configurações com !hexploration set (ou com o botão Configurações). Camada dos hexágonos, Tokens que revelam e Idioma também podem ser definidos na página de configurações do Mod.', + colKey: 'Chave', + colName: 'Configuração', + colDesc: 'Descrição', + perPage: '(Pode ser definido por página.)', + }, + jumpgate: { + heading: 'Jumpgate e Legado', + points: [ + 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', + 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', + 'O Jumpgate desenha hexágonos matematicamente regulares, com um formato ligeiramente diferente dos hexágonos do Legacy. Se os hexágonos não se alinharem com a grade da página, encaixe um token no centro de um hexágono, selecione-o e clique em Calibrar. Selecione dois tokens em hexágonos vizinhos da mesma linha (Hex V) ou coluna (Hex H) para corrigir também o tamanho do hexágono.', + 'Quando uma página ou jogo é copiado, seus hexágonos recebem novos IDs. Execute Reescanear na página para recuperá-los, junto com seus rótulos de nome e tokens de local.', + ], + }, + upgrading: { + heading: 'Atualizando da versão 1', + points: [ + 'A versão 2 não precisa mais de PathMath, MatrixMath, Vector Math ou HTML Builder. Você pode removê-los, a menos que outro mod os use.', + 'Os mapas de hexágonos, nomes, tokens de localização e configurações existentes são atualizados automaticamente na primeira inicialização.', + 'Os comandos da versão 1, incluindo a macro Hexploration_menu, ainda funcionam.', + 'A versão 1 permitia que qualquer token que representasse um personagem revelasse hexágonos. Defina Tokens que revelam como Tokens de personagem para manter esse comportamento.', + ], + colV1: 'Comando da versão 1', + colV2: 'Comando da versão 2', + }, + troubleshooting: { + heading: 'Solução de problemas', + points: [ + 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', + 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', + 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', + 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', + colLanguage: 'Linguagem', + colNative: 'Nome original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original por', + maintainer: 'Versão 2 mantida por', + marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', + support: + 'Se você encontrar um bug ou tiver uma ideia, poste no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do log do console da API.', + }, + }, + }; + + const TRANSLATION$4 = { + titles: { + ready: 'Hexploration готова.', + settings: 'Настройки Hexploration', + languages: 'Выберите язык', + pageSettings: 'Настройки страницы: {page}', + status: 'Статус Hexploration: {page}', + help: 'Команды Hexploration', + confirm: 'Пожалуйста, подтвердите', + }, + discovery: { + title: 'Локация обнаружена', + }, + menu: { + draw: 'Рисование', + reveal: 'Раскрытие и скрытие', + locations: 'Локации', + tools: 'Инструменты', + layerInUse: 'Новые гексы рисуются на этом слое: {layer}.', + pageSettingsHelp: + 'Эти настройки применяются только к этой странице. Настройки, отмеченные знаком ★, переопределяют глобальные настройки.', + }, + buttons: { + fill: 'Заполнить', + fillInverse: 'Обратная заливка', + undo: 'Отменить заливку', + reveal: 'Раскрыть', + conceal: 'Скрыть', + explore: 'Исследовать', + revealPage: 'Раскрыть страницу', + resetPage: 'Сбросить страницу', + mark: 'Отметить локацию', + unmark: 'Снять отметку', + name: 'Назвать гекс', + settings: 'Настройки', + pageSettings: 'Настройки страницы', + status: 'Статус', + rescan: 'Пересканировать', + calibrate: 'Калибровать', + calibrateReset: 'Сбросить калибровку', + help: 'Справка', + change: 'Изменить', + menu: 'Меню', + clearOverrides: 'Сбросить переопределения', + confirmReset: 'Да, удалить все гексы', + }, + prompts: { + name: 'Название местоположения (оставьте пустым, чтобы очистить)', + }, + values: { + on: 'Вкл.', + off: 'Выкл.', + none: 'Нет', + hexLayer: { + auto: 'Авто (передний план, если доступен)', + foreground: 'слой переднего плана', + objects: 'слой токенов', + }, + revealBy: { + players: 'Токены игроков', + characters: 'Токены персонажей', + all: 'Все токены', + }, + revealMode: { + clear: 'Очистка', + glimpse: 'Проблеск', + }, + announce: { + all: 'Все', + gm: 'Только ГМ', + off: 'Выкл.', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заливка', + fillInverse: 'Обратная заливка', + conceal: 'Скрытие', + }, + }, + settings: { + language: { + label: 'Язык', + desc: 'Язык меню, сообщений и раздаточных материалов.', + }, + hexLayer: { + label: 'Слой шестиугольников', + desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', + }, + fillColor: { + label: 'Цвет заливки', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Цвет границы', + desc: 'Цвет контура новых гексов.', + }, + labelColor: { + label: 'Цвет меток', + desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + }, + glimpseColor: { + label: 'Цвет проблеска', + desc: 'Цвет, который принимают гексы в режиме «Проблеск». Используйте полупрозрачный цвет rgba().', + }, + strokeWidth: { + label: 'Ширина границы', + desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + }, + maxDistance: { + label: 'Дальность раскрытия шестиугольников', + desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', + }, + revealDistance: { + label: 'Расстояние обзора', + desc: 'Сколько гексов вокруг движущегося жетона обнаружено (от 0 до 20). 0 показывает только те гексы, через которые проходит фишка.', + }, + lineOfSight: { + label: 'Линия видимости', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', + }, + revealPath: { + label: 'Раскрывать вдоль пути', + desc: 'Когда эта функция включена, отображается каждый гекс, через который проходит жетон во время перетаскивания (включая путевые точки), а не только то место, где он останавливается.', + }, + revealBy: { + label: 'Раскрывающие токены', + desc: 'Какие жетоны на слое жетонов отображают гексы: жетоны, контролируемые игроком, жетоны, представляющие любого персонажа, или каждый жетон.', + }, + revealMode: { + label: 'Режим раскрытия', + desc: '«Очистка» удаляет гексы в пределах видимости. «Проблеск» вместо этого делает их полупрозрачными; они удаляются, когда в них входит токен.', + }, + announce: { + label: 'Объявлять об открытиях', + desc: 'Кто видит сообщение чата при обнаружении именованного местоположения.', + }, + pingDiscoveries: { + label: 'Пинговать находки', + desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + }, + hideCoveredTokens: { + label: 'Скрывать токены под гексами', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + }, + }, + status: { + engine: 'Игровой движок', + grid: 'Сетка', + layer: 'Слой гексов', + hexes: 'Гексы', + named: 'Именованные гексы', + icons: 'Токены локаций', + glimpsed: 'Гексы в проблеске', + pending: 'Локации, ожидающие заливки', + calibrated: 'Откалибровано', + overrides: 'Переопределения страницы', + undo: 'Доступна отмена', + }, + messages: { + filled: + 'Заполнение завершено. Нарисованы гексы: {created}. Новый стиль: {restyled}. Местоположение скрыто: {icons}.', + revealed: 'Обнаружены гексы: {count}.', + revealedPage: 'Все гексы на странице открыты ({count}).', + confirmReset: + 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', + resetPage: 'Со страницы удалены шестигранники: {count}.', + undone: + 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Шестигранники с именем "{name}": {count}.', + unnamed: 'Имена удалены: {count}.', + marked: + 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', + unmarked: 'Токены, которые больше не являются локациями: {count}.', + settingChanged: 'Для {setting} установлено значение {value}.', + rescanned: + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + calibrated: + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + calibrationReset: + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', + migrated: + 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', + pruned: + 'Забыты сохранённые гексы, которых больше нет: {dropped}. Если эта игра или страница была скопирована, выполните «Пересканировать» на странице, чтобы снова найти её гексы.', + readyHint: + 'Введите !hexploration, чтобы открыть меню, или откройте раздаточный материал "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + someFailed: + 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', + }, + errors: { + noPage: 'Не удалось найти страницу для работы.', + notHex: 'На этой странице не используется шестигранная сетка.', + noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', + emptyArea: 'Выбранная область не содержит шестигранных центров.', + tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', + nothingToReveal: + 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + noTokens: 'Сначала выберите один или несколько жетонов.', + noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', + nothingToUndo: 'Нет заливки, которую можно было бы отменить.', + unknownCommand: 'Неизвестная команда: {command}', + unknownSetting: 'Неизвестная настройка: {key}.', + unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', + invalidValue: '«{value}» не является допустимым значением для {key}.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', + unexpected: 'Что-то пошло не так: {message}', + }, + hints: { + noPage: 'Откройте страницу, над которой хотите работать, или выберите что-нибудь на ней.', + notHex: 'Установите сетку страницы на Hex (V) или Hex (H) в настройках страницы.', + noPolygons: + 'Нарисуйте многоугольник, прямоугольник, эллипс или фигуру от руки вокруг области, выберите ее и повторите попытку.', + emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', + tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', + noHexes: + 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', + unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', + calibrateNeedsTokens: + 'Привяжите токен к центру гекса и выделите его. Чтобы заодно исправить размер гекса, выделите второй токен, привязанный к соседнему гексу в той же строке (Hex V) или в том же столбце (Hex H).', + calibrateFailed: + 'Два токена должны находиться в одной строке (Hex V) или в одном столбце (Hex H) на расстоянии не менее одного гекса друг от друга.', + unexpected: 'Подробности в журнале консоли API.', + }, + help: { + menu: 'Покажите меню.', + fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', + undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', + revealPage: 'Раскройте каждый гекс на странице без объявлений.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', + explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', + name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', + mark: 'Превратите выбранные жетоны в скрытые локации.', + unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', + set: 'Измените настройку или отобразите все настройки.', + pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageClear: 'Удалить переопределения текущей страницы.', + rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', + calibrate: + 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + calibrateReset: 'Удалить калибровку текущей страницы.', + status: 'Покажите, что Hexploration знает о текущей странице.', + journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', + help: 'Покажите этот список.', + handout: 'Полные инструкции приведены в раздаточном материале «{name}».', + }, + deck: { + drawDesc: + 'Обведите область фигурами, выделите их и нажмите «Заполнить». «Отменить заливку» отменяет последнюю заливку.', + revealDesc: + 'Выделите гексы, фигуры или токены, чтобы раскрыть их или снова скрыть. «Исследовать» раскрывает гексы вокруг выбранных токенов, как если бы они туда переместились.', + locationsDesc: + 'Выберите жетоны, чтобы скрыть их как места под гексами. Выберите гексы или жетоны, чтобы назвать гекс.', + toolsDesc: + 'Настройки, переопределение страниц, статус, повторное сканирование скопированных страниц и калибровка сетки.', + footer: 'Подробные инструкции см. в раздаточном материале «{help}».', + }, + handout: { + versionLabel: 'Версия', + subtitle: 'Исследование гекс за гексом для Roll20', + footer: 'Используйте раздаточный материал «{deck}» для управления одним щелчком мыши.', + overview: { + heading: 'Обзор', + body: 'Hexploration закрывает гексовую карту непрозрачными гексами. По мере продвижения группы гексы, через которые она проходит (и, при желании, гексы вокруг них), удаляются, так что карта открывается гекс за гексом. Под гексами можно разместить скрытые локации — при обнаружении о них будет объявлено. Работает в играх Jumpgate и Legacy, на сетках Hex (V) и Hex (H) любого размера.', + demo: 'Посмотрите короткую демонстрацию (из версии 1)', + }, + quickStart: { + heading: 'Быстрый старт', + steps: [ + 'Откройте страницу, для сетки которой установлено значение Hex (V) или Hex (H).', + 'Нарисуйте одну или несколько фигур (многоугольник, прямоугольник, эллипс или от руки) вокруг области, которую нужно скрыть.', + 'Выделите фигуры и нажмите «Заполнить» в Command Deck (или введите !hexploration fill). Фигуры заменятся гексами.', + 'Необязательно: перед заливкой выделите токены важных мест и нажмите «Отметить локацию». Они будут спрятаны под гексами, а при обнаружении о них будет объявлено.', + 'Переместите токен игрока. Каждый гекс, через который он проходит, и гексы в пределах его «Расстояния обзора» раскрываются.', + ], + }, + commands: { + heading: 'Команды', + intro: + 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + colCommand: 'Команда', + colDesc: 'Что он делает', + }, + revealing: { + heading: 'Как работает выявление', + points: [ + 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', + 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', + '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', + 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', + 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', + ], + }, + locations: { + heading: 'Именованные гексы и локации', + points: [ + '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', + 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', + 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', + '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', + ], + }, + settings: { + heading: 'Настройки', + intro: + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', + colKey: 'Ключ', + colName: 'Параметр', + colDesc: 'Описание', + perPage: '(Можно установить для каждой страницы.)', + }, + jumpgate: { + heading: 'Джампгейт и Наследие', + points: [ + 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', + 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', + 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', + ], + }, + upgrading: { + heading: 'Обновление с версии 1', + points: [ + 'Версия 2 больше не требует PathMath, MatrixMath, Vector Math или HTML Builder. Вы можете удалить их, если их не использует другой мод.', + 'Существующие гексовые карты, имена, токены локаций и настройки обновляются автоматически при первом запуске.', + 'Команды версии 1, включая макрос Hexploration_menu, по-прежнему работают.', + 'В версии 1 гексы мог раскрывать любой токен, представляющий персонажа. Чтобы сохранить такое поведение, установите для «Раскрывающие токены» значение «Токены персонажей».', + ], + colV1: 'Команда версии 1', + colV2: 'Команда версии 2', + }, + troubleshooting: { + heading: 'Поиск неисправностей', + points: [ + 'При перемещении токена ничего не происходит: убедитесь, что токен находится на слое токенов и подходит под настройку «Раскрывающие токены», а на странице есть гексы (!hexploration status).', + 'Гексы смещены относительно сетки: нажмите «Калибровать», затем проверьте токеном несколько гексов в разных частях карты.', + 'Гексы перестали раскрываться после копирования страницы или игры: выполните «Пересканировать» на странице.', + '«Заполнить» сообщает, что в области нет центров гексов: фигура должна содержать центр хотя бы одного гекса.', + 'В противном случае проверьте журнал консоли API и включите его сообщения при обращении за помощью.', + ], + }, + languages: { + heading: 'Языки', + body: 'Выберите язык командой !hexploration set language. Доступные языки:', + colLanguage: 'Язык', + colNative: 'Самоназвание', + colCode: 'Код', + }, + credits: { + heading: 'Кредиты', + original: 'Оригинальный мод от', + maintainer: 'Версия 2 поддерживается', + marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', + support: + 'Если вы обнаружили ошибку или у вас есть идея, напишите сообщение на форуме Roll20 Mod или откройте проблему на GitHub и включите все сообщения из журнала консоли API.', + }, + }, + }; + + const TRANSLATION$3 = { + titles: { + ready: 'Hexploration está listo.', + settings: 'Configuración de Hexploration', + languages: 'Elige un idioma', + pageSettings: 'Configuración de página: {page}', + status: 'Estado de Hexploration: {page}', + help: 'Comandos de Hexploration', + confirm: 'Por favor, confirme', + }, + discovery: { + title: 'Ubicación descubierta', + }, + menu: { + draw: 'Dibujar', + reveal: 'Revelar y ocultar', + locations: 'Ubicaciones', + tools: 'Herramientas', + layerInUse: 'Se están dibujando nuevos hexágonos en la {layer}.', + pageSettingsHelp: + 'Esta configuración se aplica únicamente a esta página. Las configuraciones marcadas con ★ anulan la configuración global.', + }, + buttons: { + fill: 'Rellenar', + fillInverse: 'Relleno inverso', + undo: 'Deshacer relleno', + reveal: 'Revelar', + conceal: 'Ocultar', + explore: 'Explorar', + revealPage: 'Revelar página', + resetPage: 'Restablecer página', + mark: 'Marcar ubicación', + unmark: 'Desmarcar', + name: 'Nombrar hexágono', + settings: 'Configuración', + pageSettings: 'Configuración de página', + status: 'Estado', + rescan: 'Volver a escanear', + calibrate: 'Calibrar', + calibrateReset: 'Restablecer calibración', + help: 'Ayuda', + change: 'Cambiar', + menu: 'Menú', + clearOverrides: 'Borrar anulaciones', + confirmReset: 'Sí, eliminar todos los hexágonos', + }, + prompts: { + name: 'Nombre de la ubicación (déjelo vacío para borrarlo)', + }, + values: { + on: 'Activado', + off: 'Desactivado', + none: 'Ninguno', + hexLayer: { + auto: 'Auto (primer plano si está disponible)', + foreground: 'capa de primer plano', + objects: 'capa de fichas', + }, + revealBy: { + players: 'Fichas de jugador', + characters: 'Fichas de personaje', + all: 'Todas las fichas', + }, + revealMode: { + clear: 'Despejar', + glimpse: 'Vistazo', + }, + announce: { + all: 'Todos', + gm: 'Solo el DJ', + off: 'Desactivado', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Rellenar', + fillInverse: 'Relleno inverso', + conceal: 'Ocultar', + }, + }, + settings: { + language: { + label: 'Idioma', + desc: 'Idioma para menús, mensajes y folletos.', + }, + hexLayer: { + label: 'Capa de hexágonos', + desc: 'Donde se dibujan nuevos hexágonos. Auto prueba la capa de primer plano (sobre las fichas) y vuelve a la capa de fichas si el juego no lo admite.', + }, + fillColor: { + label: 'Color de relleno', + desc: 'Color de nuevos hexágonos. Utilice rgba() para hexágonos transparentes, por ejemplo rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Color del borde', + desc: 'Color del contorno de nuevos hexágonos.', + }, + labelColor: { + label: 'Color de la etiqueta', + desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + }, + glimpseColor: { + label: 'Color de vistazo', + desc: 'Color que toman los hexágonos al vislumbrarse (modo de revelación Vistazo). Use un color rgba() transparente.', + }, + strokeWidth: { + label: 'Ancho del borde', + desc: 'Ancho del contorno de nuevos hexágonos, en píxeles (0 a 20).', + }, + maxDistance: { + label: 'Distancia de revelación de hexágonos', + desc: 'Se guarda en los hexágonos cuando se rellenan, así que configúrelo antes de rellenar: cambiarlo después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esta cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver; con 0, sólo se revelan al entrar en ellos. Úselo para montañas o bosques. Déjelo vacío para no tener límite.', + }, + revealDistance: { + label: 'Distancia de visión', + desc: 'Cuántos hexágonos se revelan alrededor de una ficha en movimiento (0 a 20). 0 revela sólo los hexágonos por los que pasa la ficha.', + }, + lineOfSight: { + label: 'Línea de visión', + desc: 'Cuando está activado, los hexágonos que siguen cubiertos, como las montañas rellenadas con una Distancia de revelación de hexágonos, ocultan los hexágonos que hay detrás de ellos. Sólo tiene efecto con una Distancia de visión de 2 o más.', + }, + revealPath: { + label: 'Revelar a lo largo del camino', + desc: 'Cuando está activado, se revela cada hexágono por el que pasa una ficha mientras es arrastrada (incluidos los puntos de ruta), no solo dónde se detiene.', + }, + revealBy: { + label: 'Fichas que revelan', + desc: 'Qué fichas en la capa de fichas revelan hexágonos: fichas controladas por un jugador, fichas que representan cualquier personaje o todas las fichas.', + }, + revealMode: { + label: 'Modo de revelación', + desc: 'Despejar elimina los hexágonos a la vista. Vistazo, en cambio, los vuelve transparentes; se eliminan cuando una ficha entra en ellos.', + }, + announce: { + label: 'Anunciar descubrimientos', + desc: 'Quién ve el mensaje de chat cuando se descubre una ubicación con nombre.', + }, + pingDiscoveries: { + label: 'Hacer ping a los descubrimientos', + desc: 'Cuando está activado, los jugadores reciben un ping a una ubicación con nombre cuando se descubre.', + }, + hideCoveredTokens: { + label: 'Ocultar fichas cubiertas', + desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + }, + }, + status: { + engine: 'Motor de juego', + grid: 'Cuadrícula', + layer: 'Capa de hexágonos', + hexes: 'Hexágonos', + named: 'Hexágonos con nombre', + icons: 'Fichas de ubicación', + glimpsed: 'Hexágonos vislumbrados', + pending: 'Ubicaciones pendientes de relleno', + calibrated: 'Calibrado', + overrides: 'Anulaciones de página', + undo: 'Deshacer disponible', + }, + messages: { + filled: + 'Relleno completado. Hexágonos dibujados: {created}. Con nuevo estilo: {restyled}. Ubicaciones ocultas: {icons}.', + revealed: 'Hexágonos revelados: {count}.', + revealedPage: 'Cada hexágono en la página revelado ({count}).', + confirmReset: + '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', + resetPage: 'Hexes eliminados de la página: {count}.', + undone: + 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', + named: 'Hexágonos denominados "{name}": {count}.', + unnamed: 'Nombres borrados: {count}.', + marked: + 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', + unmarked: 'Tokens que ya no son ubicaciones: {count}.', + settingChanged: '{setting} establecido en {value}.', + rescanned: + 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + calibrated: + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + calibrationReset: + 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', + migrated: + 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', + pruned: + 'Hexágonos guardados que ya no existen y fueron olvidados: {dropped}. Si este juego o página fue copiado, ejecuta Volver a escanear en la página para recuperar sus hexágonos nuevamente.', + readyHint: + 'Escriba !hexploration para ver el menú o abra el folleto "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Este juego no admite dibujar en la capa de primer plano, por lo que los hexágonos se dibujaron en la capa de fichas.', + someFailed: + 'Hexágonos que no se pudieron dibujar: {count}. Consulte la consola API para obtener más detalles.', + }, + errors: { + noPage: 'No se pudo encontrar la página para trabajar.', + notHex: 'Esta página no utiliza una cuadrícula hexagonal.', + noPolygons: 'Seleccione una o más formas dibujadas para rellenar.', + emptyArea: 'El área seleccionada no contiene ningún centro de hexágono.', + tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', + nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', + nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', + noTokens: 'Seleccione uno o más tokens primero.', + noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', + nothingToUndo: 'No hay ningún relleno que deshacer.', + unknownCommand: 'Comando desconocido: {command}', + unknownSetting: 'Configuración desconocida: {key}', + unknownPageSetting: 'Configuraciones que se pueden establecer por página: {keys}', + invalidValue: '"{value}" no es un valor válido para {key}.', + calibrateNeedsTokens: 'Seleccione una o dos fichas ajustadas a centros de hexágonos.', + calibrateFailed: 'Esas fichas no se pueden utilizar para calibrar.', + unexpected: 'Algo salió mal: {message}', + }, + hints: { + noPage: 'Abra la página en la que desea trabajar o seleccione algo en ella.', + notHex: + 'Establezca la cuadrícula de la página en Hex (V) o Hex (H) en Configuración de página.', + noPolygons: + 'Dibuja un polígono, un rectángulo, una elipse o una forma a mano alzada alrededor del área, selecciónala y vuelve a intentarlo.', + emptyArea: + 'Dibuja una forma más grande o verifica la configuración de la cuadrícula de la página.', + tooMany: 'Rellene un área más pequeña o divida el área en varias formas.', + noHexes: + 'Los hexágonos están en primer plano o en la capa de fichas; cambie a esa capa para seleccionarlas.', + unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', + unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', + calibrateNeedsTokens: + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + calibrateFailed: + 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + unexpected: 'Los detalles se encuentran en el registro de la consola API.', + }, + help: { + menu: 'Mostrar el menú.', + fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', + fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', + undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + reveal: + 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', + revealPage: 'Revela cada hexágono de la página sin anuncios.', + conceal: + 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', + explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', + name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', + mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', + unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + set: 'Cambie una configuración o muestre todas las configuraciones.', + pageSet: 'Anula una configuración de revelación solo en la página actual.', + pageClear: 'Elimine las anulaciones de la página actual.', + rescan: + 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', + calibrate: + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + calibrateReset: 'Elimina la calibración de la página actual.', + status: 'Muestra lo que Hexploration sabe sobre la página actual.', + journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', + help: 'Muestra esta lista.', + handout: 'Las instrucciones completas se encuentran en el folleto "{name}".', + }, + deck: { + drawDesc: + 'Dibuja formas alrededor de un área, selecciónalas y luego rellena. Deshacer relleno revierte el último relleno.', + revealDesc: + 'Selecciona hexágonos, formas o fichas para revelarlos o volver a cubrirlos. Explorar revela alrededor de las fichas seleccionadas como si se hubieran movido.', + locationsDesc: + 'Selecciona fichas para ocultarlas como ubicaciones debajo de hexágonos. Selecciona hexágonos o fichas para nombrar un hexágono.', + toolsDesc: + 'Configuraciones, anulaciones de páginas, estado, volver a escanear páginas copiadas y calibrar la cuadrícula.', + footer: 'Consulte el folleto "{help}" para obtener instrucciones completas.', + }, + handout: { + versionLabel: 'Versión', + subtitle: 'Exploración hexágono por hexágono para Roll20', + footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', + overview: { + heading: 'Descripción general', + body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + demo: 'Vea una breve demostración (de la versión 1)', + }, + quickStart: { + heading: 'Inicio rápido', + steps: [ + 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', + 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', + 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', + 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', + ], + }, + commands: { + heading: 'Comandos', + intro: + 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Dominio', + colDesc: 'que hace', + }, + revealing: { + heading: 'Cómo funciona la revelación', + points: [ + 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', + 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', + 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', + 'Roll20 dibuja los nombres, barras y auras de las fichas por encima de los hexágonos. Con Ocultar fichas cubiertas activado, una ficha bajo un hexágono cubierto tiene desactivados su nombre, barras y auras visibles para los jugadores hasta que se descubre, para que los monstruos ocultos no se delaten. Si activa alguno mientras la ficha está cubierta, permanece oculto y se activa cuando la ficha se descubre.', + 'La API no informa de los movimientos hechos por otros mods. Los movimientos de TokenMod se detectan automáticamente; para otros mods, seleccione las fichas y haga clic en Explorar, o llame a Hexploration.revealAround(token) desde su propio mod.', + ], + }, + locations: { + heading: 'Hexágonos y ubicaciones con nombre', + points: [ + 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', + 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', + ], + }, + settings: { + heading: 'Ajustes', + intro: + 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', + colKey: 'Llave', + colName: 'Configuración', + colDesc: 'Descripción', + perPage: '(Se puede configurar por página).', + }, + jumpgate: { + heading: 'Jumpgate y legado', + points: [ + 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', + 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', + 'Jumpgate dibuja hexágonos matemáticamente regulares, cuya forma es ligeramente distinta de la de los hexágonos de Legacy. Si los hexágonos no se alinean con la cuadrícula de una página, ajuste una ficha al centro de un hexágono, selecciónela y haga clic en Calibrar. Seleccione dos fichas en hexágonos vecinos de la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', + 'Cuando se copia una página o un juego, sus hexágonos obtienen nuevos ID. Ejecute Volver a escanear en la página para recuperarlos, junto con sus etiquetas de nombre y fichas de ubicación.', + ], + }, + upgrading: { + heading: 'Actualización desde la versión 1', + points: [ + 'La versión 2 ya no necesita PathMath, MatrixMath, Vector Math o HTML Builder. Puedes eliminarlos a menos que otro mod los use.', + 'Los mapas de hexágonos, nombres, fichas de ubicación y ajustes existentes se actualizan automáticamente la primera vez que se inicia.', + 'Los comandos de la versión 1, incluida la macro Hexploration_menu, todavía funcionan.', + 'La versión 1 permitía que cualquier ficha que representara a un personaje revelara hexágonos. Ajuste Fichas que revelan a Fichas de personaje para mantener ese comportamiento.', + ], + colV1: 'Comando versión 1', + colV2: 'Comando versión 2', + }, + troubleshooting: { + heading: 'Solución de problemas', + points: [ + 'No pasa nada cuando una ficha se mueve: compruebe que la ficha está en la capa de fichas y coincide con Fichas que revelan, y que la página tiene hexágonos (!hexploration status).', + 'Los hexágonos están desplazados de la cuadrícula: usa Calibrar, luego verifica con una ficha en algunos hexágonos del mapa.', + 'Los hexágonos dejaron de revelarse tras copiar una página o un juego: ejecute Volver a escanear en la página.', + 'Rellenar dice que el área no tiene centros de hexágono: la forma debe contener el centro de al menos un hexágono.', + 'Para cualquier otra cosa, consulte el registro de la consola API e incluya sus mensajes cuando solicite ayuda.', + ], + }, + languages: { + heading: 'Idiomas', + body: 'Elija un idioma con !hexploration set language. Idiomas disponibles:', + colLanguage: 'Idioma', + colNative: 'Nombre original', + colCode: 'Código', + }, + credits: { + heading: 'Créditos', + original: 'Mod original de', + maintainer: 'Versión 2 mantenida por', + marketplace: 'Paquetes de arte de Ada en Roll20 Marketplace', + support: + 'Si encuentra un error o tiene una idea, publíquelo en el foro Roll20 Mod o abra un problema en GitHub e incluya cualquier mensaje del registro de la consola API.', + }, + }, + }; + + const TRANSLATION$2 = { + titles: { + ready: 'Hexploration är redo.', + settings: 'Hexploration-inställningar', + languages: 'Välj ett språk', + pageSettings: 'Sidinställningar: {page}', + status: 'Hexploration-status: {page}', + help: 'Hexploration-kommandon', + confirm: 'Vänligen bekräfta', + }, + discovery: { + title: 'Plats upptäckt', + }, + menu: { + draw: 'Rita', + reveal: 'Avslöja och dölj', + locations: 'Platser', + tools: 'Verktyg', + layerInUse: 'Nya hexar ritas på {layer}.', + pageSettingsHelp: + 'Dessa inställningar gäller endast för denna sida. Inställningar markerade ★ åsidosätter de globala inställningarna.', + }, + buttons: { + fill: 'Fyll', + fillInverse: 'Omvänd fyllning', + undo: 'Ångra fyllning', + reveal: 'Avslöja', + conceal: 'Dölj', + explore: 'Utforska', + revealPage: 'Avslöja sida', + resetPage: 'Återställ sida', + mark: 'Markera plats', + unmark: 'Avmarkera', + name: 'Namnge hex', + settings: 'Inställningar', + pageSettings: 'Sidinställningar', + status: 'Status', + rescan: 'Skanna igen', + calibrate: 'Kalibrera', + calibrateReset: 'Återställ kalibrering', + help: 'Hjälp', + change: 'Ändra', + menu: 'Meny', + clearOverrides: 'Rensa åsidosättningar', + confirmReset: 'Ja, ta bort alla hexar', + }, + prompts: { + name: 'Platsnamn (låt vara tomt för att rensa)', + }, + values: { + on: 'På', + off: 'Av', + none: 'Ingen', + hexLayer: { + auto: 'Auto (förgrund om tillgängligt)', + foreground: 'förgrundslagret', + objects: 'tokenlagret', + }, + revealBy: { + players: 'Spelartokens', + characters: 'Rollpersonstokens', + all: 'Alla tokens', + }, + revealMode: { + clear: 'Rensa', + glimpse: 'Glimt', + }, + announce: { + all: 'Alla', + gm: 'Endast GM', + off: 'Av', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Fyll', + fillInverse: 'Omvänd fyllning', + conceal: 'Dölj', + }, + }, + settings: { + language: { + label: 'Språk', + desc: 'Språk för menyer, meddelanden och åhörarkopior.', + }, + hexLayer: { + label: 'Lager för hexar', + desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + }, + fillColor: { + label: 'Fyllningsfärg', + desc: 'Färg på nya hexar. Använd rgba() för genomskinliga hexar, till exempel rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kantfärg', + desc: 'Färg på konturerna av nya sexkanter.', + }, + labelColor: { + label: 'Etikettfärg', + desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + }, + glimpseColor: { + label: 'Glimtfärg', + desc: 'Färgen som hexar byter till när de skymtas (avslöjandeläget Glimt). Använd en genomskinlig rgba()-färg.', + }, + strokeWidth: { + label: 'Kantbredd', + desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + }, + maxDistance: { + label: 'Avslöjandeavstånd för hexar', + desc: 'Lagras på hexarna när de fylls, så ställ in det innan du fyller: att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se; med 0 avslöjas de bara när man går in i dem. Använd det för berg eller skogar. Lämna tomt för ingen gräns.', + }, + revealDistance: { + label: 'Siktavstånd', + desc: 'Hur många hexar runt en rörlig token som avslöjas (0 till 20). 0 avslöjar endast de hexar som token passerar igenom.', + }, + lineOfSight: { + label: 'Siktlinje', + desc: 'När den är på döljer hexar som förblir täckta, till exempel berg som fyllts med ett Avslöjandeavstånd för hexar, hexarna bakom dem. Det gör bara skillnad med ett Siktavstånd på 2 eller mer.', + }, + revealPath: { + label: 'Avslöja längs vägen', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + }, + revealBy: { + label: 'Tokens som avslöjar', + desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + }, + revealMode: { + label: 'Avslöjandeläge', + desc: 'Rensa tar bort hexar inom synhåll. Glimt gör dem i stället genomskinliga; de tas bort när en token går in i dem.', + }, + announce: { + label: 'Tillkännage upptäckter', + desc: 'Vem ser chattmeddelandet när en namngiven plats upptäcks.', + }, + pingDiscoveries: { + label: 'Pinga upptäckter', + desc: 'När den är på pingas spelare till en namngiven plats när den upptäcks.', + }, + hideCoveredTokens: { + label: 'Dölj täckta tokens', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + }, + }, + status: { + engine: 'Spelmotor', + grid: 'Rutnät', + layer: 'Hexlager', + hexes: 'Hexar', + named: 'Namngivna hexar', + icons: 'Platstokens', + glimpsed: 'Genomskinliga hexar', + pending: 'Platser som väntar på fyllning', + calibrated: 'Kalibrerad', + overrides: 'Sidåsidosättningar', + undo: 'Ångra tillgängligt', + }, + messages: { + filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', + revealed: 'Hexen avslöjade: {count}.', + revealedPage: 'Varje hex på sidan avslöjas ({count}).', + confirmReset: + 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexen har tagits bort från sidan: {count}.', + undone: + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', + named: 'Hex med namnet "{name}": {count}.', + unnamed: 'Namn raderade: {count}.', + marked: + 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', + unmarked: 'Tokens som inte längre är platser: {count}.', + settingChanged: '{setting} inställd på {value}.', + rescanned: + 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + calibrated: + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + calibrationReset: + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + journalRebuilt: '"{help}" och "{deck}" har byggts om.', + migrated: + 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', + pruned: + 'Sparade hexar som inte längre finns och har glömts bort: {dropped}. Om det här spelet eller sidan kopierades kör du Skanna igen på sidan för att hitta dess hexar igen.', + readyHint: + 'Skriv !hexploration för menyn, eller öppna handouten "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', + someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + }, + errors: { + noPage: 'Kunde inte hitta sidan att arbeta på.', + notHex: 'Den här sidan använder inte ett hex-rutnät.', + noPolygons: 'Välj en eller flera ritade former att fylla.', + emptyArea: 'Det valda området innehåller inga hexa-center.', + tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', + nothingToConceal: 'Välj ritade former eller tokens att dölja.', + nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + noTokens: 'Välj först en eller flera tokens.', + noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + nothingToUndo: 'Det finns ingen fyllning att ångra.', + unknownCommand: 'Okänt kommando: {command}', + unknownSetting: 'Okänd inställning: {key}', + unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', + invalidValue: '"{value}" är inte ett giltigt värde för {key}.', + calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', + unexpected: 'Något gick fel: {message}', + }, + hints: { + noPage: 'Öppna sidan du vill arbeta på eller välj något på den.', + notHex: 'Ställ in sidrutnätet på Hex (V) eller Hex (H) i Sidinställningar.', + noPolygons: + 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', + emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', + tooMany: 'Fyll ett mindre område, eller dela området i flera former.', + noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + unknownCommand: 'Skriv !hexploration help för att lista kommandona.', + unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', + calibrateNeedsTokens: + 'Fäst en token i mitten av en hex och välj den. Välj en andra token som fästs på en intilliggande hex i samma rad (Hex V) eller kolumn (Hex H) för att korrigera hexstorleken också.', + calibrateFailed: + 'Två tokens måste ligga i samma rad (Hex V) eller samma kolumn (Hex H), minst en hex från varandra.', + unexpected: 'Detaljer finns i API-konsolloggen.', + }, + help: { + menu: 'Visa menyn.', + fill: 'Täck de utvalda ritade formerna med hex.', + fillInverse: 'Täck hela sidan utom inuti de valda formerna.', + undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', + reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', + revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', + resetPage: 'Ta bort varje hex på sidan (frågar först).', + name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + mark: 'Förvandla de valda tokens till dolda platser.', + unmark: 'Stoppa de valda tokens från att vara dolda platser.', + set: 'Ändra en inställning eller visa alla inställningar.', + pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', + pageClear: 'Ta bort den aktuella sidans åsidosättningar.', + rescan: + 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', + calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrateReset: 'Ta bort den aktuella sidans kalibrering.', + status: 'Visa vad Hexploration vet om den aktuella sidan.', + journal: 'Bygg om handouterna Help och Command Deck.', + help: 'Visa den här listan.', + handout: 'Fullständiga instruktioner finns i "{name}" handout.', + }, + deck: { + drawDesc: + 'Rita former runt ett område, markera dem och fyll sedan. Ångra fyllning tar bort den senaste fyllningen.', + revealDesc: + 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', + locationsDesc: + 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + toolsDesc: + 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', + footer: 'Se "{help}"-handouten för fullständiga instruktioner.', + }, + handout: { + versionLabel: 'Version', + subtitle: 'Hex-by-hex-utforskning för Roll20', + footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', + overview: { + heading: 'Översikt', + body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + demo: 'Se en kort demo (från version 1)', + }, + quickStart: { + heading: 'Snabbstart', + steps: [ + 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', + 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', + 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', + ], + }, + commands: { + heading: 'Kommandon', + intro: + 'Endast GM:er kan använda dessa kommandon. De flesta agerar på de valda objekten; resten agerar på sidan du tittar på.', + colCommand: 'Kommando', + colDesc: 'Vad den gör', + }, + revealing: { + heading: 'Hur avslöjande fungerar', + points: [ + 'Endast tokens på tokenlagret avslöjar hexar. Vilka tokens som räknas bestäms av Tokens som avslöjar: spelartokens som standard, så att GM kan flytta monster utan att avslöja kartan.', + 'En token avslöjar varje hex den täcker (stora tokens täcker flera) och, med Avslöja längs vägen på, varje hex på rutten den drogs längs, inklusive mellanpunkter.', + 'Siktavstånd avslöjar hexarna runt var och en av dessa hexar, de närmaste först. Med Siktlinje på avslöjas en hex inte så länge en täckt hex ligger mellan den och token. Närmare hexar avslöjas oftast först, så i öppen terräng ändrar Siktlinje ingenting: den spelar bara roll med ett Siktavstånd på 2 eller mer och hexar som förblir täckta, till exempel terräng som fyllts med ett Avslöjandeavstånd för hexar.', + 'Avslöjandeavstånd för hexar lagras på varje hex när den fylls, så ställ in det innan du fyller; att ändra det senare påverkar inte hexar som redan finns på kartan. En token måste vara inom så många hexar för att avslöja dem, hur långt den än kan se, och med 0 avslöjas de bara när man går in i dem. För en bergskedja: ställ in Avslöjandeavstånd för hexar på 0, fyll bergen, återställ det till inget och fyll sedan landet bortom. Med Siktavstånd 3 och Siktlinje på ser gruppen den öppna marken runt sig, men inte bergen eller det som ligger bakom dem. Varje berghex avslöjas när en token går in i den.', + 'I läget Glimt blir hexar inom synhåll genomskinliga i stället för att försvinna, och de tas bort när en token går in i dem. Genomskinliga Glimt-hexar blockerar inte Siktlinje.', + 'Roll20 ritar tokennamn, staplar och auror ovanpå hexarna. Med Dölj täckta tokens på stängs det namn, de staplar och de auror som spelarna kan se av för en token under en täckt hex tills den avtäcks, så att dolda monster inte avslöjar sig. Om du slår på något av dem medan token är täckt förblir det dolt och slås på när token avtäcks.', + 'API:et rapporterar inte förflyttningar som görs av andra moddar. TokenMod-förflyttningar fångas upp automatiskt; för andra moddar markerar du tokens och klickar på Utforska, eller anropar Hexploration.revealAround(token) från din egen mod.', + ], + }, + locations: { + heading: 'Namngivna Hex och platser', + points: [ + 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', + 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', + 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', + 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', + ], + }, + settings: { + heading: 'Inställningar', + intro: + 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', + colKey: 'Nyckel', + colName: 'Miljö', + colDesc: 'Beskrivning', + perPage: '(Kan ställas in per sida.)', + }, + jumpgate: { + heading: 'Jumpgate och Legacy', + points: [ + 'Hexploration tar reda på vilken motor spelet använder och ritar den matchande formen. Former ritade i någon av editorerna kan fyllas.', + 'När Lager för hexar är inställt på Auto ritas hexar på förgrundslagret, ovanför tokens, så att spelarna inte kan se vad som finns under. Om förgrundslagret inte är tillgängligt används tokenlagret i stället.', + 'Jumpgate ritar matematiskt regelbundna hexar, som har en något annan form än Legacy-hexar. Om hexarna inte stämmer med en sidas rutnät, fäst en token i mitten av en hex, markera den och klicka på Kalibrera. Markera två tokens i angränsande hexar i samma rad (Hex V) eller kolumn (Hex H) för att även korrigera hexstorleken.', + 'När en sida eller ett spel kopieras får dess hexar nya ID:n. Kör Skanna igen på sidan för att hitta dem igen, tillsammans med deras namnetiketter och platstokens.', + ], + }, + upgrading: { + heading: 'Uppgraderar från version 1', + points: [ + 'Version 2 behöver inte längre PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan ta bort dem om inte en annan mod använder dem.', + 'Befintliga hexkartor, namn, platstokens och inställningar uppgraderas automatiskt vid första starten.', + 'Version 1-kommandona, inklusive makrot Hexploration_menu, fungerar fortfarande.', + 'I version 1 kunde varje token som representerade en rollperson avslöja hexar. Ställ in Tokens som avslöjar på Rollpersonstokens för att behålla det beteendet.', + ], + colV1: 'Kommandot version 1', + colV2: 'Kommandot version 2', + }, + troubleshooting: { + heading: 'Felsökning', + points: [ + 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', + 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', + 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', + 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', + ], + }, + languages: { + heading: 'Språk', + body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + colLanguage: 'Språk', + colNative: 'Eget namn', + colCode: 'Koda', + }, + credits: { + heading: 'Krediter', + original: 'Originalmod av', + maintainer: 'Version 2 underhålls av', + marketplace: 'Adas konstpaket på Roll20 Marketplace', + support: + 'Om du hittar en bugg eller har en idé, posta i Roll20 Mod-forumet eller öppna ett problem på GitHub och inkludera eventuella meddelanden från API-konsolloggen.', + }, + }, + }; + + const TRANSLATION$1 = { + titles: { + ready: 'Hexploration hazır.', + settings: 'Hexploration Ayarları', + languages: 'Bir Dil Seçin', + pageSettings: 'Sayfa Ayarları: {page}', + status: 'Hexploration Durumu: {page}', + help: 'Hexploration Komutları', + confirm: 'Lütfen Onaylayın', + }, + discovery: { + title: 'Konum Keşfedildi', + }, + menu: { + draw: 'Çizim', + reveal: 'Açığa Çıkarma ve Gizleme', + locations: 'Konumlar', + tools: 'Araçlar', + layerInUse: 'Yeni altıgenler şu katmana çiziliyor: {layer}.', + pageSettingsHelp: + 'Bu ayarlar yalnızca bu sayfa için geçerlidir. ★ işaretli ayarlar genel ayarları geçersiz kılar.', + }, + buttons: { + fill: 'Doldur', + fillInverse: 'Ters Doldur', + undo: 'Doldurmayı Geri Al', + reveal: 'Açığa Çıkar', + conceal: 'Gizle', + explore: 'Keşfet', + revealPage: 'Sayfayı Açığa Çıkar', + resetPage: 'Sayfayı Sıfırla', + mark: 'Konumu İşaretle', + unmark: 'İşareti Kaldır', + name: 'Altıgeni Adlandır', + settings: 'Ayarlar', + pageSettings: 'Sayfa Ayarları', + status: 'Durum', + rescan: 'Yeniden Tara', + calibrate: 'Kalibre Et', + calibrateReset: 'Kalibrasyonu Sıfırla', + help: 'Yardım', + change: 'Değiştir', + menu: 'Menü', + clearOverrides: 'Geçersiz Kılmaları Temizle', + confirmReset: 'Evet, Tüm Altıgenleri Kaldır', + }, + prompts: { + name: 'Konum adı (temizlemek için boş bırakın)', + }, + values: { + on: 'Açık', + off: 'Kapalı', + none: 'Hiçbiri', + hexLayer: { + auto: 'Otomatik (varsa ön plan)', + foreground: 'ön plan katmanı', + objects: 'jeton katmanı', + }, + revealBy: { + players: 'Oyuncu jetonları', + characters: 'Karakter jetonları', + all: 'Tüm jetonlar', + }, + revealMode: { + clear: 'Temizleme', + glimpse: 'Bakış', + }, + announce: { + all: 'Herkes', + gm: 'Yalnızca GM', + off: 'Kapalı', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Doldurma', + fillInverse: 'Ters Doldurma', + conceal: 'Gizleme', + }, + }, + settings: { + language: { + label: 'Dil', + desc: 'Menüler, mesajlar ve broşürler için dil.', + }, + hexLayer: { + label: 'Altıgen Katmanı', + desc: 'Yeni altıgenlerin çizildiği yer. Otomatik, ön plan katmanını (jetonların üstünde) dener; oyun bunu desteklemiyorsa jeton katmanına geri döner.', + }, + fillColor: { + label: 'Dolgu Rengi', + desc: 'Yeni altıgenlerin rengi. Şeffaf altıgenler için rgba() kullanın; örneğin rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Kenarlık Rengi', + desc: 'Yeni altıgenlerin ana hatlarının rengi.', + }, + labelColor: { + label: 'Etiket Rengi', + desc: 'Adlandırılmış altıgenlerdeki yalnızca GM ad etiketlerinin rengi.', + }, + glimpseColor: { + label: 'Bakış Rengi', + desc: 'Altıgenlerin Bakış modunda aldığı renk. Yarı saydam bir rgba() rengi kullanın.', + }, + strokeWidth: { + label: 'Kenarlık Kalınlığı', + desc: 'Yeni altıgenlerin ana hattının genişliği, piksel cinsinden (0 ila 20).', + }, + maxDistance: { + label: 'Altıgen Açığa Çıkarma Mesafesi', + desc: 'Altıgenler doldurulurken onlara kaydedilir, bu yüzden doldurmadan önce ayarlayın: sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için bu kadar altıgen mesafede olmalıdır; 0 ile yalnızca içlerine girilerek açığa çıkarlar. Dağlar veya ormanlar için kullanın. Sınır olmaması için boş bırakın.', + }, + revealDistance: { + label: 'Görüş Mesafesi', + desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + }, + lineOfSight: { + label: 'Görüş Hattı', + desc: 'Açıkken, Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş dağlar gibi örtülü kalan altıgenler, arkalarındaki altıgenleri gizler. Yalnızca 2 veya daha fazla Görüş Mesafesi ile fark yaratır.', + }, + revealPath: { + label: 'Yol Boyunca Açığa Çıkar', + desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + }, + revealBy: { + label: 'Açığa Çıkaran Jetonlar', + desc: 'Jeton katmanındaki hangi jetonlar altıgenleri ortaya çıkarır: bir oyuncu tarafından kontrol edilen jetonlar, herhangi bir karakteri temsil eden jetonlar veya her jeton.', + }, + revealMode: { + label: 'Açığa Çıkarma Modu', + desc: 'Temizleme, görüş alanındaki altıgenleri kaldırır. Bakış ise onları yarı saydam yapar; içlerine bir jeton girdiğinde kaldırılırlar.', + }, + announce: { + label: 'Keşifleri Duyur', + desc: 'Adlandırılmış bir konum keşfedildiğinde sohbet mesajını kimler görür?', + }, + pingDiscoveries: { + label: 'Keşifleri Pingle', + desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + }, + hideCoveredTokens: { + label: 'Örtülü Jetonları Gizle', + desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + }, + }, + status: { + engine: 'Oyun motoru', + grid: 'Izgara', + layer: 'Altıgen katmanı', + hexes: 'Altıgenler', + named: 'Adlandırılmış altıgenler', + icons: 'Konum jetonları', + glimpsed: 'Bakış altındaki altıgenler', + pending: 'Doldurma bekleyen konumlar', + calibrated: 'Kalibre edildi', + overrides: 'Sayfa geçersiz kılmaları', + undo: 'Geri alma mevcut', + }, + messages: { + filled: + 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', + revealed: 'Büyüler ortaya çıktı: {count}.', + revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', + confirmReset: + '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', + undone: + 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', + named: '"{name}" adlı altıgenler: {count}.', + unnamed: 'İsimler temizlendi: {count}.', + marked: + 'Mevcut altıgenlerde gizli konumlar: {attached}. Bunları kapsayan bir sonraki dolgu bekleniyor: {pending}.', + unmarked: 'Artık konum olmayan jetonlar: {count}.', + settingChanged: '{setting}, {value} olarak ayarlandı.', + rescanned: + 'Yeniden tarama tamamlandı. Tutulan: {kept}. Kabul edildi: {adopted}. Yeniden dosyalandı: {moved}. Eksik ve unutulmuş: {dropped}. Etiketler yeniden bağlandı: {labels}. Konum jetonları yeniden bağlandı: {icons}.', + calibrated: + 'Izgara kalibre edildi (sütun adımı {colStep}px, satır adımı {rowStep}px). Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + calibrationReset: + 'Kalibrasyon kaldırıldı. Yeniden tarama: {kept} tutuldu, {moved} yeniden dosyalandı, {adopted} kabul edildi.', + journalRebuilt: '"{help}" ve "{deck}" broşürleri yeniden oluşturuldu.', + migrated: + "Hexploration 1.x altıgen haritalarınız yükseltildi. Bu oyun bir Legacy oyunundan kopyalandıysa, her altıgen harita sayfasında Yeniden Tara'yı çalıştırın.", + pruned: + "Artık var olmayan ve unutulan kayıtlı altıgenler: {dropped}. Bu oyun veya sayfa kopyalandıysa, altıgenlerini yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + readyHint: 'Menü için !hexploration yazın veya "Hexploration - Command Deck" broşürünü açın.', + }, + warnings: { + foregroundUnavailable: + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', + }, + errors: { + noPage: 'Üzerinde çalışılacak sayfa bulunamadı.', + notHex: 'Bu sayfada altıgen ızgara kullanılmamaktadır.', + noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', + emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', + tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', + noTokens: 'Önce bir veya daha fazla jeton seçin.', + noHexes: + 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', + nothingToUndo: 'Geri alınacak bir dolgu yok.', + unknownCommand: 'Bilinmeyen komut: {command}', + unknownSetting: 'Bilinmeyen ayar: {key}', + unknownPageSetting: 'Sayfa başına ayarlanabilen ayarlar: {keys}', + invalidValue: '"{value}", {key} için geçerli bir değer değil.', + calibrateNeedsTokens: 'Altıgen merkezlere tutturulmuş bir veya iki jeton seçin.', + calibrateFailed: 'Bu jetonlar kalibrasyon için kullanılamaz.', + unexpected: 'Bir şeyler ters gitti: {message}', + }, + hints: { + noPage: 'Üzerinde çalışmak istediğiniz sayfayı açın veya üzerinde bir şey seçin.', + notHex: "Sayfa Ayarları'nda sayfa ızgarasını Hex (V) veya Hex (H) olarak ayarlayın.", + noPolygons: + 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', + emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', + tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', + noHexes: + 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + unknownCommand: 'Komutları listelemek için !hexploration help yazın.', + unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', + calibrateNeedsTokens: + 'Bir altıgenin ortasına bir jeton tutturun ve onu seçin. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgene tutturulmuş ikinci bir jeton seçin.', + calibrateFailed: + 'İki jetonun aynı satırda (Hex V) veya aynı sütunda (Hex H) ve en az bir altıgen aralıkla olması gerekir.', + unexpected: 'Ayrıntılar API konsolu günlüğündedir.', + }, + help: { + menu: 'Menüyü göster.', + fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', + fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', + undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + reveal: + 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', + conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', + explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', + resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', + name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + mark: 'Seçilen jetonları gizli konumlara dönüştürün.', + unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', + pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', + rescan: + 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', + calibrate: + 'Altıgen ızgarayı, altıgen merkezlerine tutturulmuş bir veya iki seçilmiş jetonla hizalayın.', + calibrateReset: 'Geçerli sayfanın kalibrasyonunu kaldırın.', + status: "Hexploration'ın geçerli sayfa hakkında bildiklerini gösterin.", + journal: 'Yardım ve Command Deck broşürlerini yeniden oluşturun.', + help: 'Bu listeyi göster.', + handout: 'Talimatların tamamı "{name}" broşüründe yer almaktadır.', + }, + deck: { + drawDesc: + "Bir alanın çevresine şekiller çizin, onları seçin ve Doldur'a tıklayın. Doldurmayı Geri Al, son doldurmayı geri alır.", + revealDesc: + 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', + locationsDesc: + 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + toolsDesc: + 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', + footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', + }, + handout: { + versionLabel: 'Sürüm', + subtitle: 'Roll20 için hex-hex keşif', + footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', + overview: { + heading: 'Genel Bakış', + body: 'Hexploration, bir altıgen haritayı opak altıgenlerle kaplar. Grup ilerledikçe içinden geçtiği altıgenler (ve isterseniz çevresindeki altıgenler) kaldırılır; böylece harita altıgen altıgen ortaya çıkar. Gizli konumlar altıgenlerin altına yerleştirilebilir ve bulunduklarında duyurulur. Jumpgate ve Legacy oyunlarında, her boyuttaki Hex (V) ve Hex (H) ızgaralarında çalışır.', + demo: "Kısa bir demo izleyin (versiyon 1'den)", + }, + quickStart: { + heading: 'Hızlı Başlangıç', + steps: [ + 'Izgarası Hex (V) veya Hex (H) olarak ayarlanmış bir sayfayı açın.', + 'Gizlenecek alanın çevresine bir veya daha fazla şekil (çokgen, dikdörtgen, elips veya serbest çizim) çizin.', + "Şekilleri seçin ve Command Deck'te Doldur'a tıklayın (veya !hexploration fill yazın). Şekiller altıgenlerle değiştirilir.", + "İsteğe bağlı: doldurmadan önce önemli yerler için jetonları seçin ve Konumu İşaretle'ye tıklayın. Altıgenlerin altında gizlenirler ve keşfedildiklerinde duyurulurlar.", + 'Bir oyuncu jetonunu taşıyın. İçinden geçtiği her altıgen ve Görüş Mesafesindeki altıgenler ortaya çıkar.', + ], + }, + commands: { + heading: 'Komutlar', + intro: + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", + colCommand: 'Emretmek', + colDesc: 'Ne işe yarar', + }, + revealing: { + heading: 'Açığa Çıkarma Nasıl Çalışır?', + points: [ + 'Altıgenleri yalnızca jeton katmanındaki jetonlar açığa çıkarır. Hangi jetonların sayılacağını Açığa Çıkaran Jetonlar ayarı belirler: varsayılan olarak oyuncu jetonları; böylece GM haritayı açmadan canavarları hareket ettirebilir.', + 'Bir jeton kapladığı her altıgeni (büyük jetonlar birkaç altıgen kaplar) ve Yol Boyunca Açığa Çıkar açıkken, ara noktalar dahil sürüklendiği rotadaki her altıgeni açığa çıkarır.', + 'Görüş Mesafesi, bu altıgenlerin her birinin çevresindeki altıgenleri en yakından başlayarak açığa çıkarır. Görüş Hattı açıkken, bir altıgen ile jeton arasında örtülü bir altıgen bulunduğu sürece o altıgen açığa çıkmaz. Yakın altıgenler genellikle önce açığa çıktığından, açık arazide Görüş Hattı hiçbir şeyi değiştirmez: yalnızca 2 veya daha fazla Görüş Mesafesi ve Altıgen Açığa Çıkarma Mesafesi ile doldurulmuş arazi gibi örtülü kalan altıgenler olduğunda önem taşır.', + 'Altıgen Açığa Çıkarma Mesafesi, her altıgen doldurulurken ona kaydedilir, bu yüzden doldurmadan önce ayarlayın; sonradan değiştirmek haritada zaten bulunan altıgenleri etkilemez. Bir jeton ne kadar uzağı görürse görsün, altıgenleri açığa çıkarmak için o kadar altıgen mesafede olmalıdır ve 0 ile yalnızca içlerine girilerek açığa çıkarlar. Bir sıradağ için: Altıgen Açığa Çıkarma Mesafesi ayarını 0 yapın, dağları doldurun, ayarı yeniden boşaltın, ardından ötedeki araziyi doldurun. Görüş Mesafesi 3 ve Görüş Hattı açıkken grup çevresindeki açık araziyi görür, ancak dağları ya da arkalarında olanları göremez. Her dağ altıgeni, bir jeton içine girdiğinde açığa çıkar.', + "Bakış modunda, görüş alanındaki altıgenler kaybolmak yerine yarı saydam olur ve içlerine bir jeton girdiğinde kaldırılır. Bakış durumundaki altıgenler Görüş Hattı'nı engellemez.", + 'Roll20, jeton adlarını, çubuklarını ve auralarını altıgenlerin üzerine çizer. Örtülü Jetonları Gizle açıkken, örtülü bir altıgenin altındaki jetonun oyunculara görünen adı, çubukları ve auraları açığa çıkana kadar kapatılır; böylece gizli canavarlar kendilerini belli etmez. Jeton örtülüyken bunlardan birini açarsanız gizli kalır ve jeton açığa çıktığında açılır.', + "API, diğer modların yaptığı hareketleri bildirmez. TokenMod hareketleri otomatik olarak algılanır; diğer modlar için jetonları seçip Keşfet'e tıklayın veya kendi modunuzdan Hexploration.revealAround(token) çağırın.", + ], + }, + locations: { + heading: 'Adlandırılmış Altıgenler ve Konumlar', + points: [ + 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', + "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", + 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", + "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", + ], + }, + settings: { + heading: 'Ayarlar', + intro: + "Ayarları !hexploration set ile (veya Ayarlar düğmesiyle) değiştirin. Altıgen Katmanı, Açığa Çıkaran Jetonlar ve Dil, Mod'un ayarlar sayfasından da ayarlanabilir.", + colKey: 'Anahtar', + colName: 'Ayar', + colDesc: 'Tanım', + perPage: '(Sayfa başına ayarlanabilir.)', + }, + jumpgate: { + heading: 'Jumpgate ve Eski', + points: [ + 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', + 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', + "Jumpgate matematiksel olarak düzgün altıgenler çizer; bunların şekli Legacy altıgenlerinden biraz farklıdır. Altıgenler sayfanın ızgarasıyla hizalı değilse bir altıgenin merkezine bir jeton tutturun, onu seçin ve Kalibre Et'e tıklayın. Altıgen boyutunu da düzeltmek için aynı satırdaki (Hex V) veya sütundaki (Hex H) komşu altıgenlerde iki jeton seçin.", + "Bir sayfa veya oyun kopyalandığında altıgenleri yeni kimlikler alır. Onları ad etiketleri ve konum jetonlarıyla birlikte yeniden bulmak için sayfada Yeniden Tara'yı çalıştırın.", + ], + }, + upgrading: { + heading: "Sürüm 1'den yükseltme", + points: [ + "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", + 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', + "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", + ], + colV1: 'Sürüm 1 komutu', + colV2: 'Sürüm 2 komutu', + }, + troubleshooting: { + heading: 'Sorun giderme', + points: [ + 'Bir jeton hareket ettiğinde hiçbir şey olmuyor: jetonun jeton katmanında olduğunu ve Açığa Çıkaran Jetonlar ayarına uyduğunu, sayfada da altıgenler bulunduğunu (!hexploration status) kontrol edin.', + "Altıgenler ızgaradan kaymış: Kalibre Et'i kullanın, ardından haritanın farklı yerlerindeki birkaç altıgeni bir jetonla kontrol edin.", + "Bir sayfayı veya oyunu kopyaladıktan sonra altıgenler açığa çıkmıyor: sayfada Yeniden Tara'yı çalıştırın.", + 'Doldur, alanda altıgen merkezi olmadığını söylüyor: şeklin en az bir altıgenin merkezini içermesi gerekir.', + 'Başka bir şey için API konsolu günlüğünü kontrol edin ve yardım isterken mesajlarını ekleyin.', + ], + }, + languages: { + heading: 'Diller', + body: '!hexploration set language ile bir dil seçin. Mevcut diller:', + colLanguage: 'Dil', + colNative: 'Yerel ad', + colCode: 'Kod', + }, + credits: { + heading: 'Kredi', + original: 'Orijinal modun yapımcısı', + maintainer: 'Versiyon 2 tarafından sürdürülen', + marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", + support: + "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", + }, + }, + }; + + const TRANSLATION = { + titles: { + ready: 'Hexploration готовий.', + settings: 'Налаштування Hexploration', + languages: 'Виберіть мову', + pageSettings: 'Налаштування сторінки: {page}', + status: 'Статус Hexploration: {page}', + help: 'Команди Hexploration', + confirm: 'Будь ласка, підтвердьте', + }, + discovery: { + title: 'Локацію виявлено', + }, + menu: { + draw: 'Малювання', + reveal: 'Розкриття і приховування', + locations: 'Локації', + tools: 'Інструменти', + layerInUse: 'Нові гекси малюються на цьому шарі: {layer}.', + pageSettingsHelp: + 'Ці налаштування застосовуються лише до цієї сторінки. Налаштування, позначені ★, замінюють глобальні налаштування.', + }, + buttons: { + fill: 'Заповнити', + fillInverse: 'Зворотне заповнення', + undo: 'Скасувати заповнення', + reveal: 'Розкрити', + conceal: 'Приховати', + explore: 'Дослідити', + revealPage: 'Розкрити сторінку', + resetPage: 'Скинути сторінку', + mark: 'Позначити локацію', + unmark: 'Зняти позначку', + name: 'Назвати гекс', + settings: 'Налаштування', + pageSettings: 'Налаштування сторінки', + status: 'Статус', + rescan: 'Пересканувати', + calibrate: 'Відкалібрувати', + calibrateReset: 'Скинути калібрування', + help: 'Довідка', + change: 'Змінити', + menu: 'Меню', + clearOverrides: 'Скинути перевизначення', + confirmReset: 'Так, видалити всі гекси', + }, + prompts: { + name: 'Назва місця (залиште порожнім, щоб очистити)', + }, + values: { + on: 'Увімкнено', + off: 'Вимкнено', + none: 'Немає', + hexLayer: { + auto: 'Авто (передній план, якщо доступний)', + foreground: 'шар переднього плану', + objects: 'шар маркерів', + }, + revealBy: { + players: 'Маркери гравців', + characters: 'Маркери персонажів', + all: 'Усі маркери', + }, + revealMode: { + clear: 'Очищення', + glimpse: 'Проблиск', + }, + announce: { + all: 'Всі', + gm: 'Лише GM', + off: 'Вимкнено', + }, + orientation: { + vertical: 'Hex (V)', + horizontal: 'Hex (H)', + }, + fillKind: { + fill: 'Заповнення', + fillInverse: 'Зворотне заповнення', + conceal: 'Приховування', + }, + }, + settings: { + language: { + label: 'Мова', + desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', + }, + hexLayer: { + label: 'Шар шестикутників', + desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', + }, + fillColor: { + label: 'Колір заливки', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + }, + strokeColor: { + label: 'Колір контуру', + desc: 'Колір контуру нових гексів.', + }, + labelColor: { + label: 'Колір міток', + desc: 'Колір написів імен лише для GM на іменованих гексах.', + }, + glimpseColor: { + label: 'Колір проблиску', + desc: 'Колір, якого набувають гекси в режимі «Проблиск». Використовуйте напівпрозорий колір rgba().', + }, + strokeWidth: { + label: 'Товщина контуру', + desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', + }, + maxDistance: { + label: 'Відстань розкриття шестикутників', + desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', + }, + revealDistance: { + label: 'Дальність огляду', + desc: 'Скільки гексів навколо рухомого жетона відкрито (від 0 до 20). 0 показує лише гекси, через які проходить жетон.', + }, + lineOfSight: { + label: 'Лінія видимості', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', + }, + revealPath: { + label: 'Розкривати вздовж шляху', + desc: 'Коли ввімкнено, відображається кожен гекс, через який проходить жетон під час перетягування (включно з маршрутними точками), а не лише там, де він зупиняється.', + }, + revealBy: { + label: 'Маркери, що розкривають', + desc: 'Які жетони на шарі жетонів розкривають гекси: жетони, якими керує гравець, жетони, які представляють будь-якого персонажа, або кожен жетон.', + }, + revealMode: { + label: 'Режим розкриття', + desc: '«Очищення» видаляє гекси в межах видимості. «Проблиск» натомість робить їх напівпрозорими; вони видаляються, коли на них заходить маркер.', + }, + announce: { + label: 'Оголошувати відкриття', + desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + }, + pingDiscoveries: { + label: 'Пінгувати знахідки', + desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + }, + hideCoveredTokens: { + label: 'Ховати маркери під гексами', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + }, + }, + status: { + engine: 'Ігровий рушій', + grid: 'Сітка', + layer: 'Шар шестикутників', + hexes: 'Гекси', + named: 'Іменовані гекси', + icons: 'Маркери локацій', + glimpsed: 'Гекси в проблиску', + pending: 'Локації, що чекають на заповнення', + calibrated: 'Відкалібровано', + overrides: 'Перевизначення сторінки', + undo: 'Доступне скасування', + }, + messages: { + filled: + 'Заповнення завершено. Намальовані гекси: {created}. Рестайлінг: {restyled}. Приховані місця: {icons}.', + revealed: 'Розкрито гекси: {count}.', + revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', + confirmReset: + 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', + resetPage: 'Зі сторінки видалено шестигранники: {count}.', + undone: + 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', + named: 'Гекси з назвою "{name}": {count}.', + unnamed: 'Імена видалено: {count}.', + marked: + 'Місця, приховані в існуючих гексах: {attached}. Очікування наступного заповнення, яке охопить їх: {pending}.', + unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', + settingChanged: '{setting} встановлено на {value}.', + rescanned: + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + calibrated: + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + calibrationReset: + 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', + migrated: + 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', + pruned: + 'Забуто збережені гекси, яких більше не існує: {dropped}. Якщо цю гру чи сторінку було скопійовано, виконайте «Пересканувати» на сторінці, щоб знову знайти її гекси.', + readyHint: + 'Введіть !hexploration, щоб відкрити меню, або відкрийте роздатковий матеріал "Hexploration - Command Deck".', + }, + warnings: { + foregroundUnavailable: + 'Ця гра не підтримує малювання на передньому шарі, тому гекси були намальовані на шарі жетонів.', + someFailed: + 'Гекси, які не вдалося намалювати: {count}. Перевірте консоль API для отримання деталей.', + }, + errors: { + noPage: 'Не вдалося знайти сторінку для роботи.', + notHex: 'На цій сторінці не використовується гексова сітка.', + noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', + emptyArea: 'Вибрана область не містить шестигранних центрів.', + tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', + nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', + nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + noTokens: 'Спочатку виберіть один або кілька токенів.', + noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', + nothingToUndo: 'Немає заповнення, яке можна скасувати.', + unknownCommand: 'Невідома команда: {command}', + unknownSetting: 'Невідоме налаштування: {key}', + unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', + invalidValue: '"{value}" не є дійсним значенням для {key}.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', + unexpected: 'Щось пішло не так: {message}', + }, + hints: { + noPage: 'Відкрийте сторінку, над якою хочете працювати, або виберіть щось на ній.', + notHex: 'Установіть для сітки сторінки Hex (V) або Hex (H) у налаштуваннях сторінки.', + noPolygons: + 'Намалюйте багатокутник, прямокутник, еліпс або форму від руки навколо області, виберіть її та повторіть спробу.', + emptyArea: 'Намалюйте більшу форму або перевірте параметри сітки сторінки.', + tooMany: 'Заповніть меншу область або розділіть її на кілька фігур.', + noHexes: + 'Гекси знаходяться на передньому плані або шарі жетонів; перейдіть на цей шар, щоб вибрати їх.', + unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', + unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', + calibrateNeedsTokens: + 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + calibrateFailed: + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + unexpected: 'Подробиці в журналі консолі API.', + }, + help: { + menu: 'Показати меню.', + fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', + undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', + reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', + revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', + resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', + name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', + mark: 'Перетворіть вибрані жетони на приховані місця.', + unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + set: 'Змінити налаштування або показати всі налаштування.', + pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageClear: 'Видаліть перевизначення поточної сторінки.', + rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', + calibrate: + 'Вирівняйте гексову сітку за одним або двома вибраними маркерами, прив’язаними до центрів гексів.', + calibrateReset: 'Видалити калібрування поточної сторінки.', + status: 'Покажіть, що Hexploration знає про поточну сторінку.', + journal: 'Перебудуйте роздаткові матеріали «Довідка» та «Command Deck».', + help: 'Покажіть цей список.', + handout: 'Повні інструкції наведено в роздатковому матеріалі "{name}".', + }, + deck: { + drawDesc: + 'Обведіть область фігурами, виділіть їх і натисніть «Заповнити». «Скасувати заповнення» скасовує останнє заповнення.', + revealDesc: + 'Виділіть гекси, фігури або маркери, щоб розкрити їх або знову приховати. «Дослідити» розкриває гекси навколо вибраних маркерів, ніби вони туди перемістилися.', + locationsDesc: + 'Виберіть жетони, щоб приховати їх як місця під гексами. Виберіть гекси або жетони, щоб назвати гекс.', + toolsDesc: + 'Налаштування, перевизначення сторінок, статус, повторне сканування скопійованих сторінок і калібрування сітки.', + footer: 'Перегляньте роздатковий матеріал "{help}", щоб отримати повні інструкції.', + }, + handout: { + versionLabel: 'Версія', + subtitle: 'Дослідження гекс за гексом для Roll20', + footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', + overview: { + heading: 'Огляд', + body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + demo: 'Перегляньте коротку демонстрацію (з версії 1)', + }, + quickStart: { + heading: 'Швидкий старт', + steps: [ + 'Відкрийте сторінку, сітку якої встановлено як Hex (V) або Hex (H).', + 'Намалюйте одну або кілька фігур (багатокутник, прямокутник, еліпс або від руки) навколо області, яку потрібно сховати.', + 'Виберіть фігури та натисніть «Заповнити» в Command Deck (або введіть !hexploration fill). Фігури буде замінено гексами.', + 'Додатково: перед заповненням виділіть маркери важливих місць і натисніть «Позначити локацію». Вони сховаються під гексами, а коли їх виявлять, про це буде оголошено.', + 'Перемістіть маркер гравця. Кожен гекс, через який він проходить, і гекси в межах його «Дальності огляду» розкриваються.', + ], + }, + commands: { + heading: 'Команди', + intro: + "Тільки GM можуть використовувати ці команди. Більшість діють на обрані об'єкти; решта діють на сторінці, яку ви переглядаєте.", + colCommand: 'Команда', + colDesc: 'Що воно робить', + }, + revealing: { + heading: 'Як працює розкриття', + points: [ + 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', + 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', + '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', + "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", + 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', + ], + }, + locations: { + heading: 'Іменовані гекси та локації', + points: [ + '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', + 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', + 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', + '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', + ], + }, + settings: { + heading: 'Налаштування', + intro: + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', + colKey: 'ключ', + colName: 'Налаштування', + colDesc: 'опис', + perPage: '(Можна встановити на сторінку.)', + }, + jumpgate: { + heading: 'Jumpgate і Legacy', + points: [ + 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', + 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', + ], + }, + upgrading: { + heading: 'Оновлення з версії 1', + points: [ + 'Версія 2 більше не потребує PathMath, MatrixMath, Vector Math або HTML Builder. Ви можете видалити їх, якщо інший мод не використовує їх.', + 'Наявні гексові карти, назви, маркери локацій і налаштування оновлюються автоматично під час першого запуску.', + 'Команди версії 1, включаючи макрос Hexploration_menu, все ще працюють.', + 'У версії 1 гекси міг розкривати будь-який маркер, що представляв персонажа. Щоб зберегти таку поведінку, встановіть для «Маркери, що розкривають» значення «Маркери персонажів».', + ], + colV1: 'Команда версії 1', + colV2: 'Команда версії 2', + }, + troubleshooting: { + heading: 'Усунення несправностей', + points: [ + 'Коли маркер рухається, нічого не відбувається: перевірте, чи маркер на шарі маркерів і відповідає параметру «Маркери, що розкривають», а на сторінці є гекси (!hexploration status).', + 'Гекси зміщені відносно сітки: натисніть «Відкалібрувати», а потім перевірте маркером кілька гексів у різних частинах карти.', + 'Гекси перестали розкриватися після копіювання сторінки або гри: виконайте «Пересканувати» на сторінці.', + '«Заповнити» повідомляє, що в області немає центрів гексів: фігура має містити центр принаймні одного гекса.', + 'Щодо іншого, перевірте журнал консолі API та включіть його повідомлення під час запиту про допомогу.', + ], + }, + languages: { + heading: 'Мови', + body: 'Виберіть мову командою !hexploration set language. Доступні мови:', + colLanguage: 'Мова', + colNative: 'Самоназва', + colCode: 'Код', + }, + credits: { + heading: 'Кредити', + original: 'Оригінальний мод від', + maintainer: 'Версія 2 підтримується', + marketplace: 'Художні набори Ади на Roll20 Marketplace', + support: + 'Якщо ви знайшли помилку або маєте ідею, опублікуйте на форумі Roll20 Mod або відкрийте проблему на GitHub і додайте будь-які повідомлення з журналу консолі API.', + }, + }, + }; + + const DEFAULT_LOCALE = 'en-US'; + + const LOCALE_DEFINITIONS = Object.freeze([ + { + code: 'af', + name: 'Afrikaans', + direction: 'ltr', + translationFile: 'locale/af.js', + flag: '🇿🇦', + flagLabel: 'Flag of South Africa', + }, + { + code: 'ca', + name: 'Catalan', + nativeName: 'Català', + direction: 'ltr', + translationFile: 'locale/ca.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'zh-TW', + name: 'Chinese (Traditional)', + nativeName: '正體中文', + direction: 'ltr', + translationFile: 'locale/zh-TW.js', + aliases: ['zh'], + flag: '🇹🇼', + flagLabel: 'Flag of Taiwan', + }, + { + code: 'cs', + name: 'Czech', + nativeName: 'Čeština', + direction: 'ltr', + translationFile: 'locale/cs.js', + flag: '🇨🇿', + flagLabel: 'Flag of Czechia', + }, + { + code: 'da', + name: 'Danish', + nativeName: 'Dansk', + direction: 'ltr', + translationFile: 'locale/da.js', + flag: '🇩🇰', + flagLabel: 'Flag of Denmark', + }, + { + code: 'nl', + name: 'Dutch', + nativeName: 'Nederlands', + direction: 'ltr', + translationFile: 'locale/nl.js', + flag: '🇳🇱', + flagLabel: 'Flag of the Netherlands', + }, + { + code: 'en-US', + name: 'English', + nativeName: 'English', + direction: 'ltr', + translationFile: 'locale/en-US.js', + aliases: ['en'], + flag: '🇺🇸', + flagLabel: 'Flag of the United States', + }, + { + code: 'fi', + name: 'Finnish', + nativeName: 'Suomeksi', + direction: 'ltr', + translationFile: 'locale/fi.js', + flag: '🇫🇮', + flagLabel: 'Flag of Finland', + }, + { + code: 'fr', + name: 'French', + nativeName: 'Français', + direction: 'ltr', + translationFile: 'locale/fr.js', + flag: '🇫🇷', + flagLabel: 'Flag of France', + }, + { + code: 'de', + name: 'German', + nativeName: 'Deutsch', + direction: 'ltr', + translationFile: 'locale/de.js', + flag: '🇩🇪', + flagLabel: 'Flag of Germany', + }, + { + code: 'el', + name: 'Greek', + nativeName: 'Ελληνικά', + direction: 'ltr', + translationFile: 'locale/el.js', + flag: '🇬🇷', + flagLabel: 'Flag of Greece', + }, + { + code: 'he', + name: 'Hebrew', + nativeName: 'עברית', + direction: 'rtl', + translationFile: 'locale/he.js', + flag: '🇮🇱', + flagLabel: 'Flag of Israel', + }, + { + code: 'hu', + name: 'Hungarian', + nativeName: 'Magyar', + direction: 'ltr', + translationFile: 'locale/hu.js', + flag: '🇭🇺', + flagLabel: 'Flag of Hungary', + }, + { + code: 'it', + name: 'Italian', + nativeName: 'Italiano', + direction: 'ltr', + translationFile: 'locale/it.js', + flag: '🇮🇹', + flagLabel: 'Flag of Italy', + }, + { + code: 'ja', + name: 'Japanese', + nativeName: '日本語', + direction: 'ltr', + translationFile: 'locale/ja.js', + flag: '🇯🇵', + flagLabel: 'Flag of Japan', + }, + { + code: 'ko', + name: 'Korean', + nativeName: '한국어', + direction: 'ltr', + translationFile: 'locale/ko.js', + flag: '🇰🇷', + flagLabel: 'Flag of South Korea', + }, + { + code: 'pl', + name: 'Polish', + nativeName: 'Polski', + direction: 'ltr', + translationFile: 'locale/pl.js', + flag: '🇵🇱', + flagLabel: 'Flag of Poland', + }, + { + code: 'pt-PT', + name: 'Portuguese (Portugal)', + nativeName: 'Português - Portugal', + direction: 'ltr', + translationFile: 'locale/pt-PT.js', + aliases: ['pt'], + flag: '🇵🇹', + flagLabel: 'Flag of Portugal', + }, + { + code: 'pt-BR', + name: 'Portuguese (Brazil)', + nativeName: 'Português - Brasil', + direction: 'ltr', + translationFile: 'locale/pt-BR.js', + flag: '🇧🇷', + flagLabel: 'Flag of Brazil', + }, + { + code: 'ru', + name: 'Russian', + nativeName: 'Русский', + direction: 'ltr', + translationFile: 'locale/ru.js', + flag: '🇷🇺', + flagLabel: 'Flag of Russia', + }, + { + code: 'es', + name: 'Spanish', + nativeName: 'Español', + direction: 'ltr', + translationFile: 'locale/es.js', + flag: '🇪🇸', + flagLabel: 'Flag of Spain', + }, + { + code: 'sv', + name: 'Swedish', + nativeName: 'Svenska', + direction: 'ltr', + translationFile: 'locale/sv.js', + flag: '🇸🇪', + flagLabel: 'Flag of Sweden', + }, + { + code: 'tr', + name: 'Turkish', + nativeName: 'Türkçe', + direction: 'ltr', + translationFile: 'locale/tr.js', + flag: '🇹🇷', + flagLabel: 'Flag of Turkey', + }, + { + code: 'uk', + name: 'Ukrainian', + nativeName: 'Українська', + direction: 'ltr', + translationFile: 'locale/uk.js', + flag: '🇺🇦', + flagLabel: 'Flag of Ukraine', + }, + ]); + + const SUPPORTED_LOCALES = Object.freeze(LOCALE_DEFINITIONS.map(({ code }) => code)); + const VALID_LOCALES = new Set(SUPPORTED_LOCALES); + const LOCALE_ALIASES = Object.freeze( + LOCALE_DEFINITIONS.reduce((aliases, locale) => { + for (const alias of locale.aliases || []) { + aliases[alias] = locale.code; + } + return aliases; + }, {}) + ); + const LOCALE_LABELS = Object.freeze( + LOCALE_DEFINITIONS.reduce((labels, locale) => { + const displayName = locale.nativeName + ? `${locale.code} - ${locale.name} (${locale.nativeName})` + : `${locale.code} - ${locale.name}`; + labels[locale.code] = displayName; + return labels; + }, {}) + ); + SUPPORTED_LOCALES.map((code) => LOCALE_LABELS[code]).join(' / '); + + const TRANSLATIONS = { + af: TRANSLATION$m, + ca: TRANSLATION$l, + 'zh-TW': TRANSLATION$k, + cs: TRANSLATION$j, + da: TRANSLATION$i, + nl: TRANSLATION$h, + 'en-US': localeEnUS, + fi: TRANSLATION$g, + fr: TRANSLATION$f, + de: TRANSLATION$e, + el: TRANSLATION$d, + he: TRANSLATION$c, + hu: TRANSLATION$b, + it: TRANSLATION$a, + ja: TRANSLATION$9, + ko: TRANSLATION$8, + pl: TRANSLATION$7, + 'pt-PT': TRANSLATION$6, + 'pt-BR': TRANSLATION$5, + ru: TRANSLATION$4, + es: TRANSLATION$3, + sv: TRANSLATION$2, + tr: TRANSLATION$1, + uk: TRANSLATION, + }; + + /** + * Returns the canonical locale for a supported locale string or alias. + * Matching is case-insensitive after exact matches are checked. + * + * @param {string} lang Locale string or alias (e.g. 'en', 'fr', 'zh-TW'). + * @returns {string} Canonical locale code, or an empty string when unsupported. + */ + function normalizeLocale(lang) { + const s = typeof lang === 'string' ? lang.trim() : ''; + if (VALID_LOCALES.has(s)) { + return s; + } + if (LOCALE_ALIASES[s]) { + return LOCALE_ALIASES[s]; + } + const normalized = s.toLowerCase(); + const found = Array.from(VALID_LOCALES).find((locale) => locale.toLowerCase() === normalized); + return ( + found || + Object.entries(LOCALE_ALIASES).find(([alias]) => alias.toLowerCase() === normalized)?.[1] || + '' + ); + } + + /** + * Returns a valid canonical locale, falling back to the default when unsupported. + * + * @param {string} lang Locale string to validate. + * @returns {string} Validated canonical locale. + */ + function getLocale(lang) { + return normalizeLocale(lang) || DEFAULT_LOCALE; + } + + /** + * Navigates a nested object following dot-separated key path segments. + * + * @param {object} obj Root object. + * @param {string[]} parts Key path segments. + * @returns {*} Value at the path, or undefined. + */ + function getNestedValue(obj, parts) { + let current = obj; + for (const part of parts) { + if (current == null || typeof current !== 'object') { + return undefined; + } + current = current[part]; + } + return current; + } + + /** + * Returns the raw translated value (string, array or object) for a key, + * falling back to en-US when the key is missing in the requested locale. + * + * @param {string} key Dot-separated translation key. + * @param {string} locale Locale code. + * @returns {*} Raw value, or undefined when not found. + */ + function tRaw(key, locale) { + const lang = getLocale(locale); + const parts = key.split('.'); + const value = getNestedValue(TRANSLATIONS[lang], parts); + return value === undefined && lang !== DEFAULT_LOCALE + ? getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts) + : value; + } + + /** + * Returns the text direction CSS for a locale. + * + * @param {string} locale Locale code. + * @returns {string} CSS declarations, empty for left-to-right locales. + */ + function getDirectionStyle(locale) { + const lang = getLocale(locale); + const def = LOCALE_DEFINITIONS.find((d) => d.code === lang); + return def?.direction === 'rtl' ? 'direction:rtl;text-align:right;' : ''; + } + + /** + * Returns the translated string for a dot-separated key, interpolating {placeholder} vars. + * Falls back to en-US when the key is missing in the requested locale. + * No HTML escaping is performed — callers must pre-escape HTML-unsafe values. + * + * @param {string} key Dot-separated translation key (e.g. 'errors.noTokensSelected'). + * @param {string} locale Locale code. + * @param {object} [vars] Interpolation variables mapped to {placeholder} names. + * @returns {string} Translated and interpolated string. Returns the key when not found. + */ + function t(key, locale, vars = {}) { + const lang = getLocale(locale); + const parts = key.split('.'); + let value = getNestedValue(TRANSLATIONS[lang], parts); + + if (value === undefined && lang !== DEFAULT_LOCALE) { + value = getNestedValue(TRANSLATIONS[DEFAULT_LOCALE], parts); + } + + if (typeof value !== 'string') { + return key; + } + + return value.replaceAll(/\{(\w+)\}/g, (_, k) => (k in vars ? String(vars[k]) : `{${k}}`)); + } + + // --------------------------------------------------------------------------- + // Config validation (pure) + // --------------------------------------------------------------------------- + + /** + * Validates one configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Result; `value` is the normalised value when valid. + */ + function validateConfigValue(key, raw) { + const ok = (value) => ({ valid: true, value }); + const bad = { valid: false }; + + switch (key) { + case 'language': { + const lang = normalizeLocale(raw); + return lang ? ok(lang) : bad; + } + case 'hexLayer': + return HEX_LAYER_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealBy': + return REVEAL_BY_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'revealMode': + return REVEAL_MODE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'announce': + return ANNOUNCE_OPTIONS.includes(raw) ? ok(raw) : bad; + case 'fillColor': + case 'strokeColor': + case 'labelColor': + case 'glimpseColor': + return isValidColor(raw) ? ok(toText(raw)) : bad; + case 'strokeWidth': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 ? bad : ok(clamp(n, 0, MAX_STROKE_WIDTH)); + } + case 'revealDistance': { + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'maxDistance': { + if (raw === null || raw === undefined || ['', '-', 'none', 'off'].includes(toText(raw))) { + return ok(null); + } + const n = typeof raw === 'number' ? Math.trunc(raw) : parseStrictInt(raw); + return n === null || !Number.isFinite(n) || n < 0 + ? bad + : ok(clamp(n, 0, MAX_REVEAL_DISTANCE)); + } + case 'lineOfSight': + case 'revealPath': + case 'pingDiscoveries': + case 'hideCoveredTokens': { + const b = parseBoolean(raw); + return b === null ? bad : ok(b); + } + default: + return bad; + } + } + + /** + * Merges a possibly incomplete or invalid config with defaults. + * + * @param {object} config Config to merge. + * @param {object} [defaults] Defaults to fall back on. + * @returns {object} Complete config. + */ + function mergeConfig(config, defaults = DEFAULT_CONFIG) { + const c = isRecord(config) ? config : {}; + const merged = {}; + for (const key of Object.keys(DEFAULT_CONFIG)) { + const result = key in c ? validateConfigValue(key, c[key]) : { valid: false }; + merged[key] = result.valid ? result.value : defaults[key]; + } + return merged; + } + + /** + * Keeps only valid per-page overrides. + * + * @param {object} settings Raw page settings. + * @returns {object} Clean page settings. + */ + function mergePageSettings(settings) { + const clean = {}; + if (!isRecord(settings)) { + return clean; + } + for (const key of PAGE_SETTING_KEYS) { + if (key in settings) { + const result = validateConfigValue(key, settings[key]); + if (result.valid) { + clean[key] = result.value; + } + } + } + return clean; + } + + // --------------------------------------------------------------------------- + // State shape and migration (pure) + // --------------------------------------------------------------------------- + + /** + * Creates an empty v2 state object. + * + * @returns {object} Fresh state. + */ + function createDefaultState() { + return { + schemaVersion: SCHEMA_VERSION, + version: SCRIPT_VERSION, + config: { ...DEFAULT_CONFIG }, + pages: {}, + pendingLocations: {}, + lastFill: null, + coveredTokens: {}, + notices: {}, + }; + } + + /** + * Normalises one stored hex record. + * + * @param {string} key "row,col" key. + * @param {object} raw Stored record. + * @returns {object|null} Clean hex record, or null when unusable. + */ + function normaliseHex(key, raw) { + const coords = parseHexKey(key); + if (!coords || !isRecord(raw) || !toText(raw.id)) { + return null; + } + const hex = { + id: toText(raw.id), + type: raw.type === 'pathv2' ? 'pathv2' : raw.type === 'path' ? 'path' : null, + row: coords[0], + col: coords[1], + }; + if (toText(raw.name)) { + hex.name = toText(raw.name); + } + if (toText(raw.nameId)) { + hex.nameId = toText(raw.nameId); + } + if (toText(raw.iconId)) { + hex.iconId = toText(raw.iconId); + } + const maxDistance = validateConfigValue('maxDistance', raw.maxDistance); + if (maxDistance.valid && maxDistance.value !== null) { + hex.maxDistance = maxDistance.value; + } + if (raw.glimpsed === true) { + hex.glimpsed = true; + } + return hex; + } + + /** + * Normalises a page's stored data. + * + * @param {object} raw Stored page data. + * @returns {object} Clean page data. + */ + function normalisePage(raw) { + const page = { hexes: {}, settings: {}, calibration: null }; + if (!isRecord(raw)) { + return page; + } + if (isRecord(raw.hexes)) { + for (const [key, value] of Object.entries(raw.hexes)) { + const hex = normaliseHex(key, value); + if (hex) { + page.hexes[`${hex.row},${hex.col}`] = hex; + } + } + } + page.settings = mergePageSettings(raw.settings); + if (isRecord(raw.calibration)) { + const cal = {}; + for (const k of ['colStep', 'rowStep', 'originX', 'originY']) { + if (Number.isFinite(raw.calibration[k])) { + cal[k] = raw.calibration[k]; + } + } + page.calibration = Object.keys(cal).length === 4 ? cal : null; + } + return page; + } + + /** + * Converts any stored state (v1, v2 or damaged) into a clean v2 state. + * + * v1 stored hexes in `pageHexes[pageId]["row,col"]` with a parallel `hexIdMap`, + * and a flat config. Its defaults differed (no reveal distance), so missing + * v1 values fall back to v1 behaviour rather than the new defaults. + * + * @param {*} raw Stored state. + * @returns {{state: object, migratedFrom: number|null}} Clean state and the + * schema it was migrated from (null when no migration was needed). + */ + function migrateState(raw) { + const fresh = createDefaultState(); + if (!isRecord(raw)) { + return { state: fresh, migratedFrom: null }; + } + + if (isRecord(raw.pageHexes) && !isRecord(raw.pages)) { + const v1Defaults = { ...DEFAULT_CONFIG, revealDistance: 0, strokeWidth: 0 }; + fresh.config = mergeConfig(raw.config, v1Defaults); + for (const [pageId, hexes] of Object.entries(raw.pageHexes)) { + const page = normalisePage({ hexes }); + if (Object.keys(page.hexes).length > 0) { + fresh.pages[pageId] = page; + } + } + return { state: fresh, migratedFrom: 1 }; + } + + fresh.config = mergeConfig(raw.config); + if (isRecord(raw.pages)) { + for (const [pageId, page] of Object.entries(raw.pages)) { + fresh.pages[pageId] = normalisePage(page); + } + } + if (isRecord(raw.pendingLocations)) { + for (const [tokenId, pageId] of Object.entries(raw.pendingLocations)) { + if (toText(pageId)) { + fresh.pendingLocations[tokenId] = toText(pageId); + } + } + } + if (isRecord(raw.lastFill)) { + fresh.lastFill = raw.lastFill; + } + if (isRecord(raw.coveredTokens)) { + for (const [tokenId, entry] of Object.entries(raw.coveredTokens)) { + if (isRecord(entry) && toText(entry.pageId) && isRecord(entry.saved)) { + fresh.coveredTokens[tokenId] = { + pageId: toText(entry.pageId), + saved: { ...entry.saved }, + }; + } + } + } + if (isRecord(raw.notices)) { + fresh.notices = { ...raw.notices }; + } + return { state: fresh, migratedFrom: null }; + } + + // --------------------------------------------------------------------------- + // Persistent state access (Roll20) + // --------------------------------------------------------------------------- + + let pathIndex = null; + + /** + * Loads, migrates and validates the persistent state. Call once on ready. + * + * @returns {number|null} The schema migrated from, or null. + */ + function initialiseState() { + const { state: clean, migratedFrom } = migrateState(state[STATE_KEY]); + clean.version = SCRIPT_VERSION; + state[STATE_KEY] = clean; + pathIndex = null; + return migratedFrom; + } + + /** + * Returns the persistent state, creating it when missing. + * + * @returns {object} State branch. + */ + function getState() { + if (!isRecord(state[STATE_KEY]) || state[STATE_KEY].schemaVersion !== SCHEMA_VERSION) { + initialiseState(); + } + return state[STATE_KEY]; + } + + /** + * Returns the global configuration. + * + * @returns {object} Config. + */ + function getConfig() { + return getState().config; + } + + /** + * Sets one global configuration value. + * + * @param {string} key Config key. + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setConfigValue(key, raw) { + if (!(key in DEFAULT_CONFIG)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getState().config[key] = result.value; + } + return result; + } + + /** + * Imports Roll20 One-Click useroptions into the persisted config. + * + * @returns {void} + */ + function applyGlobalConfig() { + if (typeof globalconfig === 'undefined' || !isRecord(globalconfig)) { + return; + } + const branch = globalconfig[STATE_KEY.toLowerCase()] || globalconfig[STATE_KEY]; + if (!isRecord(branch)) { + return; + } + const options = isRecord(branch.useroptions) ? branch.useroptions : branch; + const s = getState(); + // useroptions only change when the GM edits them, so remember what was last + // applied and only re-apply on change; otherwise chat changes would be + // overwritten on every restart. + const applied = isRecord(s.notices.useroptions) ? s.notices.useroptions : {}; + for (const key of ['hexLayer', 'revealBy', 'language']) { + if (key in options && options[key] !== applied[key]) { + setConfigValue(key, options[key]); + applied[key] = options[key]; + } + } + s.notices.useroptions = applied; + } + + /** + * Returns a page's stored data. + * + * @param {string} pageId Page ID. + * @param {boolean} [create=false] Create the record when missing. + * @returns {object|null} Page data. + */ + function getPageData(pageId, create = false) { + const s = getState(); + if (!s.pages[pageId] && create) { + s.pages[pageId] = { hexes: {}, settings: {}, calibration: null }; + } + return s.pages[pageId] || null; + } + + /** + * Returns the IDs of every page with stored data. + * + * @returns {string[]} Page IDs. + */ + function getPageIds() { + return Object.keys(getState().pages); + } + + /** + * Removes a page's stored data entirely. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function deletePageData(pageId) { + const s = getState(); + const page = s.pages[pageId]; + if (page && pathIndex) { + for (const hex of Object.values(page.hexes)) { + pathIndex.delete(hex.id); + } + } + delete s.pages[pageId]; + } + + /** + * Returns the settings in force on a page: global config plus page overrides. + * + * @param {string} pageId Page ID. + * @returns {object} Effective settings. + */ + function getPageSettings(pageId) { + const page = getPageData(pageId); + return { ...getConfig(), ...(page ? page.settings : {}) }; + } + + /** + * Sets a per-page override. + * + * @param {string} pageId Page ID. + * @param {string} key Setting key (must be in PAGE_SETTING_KEYS). + * @param {*} raw Raw value. + * @returns {{valid: boolean, value?: *}} Validation result. + */ + function setPageSetting(pageId, key, raw) { + if (!PAGE_SETTING_KEYS.includes(key)) { + return { valid: false }; + } + const result = validateConfigValue(key, raw); + if (result.valid) { + getPageData(pageId, true).settings[key] = result.value; + } + return result; + } + + /** + * Clears all per-page overrides. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function clearPageSettings(pageId) { + const page = getPageData(pageId); + if (page) { + page.settings = {}; + } + } + + /** + * Stores or clears a page's grid calibration. + * + * @param {string} pageId Page ID. + * @param {object|null} calibration Calibration, or null to clear. + * @returns {void} + */ + function setCalibration(pageId, calibration) { + getPageData(pageId, true).calibration = calibration ? { ...calibration } : null; + } + + // --------------------------------------------------------------------------- + // Hex records + // --------------------------------------------------------------------------- + + /** + * Builds the in-memory path ID index on first use. + * + * @returns {Map} Map of path ID to [pageId, key]. + */ + function getIndex() { + if (!pathIndex) { + pathIndex = new Map(); + for (const [pageId, page] of Object.entries(getState().pages)) { + for (const [key, hex] of Object.entries(page.hexes)) { + pathIndex.set(hex.id, [pageId, key]); + } + } + } + return pathIndex; + } + + /** + * Returns a hex record. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} Hex record. + */ + function getHex(pageId, key) { + return getPageData(pageId)?.hexes[key] || null; + } + + /** + * Returns every hex record on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Hex records. + */ + function getPageHexes(pageId) { + const page = getPageData(pageId); + return page ? Object.values(page.hexes) : []; + } + + /** + * Returns the hex record drawn by a path, with its page. + * + * @param {string} pathId Path object ID. + * @returns {{pageId: string, key: string, hex: object}|null} Lookup result. + */ + function getHexByPathId(pathId) { + const entry = getIndex().get(pathId); + if (!entry) { + return null; + } + const [pageId, key] = entry; + const hex = getHex(pageId, key); + return hex ? { pageId, key, hex } : null; + } + + /** + * Stores a hex record, replacing any record at the same cell. + * + * @param {string} pageId Page ID. + * @param {object} hex Hex record with row and col. + * @returns {object} The stored record. + */ + function putHex(pageId, hex) { + const key = `${hex.row},${hex.col}`; + const page = getPageData(pageId, true); + const old = page.hexes[key]; + if (old && old.id !== hex.id) { + getIndex().delete(old.id); + } + page.hexes[key] = hex; + getIndex().set(hex.id, [pageId, key]); + return hex; + } + + /** + * Removes a hex record (not its Roll20 objects). + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @returns {object|null} The removed record. + */ + function deleteHexRecord(pageId, key) { + const page = getPageData(pageId); + const hex = page?.hexes[key]; + if (!hex) { + return null; + } + delete page.hexes[key]; + getIndex().delete(hex.id); + return hex; + } + + // --------------------------------------------------------------------------- + // Pending locations and undo + // --------------------------------------------------------------------------- + + /** + * Returns pending location token IDs on a page (tokens marked as locations + * before the area under them was filled). + * + * @param {string} pageId Page ID. + * @returns {string[]} Token IDs. + */ + function getPendingLocations(pageId) { + return Object.entries(getState().pendingLocations) + .filter(([, page]) => page === pageId) + .map(([tokenId]) => tokenId); + } + + /** + * Adds or removes a pending location. + * + * @param {string} tokenId Token ID. + * @param {string|null} pageId Page ID, or null to remove. + * @returns {void} + */ + function setPendingLocation(tokenId, pageId) { + const pending = getState().pendingLocations; + if (pageId) { + pending[tokenId] = pageId; + } else { + delete pending[tokenId]; + } + } + + /** + * Returns the record of the last fill, used by undo. + * + * @returns {object|null} Last fill record. + */ + function getLastFill() { + return getState().lastFill; + } + + /** + * Stores or clears the record of the last fill. + * + * @param {object|null} record Fill record. + * @returns {void} + */ + function setLastFill(record) { + getState().lastFill = record; + } + + /** + * Returns the saved player-visible properties of tokens hidden under hexes. + * + * @returns {object} Map of token ID to { pageId, saved }. + */ + function getCoveredTokens() { + return getState().coveredTokens; + } + + /** + * Builds the hex grid for a page, including any calibration. + * + * @param {object} page Roll20 page. + * @returns {object|null} Grid object, or null when the page has no hex grid. + */ + function buildPageGrid(page) { + const pageId = page.get('_id'); + return createGrid({ + gridType: page.get('grid_type'), + // snapping_increment is 0 when snapping is off; the grid is still drawn at 1 unit. + scale: Number(page.get('snapping_increment')) || 1, + jumpgate: isJumpgate(), + // Set by Jumpgate's map alignment tool. + offsetX: Number(page.get('grid_offset_x')) || 0, + offsetY: Number(page.get('grid_offset_y')) || 0, + calibration: getPageData(pageId)?.calibration || null, + }); + } + + /** + * Returns everything needed to work on a page's hexes. + * + * @param {string} pageId Page ID. + * @returns {{ok: true, pageId: string, page: object, grid: object}|{ok: false, reason: string}} + * Context, or the reason it is unavailable ('noPage' or 'notHex'). + */ + function getPageContext(pageId) { + const page = pageId ? getObj('page', pageId) : null; + if (!page) { + return { ok: false, reason: 'noPage' }; + } + const grid = buildPageGrid(page); + if (!grid) { + return { ok: false, reason: 'notHex' }; + } + return { ok: true, pageId, page, grid }; + } + + // Hiding tokens' player-visible details while they are under a hex. + // + // Hexes hide the token image, but Roll20 draws nameplates, bars and auras + // above the foreground layer, so a monster under a hex would still give its + // position away. While a token's centre is under a covered (not glimpsed) hex, + // its player-visible flags are switched off; the saved values are restored + // when it is uncovered, moved out, or the setting is turned off. + + /** + * Returns true when a token's centre is under a covered hex. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @returns {boolean} True when covered. + */ + function isCovered(ctx, token) { + if (token.get('layer') !== LAYER_TOKEN || token.get('_subtype') !== 'token') { + return false; + } + const [row, col] = pixelToHex(ctx.grid, Number(token.get('left')), Number(token.get('top'))); + const hex = getHex(ctx.pageId, hexKey(row, col)); + return !!hex && !hex.glimpsed; + } + + /** + * Switches a token's player-visible details off, saving their values. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function hideDetails(token) { + const covered = getCoveredTokens(); + const id = token.get('_id'); + if (covered[id]) { + return; + } + const saved = {}; + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + saved[prop] = token.get(prop) === true; + updates[prop] = false; + } + covered[id] = { pageId: token.get('_pageid'), saved }; + token.set(updates); + } + + /** + * Restores a token's saved player-visible details. + * + * @param {string} tokenId Token ID. + * @returns {void} + */ + function restoreDetails(tokenId) { + const covered = getCoveredTokens(); + const entry = covered[tokenId]; + if (!entry) { + return; + } + delete covered[tokenId]; + const token = getObj('graphic', tokenId); + if (token) { + token.set({ ...entry.saved }); + } + } + + /** + * Keeps a covered token's details hidden when the GM switches one on while it + * is covered: the new value is saved for when the token is uncovered. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleCoveredChange(token, prev) { + const entry = getCoveredTokens()[token.get('_id')]; + if (!entry || !prev) { + return; + } + const updates = {}; + for (const prop of COVERED_TOKEN_PROPS) { + if (token.get(prop) === true && prev[prop] !== true) { + entry.saved[prop] = true; + updates[prop] = false; + } + } + if (Object.keys(updates).length > 0) { + token.set(updates); + } + } + + /** + * Hides or restores one token's details to match whether it is covered. + * + * @param {object} token Roll20 graphic. + * @returns {void} + */ + function refreshToken(token) { + const ctx = getPageContext(token.get('_pageid')); + if (getConfig().hideCoveredTokens && ctx.ok && isCovered(ctx, token)) { + hideDetails(token); + } else { + restoreDetails(token.get('_id')); + } + } + + /** + * Hides or restores the details of every token on a page. + * + * @param {string} pageId Page ID. + * @returns {void} + */ + function refreshPage(pageId) { + const ctx = getPageContext(pageId); + const enabled = getConfig().hideCoveredTokens && ctx.ok; + const covered = getCoveredTokens(); + for (const token of findObjs({ _type: 'graphic', _pageid: pageId, _subtype: 'token' })) { + if (enabled && isCovered(ctx, token)) { + hideDetails(token); + } else if (covered[token.get('_id')]) { + restoreDetails(token.get('_id')); + } + } + // Forget tokens that were deleted while hidden. + for (const [tokenId, entry] of Object.entries(covered)) { + if (entry.pageId === pageId && !getObj('graphic', tokenId)) { + delete covered[tokenId]; + } + } + } + + /** + * Restores every hidden token in the game (used when the setting is turned off). + * + * @returns {void} + */ + function restoreAll() { + for (const tokenId of Object.keys(getCoveredTokens())) { + restoreDetails(tokenId); + } + } + + // Named hexes and hidden location tokens. + // + // A hex can carry a name (shown to the GM as a label on the GM layer) and an + // icon (a token hidden on the GM layer). Both are announced when the hex is + // revealed, and the icon is moved back to the token layer. + + /** + * Returns the token attached to a hex as its icon, if it still exists. + * + * @param {object} hex Hex record. + * @returns {object|null} Roll20 graphic. + */ + function getHexIcon(hex) { + return hex.iconId ? getObj('graphic', hex.iconId) || null : null; + } + + /** + * Returns the name announced when a hex is discovered: the icon's name, or + * the hex's own name. + * + * @param {object} hex Hex record. + * @returns {string} Discovery name (empty when the hex is unnamed). + */ + function getDiscoveryName(hex) { + const icon = getHexIcon(hex); + return toText(icon?.get('name')) || toText(hex.name); + } + + /** + * Removes a hex's GM-layer name label. + * + * @param {object} hex Hex record. + * @returns {void} + */ + function removeLabel(hex) { + if (hex.nameId) { + getObj('text', hex.nameId)?.remove(); + delete hex.nameId; + } + } + + /** + * Gives a name label a font Jumpgate can draw. A text created through the API + * without one gets the font "unset", and Jumpgate stops drawing the whole + * tabletop ("Something Went Wrong") when it meets it. Labels made by 2.0.0 and + * 2.0.1 have that font. + * + * @param {object} text Roll20 text object. + * @returns {boolean} Whether the font was changed. + */ + function repairLabelFont(text) { + const font = toText(text.get('font_family')); + if (font && font !== 'unset') { + return false; + } + text.set('font_family', LABEL_FONT_FAMILY); + return true; + } + + /** + * Repairs the font of every name label Hexploration knows about. + * + * @param {string[]} pageIds Pages with hexes. + * @returns {number} Number of labels repaired. + */ + function repairLabelFonts(pageIds) { + let count = 0; + for (const pageId of pageIds) { + for (const hex of getPageHexes(pageId)) { + const text = hex.nameId ? getObj('text', hex.nameId) : null; + if (text && repairLabelFont(text)) { + count++; + } + } + } + return count; + } + + /** + * Sets or clears a hex's name and redraws its GM-layer label. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record. + * @param {string} name New name (empty to clear). + * @returns {void} + */ + function setHexName(ctx, hex, name) { + removeLabel(hex); + const clean = toText(name).slice(0, MAX_NAME_LENGTH); + if (!clean) { + delete hex.name; + return; + } + hex.name = clean; + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + const label = createObj('text', { + _pageid: ctx.pageId, + layer: LAYER_GM, + left: x, + top: y, + text: clean, + color: getConfig().labelColor, + font_family: LABEL_FONT_FAMILY, + font_size: LABEL_FONT_SIZE, + }); + if (label) { + hex.nameId = label.get('_id'); + } + } + + /** + * Attaches a token to a hex as its hidden icon. + * + * @param {object} hex Hex record. + * @param {object} token Roll20 graphic. + * @returns {string} The token's layer before it was hidden (for undo). + */ + function attachIcon(hex, token) { + const previousLayer = token.get('layer'); + hex.iconId = token.get('_id'); + token.set('layer', LAYER_GM); + setPendingLocation(hex.iconId, null); + return previousLayer; + } + + /** + * Detaches a hex's icon and returns it to the token layer. + * + * @param {object} hex Hex record. + * @param {boolean} [show=true] Move the icon back to the token layer. + * @returns {void} + */ + function detachIcon(hex, show = true) { + const icon = getHexIcon(hex); + if (icon && show) { + icon.set('layer', LAYER_TOKEN); + } + delete hex.iconId; + } + + /** + * Returns the hex records on a page keyed by the ID of their icon. + * + * @param {string} pageId Page ID. + * @returns {Map} Map of icon ID to hex record. + */ + function hexesByIcon(pageId) { + const map = new Map(); + for (const hex of getPageHexes(pageId)) { + if (hex.iconId) { + map.set(hex.iconId, hex); + } + } + return map; + } + + /** + * Returns location tokens waiting for a hex on a page, keyed by hex cell: + * tokens marked with `mark`, plus (as in v1) tokens with the white-tower + * status marker. Tokens already attached to a hex are ignored. + * + * @param {object} ctx Page context. + * @returns {Map} Map of "row,col" to Roll20 graphic. + */ + function findLocationTokens(ctx) { + const attached = hexesByIcon(ctx.pageId); + const tokens = new Map(); + const consider = (token) => { + if (!token || attached.has(token.get('_id'))) { + return; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + tokens.set(hexKey(row, col), token); + }; + + for (const tokenId of getPendingLocations(ctx.pageId)) { + const token = getObj('graphic', tokenId); + if (token) { + consider(token); + } else { + setPendingLocation(tokenId, null); + } + } + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId })) { + if (tokenHasMarker(token, LOCATION_MARKER)) { + consider(token); + } + } + return tokens; + } + + /** + * Marks tokens as hidden locations. A token already under a hex is attached + * immediately; otherwise it waits for the next fill that covers it. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {{attached: number, pending: number}} Counts. + */ + function markLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + let attachedCount = 0; + let pendingCount = 0; + for (const token of tokens) { + if (attached.has(token.get('_id'))) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + attachIcon(hex, token); + attachedCount++; + } else { + setPendingLocation(token.get('_id'), ctx.pageId); + pendingCount++; + } + } + return { attached: attachedCount, pending: pendingCount }; + } + + /** + * Stops tokens being hidden locations. Attached tokens return to the token layer. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number} Number of tokens unmarked. + */ + function unmarkLocations(ctx, tokens) { + const attached = hexesByIcon(ctx.pageId); + const pending = new Set(getPendingLocations(ctx.pageId)); + let count = 0; + for (const token of tokens) { + const id = token.get('_id'); + const hex = attached.get(id); + if (hex) { + detachIcon(hex); + count++; + } else if (pending.has(id)) { + setPendingLocation(id, null); + count++; + } + } + return count; + } + + // Polygon maths for Roll20 drawn shapes. Pure functions only: callers pass + // plain property objects, so the module can be unit tested in Node. + // + // Both kinds of Roll20 path store points relative to their own bounding box + // and are placed by their centre: + // - Legacy `path`: `_path` is a JSON list of SVG-like commands (M, L, Q, C), + // placed by left/top, sized by width/height, scaled by scaleX/scaleY. + // - Jumpgate `pathv2`: `points` is a JSON list of [x, y] pairs interpreted by + // `shape` (pol, free, rec, eli) and placed by x/y. It has no scale. + // Both can be rotated by `rotation` degrees about their centre. + + const UNIT_PX = 70; + const ELLIPSE_SEGMENTS = 32; + const CURVE_SEGMENTS = 8; + + /** + * Returns the bounding box of a list of points. + * + * @param {number[][]} points Array of [x, y]. + * @returns {{left: number, top: number, right: number, bottom: number}} Bounding box. + */ + function boundingBox(points) { + let left = Infinity; + let top = Infinity; + let right = -Infinity; + let bottom = -Infinity; + for (const [x, y] of points) { + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x); + bottom = Math.max(bottom, y); + } + return { left, top, right, bottom }; + } + + /** + * Tests whether a point lies inside a polygon ring (even-odd rule). The ring + * is treated as closed whether or not its last point repeats the first. + * + * @param {number[]} point [x, y]. + * @param {number[][]} ring Array of [x, y]. + * @returns {boolean} True when inside. + */ + function pointInRing(point, ring) { + const [x, y] = point; + let inside = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const [xi, yi] = ring[i]; + const [xj, yj] = ring[j]; + const crosses = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi; + if (crosses) { + inside = !inside; + } + } + return inside; + } + + /** + * Tests whether a point lies inside any of a shape's rings (even-odd across + * rings, so a ring drawn inside another makes a hole). + * + * @param {number[]} point [x, y]. + * @param {number[][][]} rings Array of rings. + * @returns {boolean} True when inside. + */ + function pointInShape(point, rings) { + let inside = false; + for (const ring of rings) { + if (ring.length >= 3 && pointInRing(point, ring)) { + inside = !inside; + } + } + return inside; + } + + /** + * Builds a transform from path-local coordinates to page pixels. + * + * @param {object} t Transform values. + * @returns {(x: number, y: number) => number[]} Point transform. + */ + function makeTransform({ width, height, cx, cy, scaleX = 1, scaleY = 1, rotation = 0 }) { + const angle = ((Number(rotation) || 0) * Math.PI) / 180; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + return (x, y) => { + const lx = (x - width / 2) * scaleX; + const ly = (y - height / 2) * scaleY; + return [cx + lx * cos - ly * sin, cy + lx * sin + ly * cos]; + }; + } + + /** + * Samples a quadratic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 Control point. + * @param {number[]} p2 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleQuadratic(p0, p1, p2) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + points.push([ + u * u * p0[0] + 2 * u * t * p1[0] + t * t * p2[0], + u * u * p0[1] + 2 * u * t * p1[1] + t * t * p2[1], + ]); + } + return points; + } + + /** + * Samples a cubic Bezier curve. + * + * @param {number[]} p0 Start point. + * @param {number[]} p1 First control point. + * @param {number[]} p2 Second control point. + * @param {number[]} p3 End point. + * @returns {number[][]} Points after the start point. + */ + function sampleCubic(p0, p1, p2, p3) { + const points = []; + for (let i = 1; i <= CURVE_SEGMENTS; i++) { + const t = i / CURVE_SEGMENTS; + const u = 1 - t; + const a = u * u * u; + const b = 3 * u * u * t; + const c = 3 * u * t * t; + const d = t * t * t; + points.push([ + a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], + a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1], + ]); + } + return points; + } + + /** + * Converts a Legacy path's command list into rings in path-local coordinates. + * + * @param {Array[]} commands Parsed `_path` commands. + * @returns {number[][][]} Rings. + */ + function legacyCommandsToRings(commands) { + const rings = []; + let ring = []; + let prevType = null; + for (const cmd of commands) { + if (!Array.isArray(cmd)) { + continue; + } + const [type, ...args] = cmd; + const nums = args.map(Number); + const prev = ring.at(-1); + if (type === 'M' && prevType !== 'M') { + if (ring.length > 0) { + rings.push(ring); + } + ring = [[nums[0], nums[1]]]; + } else if (type === 'L' || type === 'M') { + // Two consecutive Ms are drawn by Roll20 as a line, so treat the second as L. + ring.push([nums[0], nums[1]]); + } else if (type === 'Q' && prev) { + ring.push(...sampleQuadratic(prev, [nums[0], nums[1]], [nums[2], nums[3]])); + } else if (type === 'C' && prev) { + ring.push(...sampleCubic(prev, [nums[0], nums[1]], [nums[2], nums[3]], [nums[4], nums[5]])); + } + prevType = type; + } + if (ring.length > 0) { + rings.push(ring); + } + return rings; + } + + /** + * Returns points approximating an ellipse inside a box. + * + * @param {number} width Box width. + * @param {number} height Box height. + * @returns {number[][]} Points in box-local coordinates. + */ + function ellipsePoints(width, height) { + const points = []; + for (let i = 0; i < ELLIPSE_SEGMENTS; i++) { + const angle = (i / ELLIPSE_SEGMENTS) * Math.PI * 2; + points.push([ + width / 2 + (Math.cos(angle) * width) / 2, + height / 2 + (Math.sin(angle) * height) / 2, + ]); + } + return points; + } + + /** + * Parses a JSON string, returning null on failure. + * + * @param {string} text JSON text. + * @returns {*} Parsed value, or null. + */ + function safeJson(text) { + try { + return JSON.parse(text); + } catch { + return null; + } + } + + /** + * Converts a Legacy path's properties into page-space rings. + * + * @param {object} props Path properties (_path, left, top, width, height, scaleX, scaleY, rotation). + * @param {object} [page] Page size in units ({ width, height }) for mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function legacyPathToRings(props, page = {}) { + const raw = String(props._path || props.path || '') + .replaceAll('mapWidth', String((Number(page.width) || 0) * UNIT_PX)) + .replaceAll('mapHeight', String((Number(page.height) || 0) * UNIT_PX)); + const commands = safeJson(raw); + if (!Array.isArray(commands)) { + return []; + } + const transform = makeTransform({ + width: Number(props.width) || 0, + height: Number(props.height) || 0, + cx: Number(props.left) || 0, + cy: Number(props.top) || 0, + scaleX: Number(props.scaleX) || 1, + scaleY: Number(props.scaleY) || 1, + rotation: props.rotation, + }); + return legacyCommandsToRings(commands).map((ring) => ring.map(([x, y]) => transform(x, y))); + } + + /** + * Converts a Jumpgate pathv2's properties into page-space rings. + * + * @param {object} props Path properties (points, shape, x, y, rotation). + * @returns {number[][][]} Rings in page pixels. + */ + function pathV2ToRings(props) { + const parsed = safeJson(props.points); + if (!Array.isArray(parsed) || parsed.length === 0) { + return []; + } + const raw = parsed + .filter((p) => Array.isArray(p) && p.length >= 2) + .map(([x, y]) => [Number(x), Number(y)]) + .filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)); + if (raw.length === 0) { + return []; + } + + // Points are normalised so the bounding box starts at 0,0. + const box = boundingBox(raw); + const local = raw.map(([x, y]) => [x - box.left, y - box.top]); + const width = box.right - box.left; + const height = box.bottom - box.top; + + let ring; + if (props.shape === 'rec') { + ring = [ + [0, 0], + [width, 0], + [width, height], + [0, height], + ]; + } else if (props.shape === 'eli') { + ring = ellipsePoints(width, height); + } else { + ring = local; + } + + const transform = makeTransform({ + width, + height, + cx: Number(props.x) || 0, + cy: Number(props.y) || 0, + rotation: props.rotation, + }); + return [ring.map(([x, y]) => transform(x, y))]; + } + + /** + * Converts either kind of path into page-space rings. + * + * @param {object} props Path properties including `type` ('path' or 'pathv2'). + * @param {object} [page] Page size in units, for Legacy mapWidth/mapHeight paths. + * @returns {number[][][]} Rings in page pixels. + */ + function pathToRings(props, page) { + if (props.type === 'pathv2') { + return pathV2ToRings(props); + } + return legacyPathToRings(props, page); + } + + /** + * Builds the properties for a closed polygon as either kind of path. + * Points are made relative to their bounding box, and the path is placed by + * its centre, matching how Roll20 stores both path types. + * + * @param {number[][]} points Polygon corners in page pixels. + * @param {boolean} jumpgate True to build a pathv2, false for a Legacy path. + * @returns {object} Geometry properties for createObj. + */ + function polygonPathProps(points, jumpgate) { + const box = boundingBox(points); + const width = box.right - box.left; + const height = box.bottom - box.top; + const cx = box.left + width / 2; + const cy = box.top + height / 2; + const round = (n) => Math.round(n * 1000) / 1000; + const local = points.map(([x, y]) => [round(x - box.left), round(y - box.top)]); + const closed = [...local, local[0]]; + + if (jumpgate) { + return { + shape: 'pol', + points: JSON.stringify(closed), + x: cx, + y: cy, + }; + } + + const commands = closed.map(([x, y], i) => [i === 0 ? 'M' : 'L', x, y]); + return { + _path: JSON.stringify(commands), + left: cx, + top: cy, + width, + height, + }; + } + + /** + * Returns the centroid of a ring's distinct vertices. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[]} [x, y]. + */ + function ringCentre(ring) { + const pts = distinctVertices(ring); + const sum = pts.reduce((acc, [x, y]) => [acc[0] + x, acc[1] + y], [0, 0]); + return [sum[0] / pts.length, sum[1] / pts.length]; + } + + /** + * Returns a ring's vertices with a repeated closing point removed. + * + * @param {number[][]} ring Array of [x, y]. + * @returns {number[][]} Distinct vertices. + */ + function distinctVertices(ring) { + if (ring.length > 1) { + const first = ring[0]; + const last = ring.at(-1); + if (Math.abs(first[0] - last[0]) < 0.01 && Math.abs(first[1] - last[1]) < 0.01) { + return ring.slice(0, -1); + } + } + return ring; + } + + // Roll20 object access for drawn shapes. Jumpgate games draw `pathv2` + // objects; Legacy games draw `path` objects. Everything that reads or writes a + // path goes through this module so the rest of the mod never cares which. + + // Set when the foreground layer turns out to be unavailable, so later hexes + // go straight to the token layer instead of failing one by one. + let foregroundUnavailable = false; + + /** + * Returns a path object of either type by ID. + * + * @param {string} id Object ID. + * @param {string|null} [type] Known type, checked first. + * @returns {object|null} Roll20 path or pathv2 object. + */ + function getPathObject(id, type = null) { + if (!id) { + return null; + } + const types = activePathTypes(); + const order = type && types.includes(type) ? [type, ...types.filter((t) => t !== type)] : types; + for (const t of order) { + const obj = getObj(t, id); + if (obj) { + return obj; + } + } + return null; + } + + /** + * Returns true when a Roll20 object is a path of either type. + * + * @param {object} obj Roll20 object. + * @returns {boolean} True for path and pathv2. + */ + function isPathObject(obj) { + return !!obj && PATH_TYPES.includes(obj.get('_type')); + } + + /** + * Returns a colour in a form the given path type accepts. + * + * @param {string} color Colour from the settings. + * @param {string} type Path type. + * @returns {string} Colour to write. + */ + function pathColor(color, type) { + return type === PATH_TYPE_V2 ? toPathV2Color(color) : color; + } + + /** + * Sets a path's colours, converting them for Jumpgate pathv2 objects. + * + * @param {object} obj Roll20 path or pathv2. + * @param {object} attrs Attributes to set; `fill` and `stroke` are converted. + * @returns {void} + */ + function setPathStyle(obj, attrs) { + const type = obj.get('_type'); + const converted = { ...attrs }; + for (const key of ['fill', 'stroke']) { + if (key in converted) { + converted[key] = pathColor(converted[key], type); + } + } + obj.set(converted); + } + + /** + * Copies the properties the polygon module needs from a path. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {object} Plain properties including `type`. + */ + function readPathProps(obj) { + const type = obj.get('_type'); + const base = { + type, + pageId: obj.get('_pageid'), + layer: obj.get('layer'), + rotation: obj.get('rotation'), + fill: obj.get('fill'), + stroke: obj.get('stroke'), + stroke_width: obj.get('stroke_width'), + }; + if (type === PATH_TYPE_V2) { + return { + ...base, + shape: obj.get('shape'), + points: obj.get('points'), + x: obj.get('x'), + y: obj.get('y'), + }; + } + return { + ...base, + _path: obj.get('_path'), + left: obj.get('left'), + top: obj.get('top'), + width: obj.get('width'), + height: obj.get('height'), + scaleX: obj.get('scaleX'), + scaleY: obj.get('scaleY'), + }; + } + + /** + * Returns a path's outline as page-space rings. + * + * @param {object} obj Roll20 path or pathv2. + * @returns {number[][][]} Rings. + */ + function getPathRings(obj) { + const props = readPathProps(obj); + const page = getObj('page', props.pageId); + return pathToRings(props, page ? { width: page.get('width'), height: page.get('height') } : {}); + } + + /** + * Recreates a path from properties saved by readPathProps (used by undo). + * + * @param {object} props Saved properties. + * @returns {object|null} New Roll20 object. + */ + function recreatePath(props) { + const { type, pageId, ...rest } = props; + const attrs = { _pageid: pageId }; + for (const [key, value] of Object.entries(rest)) { + if (value !== undefined && value !== null) { + attrs[key] = value; + } + } + // A Legacy game cannot create pathv2 objects, and vice versa. + const createType = type === PATH_TYPE_V2 && !isJumpgate() ? PATH_TYPE_LEGACY : type; + return createObj(createType, attrs) || null; + } + + /** + * Returns the layer new hexes should be drawn on. + * + * @returns {string} Roll20 layer. + */ + function getHexLayer() { + const setting = getConfig().hexLayer; + if (setting === 'objects' || foregroundUnavailable) { + return LAYER_TOKEN; + } + return LAYER_FOREGROUND; + } + + /** + * Draws a hex outline as a path. + * + * The foreground layer is tried first (unless the GM chose the token layer); + * if the game rejects it, the hex is drawn on the token layer instead and the + * fallback is remembered for the rest of the session. + * + * @param {string} pageId Page ID. + * @param {number[][]} corners Hex corners in page pixels. + * @param {object} style Style with fill, stroke and strokeWidth. + * @returns {{obj: object, fellBack: boolean}|null} New path, or null when it could not be created. + */ + function createHexPath(pageId, corners, style) { + const jumpgate = isJumpgate(); + const type = jumpgate ? PATH_TYPE_V2 : PATH_TYPE_LEGACY; + const geometry = polygonPathProps(corners, jumpgate); + const attrs = { + ...geometry, + _pageid: pageId, + fill: pathColor(style.fill, type), + stroke: pathColor(style.stroke, type), + stroke_width: style.strokeWidth, + controlledby: '', + }; + + const layer = getHexLayer(); + let obj = createObj(type, { ...attrs, layer }); + if (obj && obj.get('layer') === layer) { + return { obj, fellBack: false }; + } + + if (layer === LAYER_FOREGROUND) { + if (obj) { + obj.remove(); + } + foregroundUnavailable = true; + obj = createObj(type, { ...attrs, layer: LAYER_TOKEN }); + return obj ? { obj, fellBack: true } : null; + } + return obj ? { obj, fellBack: false } : null; + } + + /** + * Removes a Roll20 object if it still exists. + * + * @param {object|null} obj Roll20 object. + * @returns {void} + */ + function safeRemove(obj) { + if (obj) { + try { + obj.remove(); + } catch (err) { + log(`Hexploration: could not remove object: ${err?.message || err}`); + } + } + } + + /** + * Returns every path of either type on a page. + * + * @param {string} pageId Page ID. + * @returns {object[]} Roll20 path objects. + */ + function getPagePaths(pageId) { + return activePathTypes().flatMap((type) => findObjs({ _type: type, _pageid: pageId })); + } + + /** + * Returns the path types that can exist in this game. Jumpgate games can + * hold both (old API-made paths survive); Legacy games only have `path`. + * + * @returns {string[]} Path types. + */ + function activePathTypes() { + return isJumpgate() ? PATH_TYPES : [PATH_TYPE_LEGACY]; + } + + // Creating, removing and maintaining hexes on a page: fill, inverse fill, + // conceal, reset, rescan, calibrate and undo. + + /** + * Returns the hex style from the current config. + * + * @returns {{fill: string, stroke: string, strokeWidth: number, maxDistance: number|null}} Style. + */ + function currentStyle() { + const config = getConfig(); + return { + fill: config.fillColor, + stroke: config.strokeColor, + strokeWidth: config.strokeWidth, + maxDistance: config.maxDistance, + }; + } + + /** + * Draws one hex and stores its record. + * + * @param {object} ctx Page context. + * @param {number} row Hex row. + * @param {number} col Hex column. + * @param {object} style Hex style. + * @param {object} [extra] Extra record fields (name, iconId…). + * @returns {{hex: object, fellBack: boolean}|null} New record, or null on failure. + */ + function drawHex(ctx, row, col, style, extra = {}) { + const created = createHexPath(ctx.pageId, hexCorners(ctx.grid, row, col), style); + if (!created) { + return null; + } + const hex = { id: created.obj.get('_id'), type: created.obj.get('_type'), row, col, ...extra }; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } + putHex(ctx.pageId, hex); + return { hex, fellBack: created.fellBack }; + } + + /** + * Removes a hex: its record, its path and its name label. Its icon is moved + * back to the token layer when `showIcon` is true, otherwise left hidden. + * + * @param {string} pageId Page ID. + * @param {string} key "row,col" key. + * @param {boolean} [showIcon=false] Return the icon to the token layer. + * @returns {object|null} The removed record. + */ + function removeHex(pageId, key, showIcon = false) { + const hex = deleteHexRecord(pageId, key); + if (!hex) { + return null; + } + removeLabel(hex); + if (showIcon) { + detachIcon(hex); + } + safeRemove(getPathObject(hex.id, hex.type)); + return hex; + } + + /** + * Returns the cells whose centres lie inside any of the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects on the page. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function cellsInPaths(ctx, paths) { + const seen = new Set(); + const cells = []; + for (const path of paths) { + const rings = getPathRings(path); + if (rings.length === 0) { + continue; + } + const box = boundingBox(rings.flat()); + for (const [row, col] of hexesInBox(ctx.grid, box)) { + const key = hexKey(row, col); + if (!seen.has(key) && pointInShape(hexToPixel(ctx.grid, row, col), rings)) { + seen.add(key); + cells.push([row, col]); + } + } + } + return cells; + } + + /** + * Returns every cell on the page except those inside the given paths. + * + * @param {object} ctx Page context. + * @param {object[]} paths Roll20 path objects to leave uncovered. + * @returns {number[][]} Array of [row, col]. + */ + function cellsOutsidePaths(ctx, paths) { + const omit = new Set(cellsInPaths(ctx, paths).map(([r, c]) => hexKey(r, c))); + const width = Number(ctx.page.get('width')) * 70; + const height = Number(ctx.page.get('height')) * 70; + return hexesCoveringPage(ctx.grid, width, height).filter(([r, c]) => !omit.has(hexKey(r, c))); + } + + /** + * Covers cells with hexes. Existing hexes are restyled rather than replaced, + * so their names and icons are kept. Location tokens in a covered cell are + * attached as icons. Work is batched; `onDone` receives a summary. + * + * @param {object} ctx Page context. + * @param {number[][]} cells Cells to cover. + * @param {object} options Fill options. + * @param {object[]} [options.sources] Saved properties of the polygons used (for undo). + * @param {string} options.kind Fill kind for undo ('fill', 'fillInverse', 'conceal'). + * @param {(summary: object) => void} options.onDone Completion callback. + * @returns {{started: boolean, reason?: string}} Whether the fill started. + */ + function fillCells(ctx, cells, { sources = [], kind, onDone }) { + if (cells.length > MAX_FILL_HEXES) { + return { started: false, reason: 'tooMany' }; + } + + const style = currentStyle(); + const locations = findLocationTokens(ctx); + const record = { + pageId: ctx.pageId, + kind, + time: Date.now(), + created: [], + restyled: [], + icons: [], + sources, + }; + const summary = { created: 0, restyled: 0, icons: 0, failed: 0, fellBack: false }; + + runInBatches( + cells, + BATCH_SIZE, + ([row, col]) => { + const key = hexKey(row, col); + let hex = getHex(ctx.pageId, key); + const existingPath = hex ? getPathObject(hex.id, hex.type) : null; + + if (hex && existingPath) { + record.restyled.push({ + key, + fill: existingPath.get('fill'), + stroke: existingPath.get('stroke'), + strokeWidth: existingPath.get('stroke_width'), + maxDistance: hex.maxDistance ?? null, + glimpsed: hex.glimpsed === true, + }); + setPathStyle(existingPath, { + fill: style.fill, + stroke: style.stroke, + stroke_width: style.strokeWidth, + }); + delete hex.glimpsed; + if (Number.isInteger(style.maxDistance)) { + hex.maxDistance = style.maxDistance; + } else { + delete hex.maxDistance; + } + summary.restyled++; + } else { + if (hex) { + // The record outlived its path (deleted while the API was off). + deleteHexRecord(ctx.pageId, key); + } + const drawn = drawHex(ctx, row, col, style); + if (!drawn) { + summary.failed++; + return; + } + hex = drawn.hex; + summary.fellBack = summary.fellBack || drawn.fellBack; + record.created.push({ key, id: hex.id }); + summary.created++; + } + + const token = locations.get(key); + if (token && !hex.iconId) { + // Remember a Mark Location token so undo can mark it again + const id = token.get('_id'); + const pending = getPendingLocations(ctx.pageId).includes(id); + record.icons.push({ id, layer: token.get('layer'), pending }); + attachIcon(hex, token); + summary.icons++; + } + }, + (errors) => { + summary.failed += errors; + setLastFill(record); + onDone(summary); + } + ); + + return { started: true }; + } + + /** + * Removes every hex on a page, returning icons to the token layer. Page + * settings and calibration are kept. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function clearPage(ctx, onDone) { + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + for (const tokenId of getPendingLocations(ctx.pageId)) { + setPendingLocation(tokenId, null); + } + const last = getLastFill(); + if (last?.pageId === ctx.pageId) { + setLastFill(null); + } + runInBatches( + keys, + BATCH_SIZE, + (key) => removeHex(ctx.pageId, key, true), + () => onDone(keys.length) + ); + } + + /** + * Reverses the last fill: removes the hexes it created, restores the style + * of hexes it restyled, returns icons it hid, and redraws the polygons it used. + * + * @returns {{ok: boolean, reason?: string, removed?: number, restored?: number, pageId?: string}} Result. + */ + function undoLastFill() { + const record = getLastFill(); + if (!record) { + return { ok: false, reason: 'nothingToUndo' }; + } + setLastFill(null); + const page = getObj('page', record.pageId); + if (!page) { + return { ok: false, reason: 'noPage' }; + } + + let removed = 0; + for (const { key, id } of record.created || []) { + const hex = getHex(record.pageId, key); + if (hex && hex.id === id) { + removeHex(record.pageId, key, false); + removed++; + } + } + + let restored = 0; + for (const prev of record.restyled || []) { + const hex = getHex(record.pageId, prev.key); + const path = hex ? getPathObject(hex.id, hex.type) : null; + if (path) { + setPathStyle(path, { + fill: prev.fill, + stroke: prev.stroke, + stroke_width: prev.strokeWidth, + }); + if (Number.isInteger(prev.maxDistance)) { + hex.maxDistance = prev.maxDistance; + } else { + delete hex.maxDistance; + } + if (prev.glimpsed) { + hex.glimpsed = true; + } + restored++; + } + } + + for (const { id, layer, pending } of record.icons || []) { + const token = getObj('graphic', id); + if (token) { + for (const hex of getPageHexes(record.pageId)) { + if (hex.iconId === id) { + delete hex.iconId; + } + } + token.set('layer', layer || LAYER_TOKEN); + // Hiding it used up its Mark Location; mark it again so the next fill hides it + if (pending) { + setPendingLocation(id, record.pageId); + } + } + } + + for (const props of record.sources || []) { + recreatePath(props); + } + + return { ok: true, removed, restored, pageId: record.pageId }; + } + + /** + * Captures the polygons used for a fill so undo can redraw them, then deletes them. + * + * @param {object[]} paths Roll20 path objects. + * @returns {object[]} Saved properties. + */ + function consumeSourcePaths(paths) { + // A selected path may itself be a hex; only plain drawings are consumed. + const drawings = paths.filter((path) => !getHexByPathId(path.get('_id'))); + const sources = drawings.map(readPathProps); + for (const path of drawings) { + safeRemove(path); + } + return sources; + } + + /** + * Returns the hex a path draws, judged by its shape: a six-cornered polygon + * centred on a hex cell and roughly the size of a hex. + * + * @param {object} ctx Page context. + * @param {object} path Roll20 path object. + * @returns {number[]|null} [row, col], or null when the path is not a hex. + */ + function matchHexShape(ctx, path) { + const rings = getPathRings(path); + if (rings.length !== 1) { + return null; + } + const vertices = distinctVertices(rings[0]); + if (vertices.length !== 6) { + return null; + } + const [x, y] = ringCentre(vertices); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + if (Math.hypot(x - cx, y - cy) > ctx.grid.colStep * RESCAN_CENTRE_TOLERANCE) { + return null; + } + const actual = boundingBox(vertices); + const expected = boundingBox(hexCorners(ctx.grid, row, col)); + const ratioW = (actual.right - actual.left) / (expected.right - expected.left); + const ratioH = (actual.bottom - actual.top) / (expected.bottom - expected.top); + if (ratioW < 0.75 || ratioW > 1.25 || ratioH < 0.75 || ratioH > 1.25) { + return null; + } + return [row, col]; + } + + /** + * Rebuilds a page's hex list from what is actually on the page: + * - drops records whose path is gone, and label/icon links that are broken; + * - re-files hexes whose cell changed (after calibration); + * - adopts hex-shaped paths the mod does not know about (duplicated pages, + * Legacy games copied to Jumpgate); + * - re-links GM-layer labels and white-tower icons sitting on hexes. + * + * @param {object} ctx Page context. + * @returns {{kept: number, dropped: number, moved: number, adopted: number, labels: number, icons: number}} Counts. + */ + function rescanPage(ctx) { + const counts = { kept: 0, dropped: 0, moved: 0, adopted: 0, labels: 0, icons: 0 }; + const pageData = getPageData(ctx.pageId, true); + + // 1. Check existing records. + for (const hex of Object.values(pageData.hexes)) { + const key = hexKey(hex.row, hex.col); + const path = getPathObject(hex.id, hex.type); + if (!path) { + removeLabel(hex); + deleteHexRecord(ctx.pageId, key); + counts.dropped++; + continue; + } + hex.type = path.get('_type'); + if (hex.nameId && !getObj('text', hex.nameId)) { + delete hex.nameId; + } + if (hex.iconId && !getHexIcon(hex)) { + delete hex.iconId; + } + const cell = matchHexShape(ctx, path); + if ( + cell && + hexKey(cell[0], cell[1]) !== key && + !getHex(ctx.pageId, hexKey(cell[0], cell[1])) + ) { + deleteHexRecord(ctx.pageId, key); + putHex(ctx.pageId, { ...hex, row: cell[0], col: cell[1] }); + counts.moved++; + } else { + counts.kept++; + } + } + + // 2. Adopt unknown hex-shaped paths. + for (const path of getPagePaths(ctx.pageId)) { + const id = path.get('_id'); + if (getHexByPathId(id)) { + continue; + } + const cell = matchHexShape(ctx, path); + if (!cell || getHex(ctx.pageId, hexKey(cell[0], cell[1]))) { + continue; + } + putHex(ctx.pageId, { id, type: path.get('_type'), row: cell[0], col: cell[1] }); + counts.adopted++; + } + + // 3. Re-link GM-layer labels sitting on hex centres. + const linkedLabels = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.nameId) + .filter(Boolean) + ); + for (const text of findObjs({ _type: 'text', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedLabels.has(text.get('_id'))) { + continue; + } + const x = Number(text.get('left')); + const y = Number(text.get('top')); + const [row, col] = pixelToHex(ctx.grid, x, y); + const [cx, cy] = hexToPixel(ctx.grid, row, col); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + repairLabelFont(text); + hex.nameId = text.get('_id'); + hex.name = String(text.get('text') || '').trim() || hex.name; + counts.labels++; + } + } + + // 4. Re-link hidden white-tower icons. + const linkedIcons = new Set( + getPageHexes(ctx.pageId) + .map((hex) => hex.iconId) + .filter(Boolean) + ); + for (const token of findObjs({ _type: 'graphic', _pageid: ctx.pageId, layer: LAYER_GM })) { + if (linkedIcons.has(token.get('_id')) || !tokenHasMarker(token, LOCATION_MARKER)) { + continue; + } + const [row, col] = pixelToHex(ctx.grid, token.get('left'), token.get('top')); + const hex = getHex(ctx.pageId, hexKey(row, col)); + if (hex && !hex.iconId) { + hex.iconId = token.get('_id'); + counts.icons++; + } + } + + return counts; + } + + /** + * Calibrates a page's grid from tokens snapped to hex centres, then rescans + * so existing hexes are filed under their corrected cells. + * + * @param {object} ctx Page context. + * @param {object[]} tokens One or two Roll20 graphics. + * @returns {{ok: boolean, calibration?: object, counts?: object}} Result. + */ + function calibratePage(ctx, tokens) { + const points = tokens.slice(0, 2).map((t) => [Number(t.get('left')), Number(t.get('top'))]); + // Calibrate against the uncalibrated profile so repeated calibration does not drift. + setCalibration(ctx.pageId, null); + const base = buildPageGrid(ctx.page); + const calibration = calibrateGrid(base, points); + if (!calibration) { + return { ok: false }; + } + setCalibration(ctx.pageId, calibration); + const fresh = { ...ctx, grid: buildPageGrid(ctx.page) }; + return { ok: true, calibration, counts: rescanPage(fresh) }; + } + + /** + * Clears a page's calibration and rescans. + * + * @param {object} ctx Page context. + * @returns {object} Rescan counts. + */ + function resetCalibration(ctx) { + setCalibration(ctx.pageId, null); + return rescanPage({ ...ctx, grid: buildPageGrid(ctx.page) }); + } + + /** + * Removes stored hexes whose paths no longer exist, on every page. Run on + * startup, since paths deleted while the API was off fire no events. + * + * @returns {{dropped: number, pages: number}} Counts. + */ + function pruneMissingHexes() { + let dropped = 0; + let pages = 0; + for (const pageId of getPageIds()) { + if (!getObj('page', pageId)) { + dropped += getPageHexes(pageId).length; + deletePageData(pageId); + pages++; + continue; + } + for (const hex of getPageHexes(pageId)) { + if (!getPathObject(hex.id, hex.type)) { + deleteHexRecord(pageId, hexKey(hex.row, hex.col)); + dropped++; + } + } + } + return { dropped, pages }; + } + + // Journal handouts: the Help handout and the Command Deck. + + const STYLE = { + outer: `background:${COLOR_CARD_BG_BOTTOM};color:${COLOR_TEXT};padding:14px 18px;border:1px solid ${COLOR_BORDER};border-radius:6px;font-family:Arial,sans-serif;line-height:1.5;`, + header: `background:${COLOR_HEADER_BG};padding:12px;border-radius:4px;text-align:center;border-bottom:3px solid ${COLOR_ACCENT};margin-bottom:12px;`, + h1: `color:${COLOR_HEADER_TEXT};margin:0;font-size:1.8em;letter-spacing:0.05em;`, + subtitle: `color:${COLOR_MUTED};margin:4px 0 0 0;font-size:0.9em;`, + h2: `color:${COLOR_ACCENT};border-bottom:1px solid ${COLOR_BORDER};padding-bottom:3px;margin:18px 0 8px 0;font-size:1.25em;`, + p: `color:${COLOR_TEXT};margin:6px 0;`, + li: `color:${COLOR_TEXT};margin:3px 0;`, + table: 'width:100%;border-collapse:collapse;margin:6px 0;font-size:0.92em;', + th: `background:${COLOR_HEADER_BG};color:${COLOR_HEADER_TEXT};padding:5px 8px;text-align:left;border:1px solid ${COLOR_BORDER};`, + td: `padding:5px 8px;border:1px solid ${COLOR_BORDER};vertical-align:top;color:${COLOR_TEXT};`, + code: 'font-family:monospace;color:#f3d48b;white-space:nowrap;', + link: `color:${COLOR_ACCENT};`, + footer: `color:${COLOR_MUTED};font-size:0.85em;text-align:center;margin-top:16px;border-top:1px solid ${COLOR_BORDER};padding-top:8px;`, + btn: `background:${COLOR_BUTTON_BG};color:${COLOR_BUTTON_TEXT};padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;font-weight:bold;`, + btnDark: `background:#2c4034;color:${COLOR_TEXT};border:1px solid #4d6b56;padding:3px 9px;border-radius:3px;text-decoration:none;font-size:0.9em;display:inline-block;margin:2px 3px;`, + section: `background:${COLOR_HEADER_BG};color:${COLOR_ACCENT};padding:4px 8px;font-variant:small-caps;font-weight:bold;letter-spacing:0.05em;border-left:3px solid ${COLOR_ACCENT};margin:12px 0 4px 0;`, + desc: `color:${COLOR_MUTED};font-size:0.85em;margin:0 0 4px 8px;`, + }; + + /** + * Builds a table. + * + * @param {string[]} headings Column headings (escaped). + * @param {string[][]} rows Row cells (trusted HTML). + * @returns {string} HTML string. + */ + function table(headings, rows) { + const head = headings.map((h) => `${escapeHtml(h)}`).join(''); + const body = rows + .map((cells) => `${cells.map((c) => `${c}`).join('')}`) + .join(''); + return `${head}${body}
    `; + } + + /** + * Builds a paragraph list from a translated array. + * + * @param {*} items Translated value (array of strings expected). + * @param {boolean} [ordered=false] Use a numbered list. + * @returns {string} HTML string. + */ + function list(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const lis = (Array.isArray(items) ? items : []) + .map((item) => `
  • ${escapeHtml(item)}
    • `) + .join(''); + return `<${tag}>${lis}`; + } + + /** + * Builds a link. + * + * @param {string} url URL. + * @param {string} label Link text. + * @returns {string} HTML anchor. + */ + function link(url, label) { + return `${escapeHtml(label)}`; + } + + /** + * Builds the Help handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildHelpHtml(locale) { + const lang = getLocale(locale); + const h = (key, vars) => escapeHtml(t(`handout.${key}`, lang, vars)); + const raw = (key) => tRaw(`handout.${key}`, lang); + const code = (text) => `${escapeHtml(text)}`; + const section = (key, body) => `

    ${h(`${key}.heading`)}

    ${body}`; + + const commands = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ].map(([cmd, key]) => [code(`${COMMAND} ${cmd}`.trim()), escapeHtml(t(`help.${key}`, lang))]); + + const settings = Object.keys(DEFAULT_CONFIG).map((key) => [ + code(key), + escapeHtml(t(`settings.${key}.label`, lang)), + escapeHtml(t(`settings.${key}.desc`, lang)) + + (PAGE_SETTING_KEYS.includes(key) ? ` ${h('settings.perPage')}` : ''), + ]); + + const legacyCommands = [ + ['!hexploration_showMenuMain', `${COMMAND}`], + ['!hexploration_fillPoly', `${COMMAND} fill`], + ['!hexploration_fillInversePoly', `${COMMAND} fill inverse`], + ['!hexploration_hexModifyProperty name&&…', `${COMMAND} name …`], + ['!hexploration_configModifyProperty …', `${COMMAND} set …`], + ].map(([v1, v2]) => [code(v1), code(v2)]); + + const locales = LOCALE_DEFINITIONS.map((locale) => [ + escapeHtml(locale.name), + escapeHtml(locale.nativeName || locale.name), + `${buildLocaleFlag(locale)}${code(locale.code)}`, + ]); + const { original, maintainer } = AUTHOR_LINKS; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${h('versionLabel')} ${SCRIPT_VERSION} • ${h('subtitle')}

    +
    + ${section('overview', `

    ${h('overview.body')}

    ${link(DEMO_GIF_URL, t('handout.overview.demo', lang))}

    `)} + ${section('quickStart', list(raw('quickStart.steps'), true))} + ${section('commands', `

    ${h('commands.intro')}

    ${table([t('handout.commands.colCommand', lang), t('handout.commands.colDesc', lang)], commands)}`)} + ${section('revealing', list(raw('revealing.points')))} + ${section('locations', list(raw('locations.points')))} + ${section('settings', `

    ${h('settings.intro')}

    ${table([t('handout.settings.colKey', lang), t('handout.settings.colName', lang), t('handout.settings.colDesc', lang)], settings)}`)} + ${section('jumpgate', list(raw('jumpgate.points')))} + ${section('upgrading', `${list(raw('upgrading.points'))}${table([t('handout.upgrading.colV1', lang), t('handout.upgrading.colV2', lang)], legacyCommands)}`)} + ${section('troubleshooting', list(raw('troubleshooting.points')))} + ${section('languages', `

    ${h('languages.body')}

    ${table([t('handout.languages.colLanguage', lang), t('handout.languages.colNative', lang), t('handout.languages.colCode', lang)], locales)}`)} + ${section( + 'credits', + `

    ${h('credits.original')} ${link(original.profile, original.name)} • ${link(original.marketplace, t('handout.credits.marketplace', lang))}

    +

    ${h('credits.maintainer')} ${link(maintainer.profile, maintainer.name)} • ${link(maintainer.github, 'GitHub')}

    +

    ${h('credits.support')}

    ` + )} +
    ${SCRIPT_NAME} ${SCRIPT_VERSION} • ${h('footer', { deck: HANDOUT_DECK_NAME })}
    +
    `; + } + + /** + * Builds the Command Deck handout HTML. + * + * @param {string} locale Locale code. + * @returns {string} HTML string. + */ + function buildDeckHtml(locale) { + const lang = getLocale(locale); + const tr = (key, vars) => t(key, lang, vars); + const btn = (key, cmd, dark = false) => + `${escapeHtml(tr(`buttons.${key}`))}`; + const group = (titleKey, descKey, buttons) => + `
    ${escapeHtml(tr(titleKey))}
    ${escapeHtml(tr(descKey))}
    ${buttons.join('')}
    `; + + return `
    +
    +

    ⬢ ${SCRIPT_NAME} ⬢

    +

    ${DECK_TITLE} • v${SCRIPT_VERSION}

    +
    + ${group('menu.draw', 'deck.drawDesc', [btn('fill', 'fill'), btn('fillInverse', 'fill inverse'), btn('undo', 'undo', true)])} + ${group('menu.reveal', 'deck.revealDesc', [btn('reveal', 'reveal'), btn('conceal', 'conceal'), btn('explore', 'explore'), btn('revealPage', 'reveal page', true), btn('resetPage', 'reset page', true)])} + ${group('menu.locations', 'deck.locationsDesc', [btn('mark', 'mark'), btn('unmark', 'unmark', true), btn('name', `name ?{${tr('prompts.name')}}`)])} + ${group('menu.tools', 'deck.toolsDesc', [btn('settings', 'set', true), btn('pageSettings', 'page', true), btn('status', 'status', true), btn('rescan', 'rescan', true), btn('calibrate', 'calibrate', true), btn('calibrateReset', 'calibrate reset', true), btn('help', 'help', true), btn('menu', '', true)])} +
    ${escapeHtml(tr('deck.footer', { help: HANDOUT_HELP_NAME }))}
    +
    `; + } + + /** + * Creates or updates a handout, removing duplicates with the same name. + * + * @param {string} name Handout name. + * @param {string} html Handout notes HTML. + * @returns {void} + */ + function upsertHandout(name, html) { + const existing = findObjs({ _type: 'handout', name }); + const [primary, ...duplicates] = existing; + const handout = primary || createObj('handout', { name }); + if (!handout) { + return; + } + handout.set({ inplayerjournals: '', controlledby: '' }); + handout.set('notes', html); + for (const dup of duplicates) { + dup.remove(); + } + } + + /** + * Creates or refreshes the Help and Command Deck handouts in the current language. + * + * @returns {void} + */ + function installHandouts() { + const lang = getConfig().language; + upsertHandout(HANDOUT_HELP_NAME, buildHelpHtml(lang)); + upsertHandout(HANDOUT_DECK_NAME, buildDeckHtml(lang)); + } + + // Revealing hexes: when tokens move, from GM commands, and through the public API. + + /** + * Returns true when a token should reveal hexes under the page's settings. + * + * @param {object} token Roll20 graphic. + * @param {object} settings Effective page settings. + * @returns {boolean} True when the token reveals. + */ + function tokenReveals(token, settings) { + if (!token || token.get('_subtype') !== 'token' || token.get('layer') !== LAYER_TOKEN) { + return false; + } + switch (settings.revealBy) { + case 'all': + return true; + case 'characters': + return !!token.get('represents'); + default: + return getTokenControllers(token).some((id) => id === 'all' || !playerIsGM(id)); + } + } + + /** + * Announces a discovered location. + * + * @param {object} ctx Page context. + * @param {object} hex Hex record (before removal). + * @param {string} name Location name. + * @param {string} imgsrc Icon image URL (may be empty). + * @param {object} settings Effective page settings. + * @returns {void} + */ + function announceDiscovery(ctx, hex, name, imgsrc, settings) { + if (name && settings.announce !== 'off') { + const lang = getConfig().language; + const img = imgsrc + ? `
    ` + : ''; + const html = buildCard( + t('discovery.title', lang), + `${img}
    ${escapeHtml(name)}
    ` + ); + const prefix = settings.announce === 'gm' ? '/w gm ' : ''; + sendChat(SCRIPT_NAME, `${prefix}${html}`); + } + if (name && settings.pingDiscoveries) { + const [x, y] = hexToPixel(ctx.grid, hex.row, hex.col); + sendPing(x, y, ctx.pageId, null, true); + } + } + + /** + * Reveals one hex: removes it and its label, shows its icon, and announces + * it when named. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {object} settings Effective page settings. + * @param {object} [options] Options. + * @param {number} [options.distance=0] Distance from the revealing token (for maxDistance). + * @param {boolean} [options.announce=true] Announce named discoveries. + * @returns {boolean} True when a hex was revealed. + */ + function revealHex(ctx, key, settings, { distance = 0, announce = true } = {}) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + if (distance > 0 && Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + + const name = getDiscoveryName(hex); + const icon = getHexIcon(hex); + const imgsrc = icon ? toText(icon.get('imgsrc')) : ''; + removeHex(ctx.pageId, key, false); + if (icon) { + icon.set({ layer: LAYER_TOKEN, showname: true }); + } + if (announce) { + announceDiscovery(ctx, hex, name, imgsrc, settings); + } + return true; + } + + /** + * Turns a hex see-through (glimpse mode) without revealing it. + * + * @param {object} ctx Page context. + * @param {string} key "row,col" key. + * @param {number} distance Distance from the revealing token. + * @returns {boolean} True when the hex changed. + */ + function glimpseHex(ctx, key, distance) { + const hex = getHex(ctx.pageId, key); + if (!hex) { + return false; + } + const path = getPathObject(hex.id, hex.type); + if (!path) { + return false; + } + const fill = pathColor(getConfig().glimpseColor, path.get('_type')); + if (hex.glimpsed) { + // Versions before this fix marked Jumpgate hexes as glimpsed without + // changing their colour; repaint them when they are seen again. + if (path.get('fill') !== fill) { + path.set('fill', fill); + } + return false; + } + if (Number.isInteger(hex.maxDistance) && distance > hex.maxDistance) { + return false; + } + path.set('fill', fill); + hex.glimpsed = true; + return true; + } + + /** + * Returns true when line of sight from one hex to another is blocked by a + * covered hex. Glimpsed hexes have been seen through, so they do not block. + * + * @param {object} ctx Page context. + * @param {number[]} from [row, col]. + * @param {number[]} to [row, col]. + * @returns {boolean} True when blocked. + */ + function isBlocked(ctx, from, to) { + return hexesBetween(ctx.grid, from, to).some(([r, c]) => { + const hex = getHex(ctx.pageId, hexKey(r, c)); + return hex && !hex.glimpsed; + }); + } + + /** + * Parses a token's lastmove into points. + * + * @param {string} lastmove Roll20 lastmove ("x1,y1,x2,y2,…"). + * @returns {number[][]} Array of [x, y]. + */ + function parseLastMove(lastmove) { + const nums = toText(lastmove) + .split(',') + .map(Number) + .filter((n) => Number.isFinite(n)); + const points = []; + for (let i = 0; i + 1 < nums.length; i += 2) { + points.push([nums[i], nums[i + 1]]); + } + return points; + } + + /** + * Returns the cells a token passed through on its last move, in order, plus + * every cell it now covers. + * + * @param {object} ctx Page context. + * @param {object} token Roll20 graphic. + * @param {object|null} prev Previous token properties, when known. + * @param {boolean} followPath Include the route travelled. + * @returns {number[][]} Array of [row, col], without duplicates. + */ + function travelledCells(ctx, token, prev, followPath) { + const current = [Number(token.get('left')), Number(token.get('top'))]; + const cells = []; + + if ( + followPath && + prev && + Number.isFinite(Number(prev.left)) && + Number.isFinite(Number(prev.top)) + ) { + const start = [Number(prev.left), Number(prev.top)]; + // lastmove holds the start point and any waypoints of the latest drag. It + // is only trusted when it starts where the token was; moves made by other + // mods leave a stale lastmove behind. + const waypoints = parseLastMove(token.get('lastmove')); + const startsHere = + waypoints.length > 0 && + Math.abs(waypoints[0][0] - start[0]) < 1 && + Math.abs(waypoints[0][1] - start[1]) < 1; + const route = startsHere ? [...waypoints, current] : [start, current]; + for (let i = 1; i < route.length; i++) { + cells.push(...hexesAlongSegment(ctx.grid, route[i - 1], route[i])); + } + } + + cells.push( + ...hexesUnderToken( + ctx.grid, + current[0], + current[1], + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + + const seen = new Set(); + return cells.filter(([r, c]) => { + const key = hexKey(r, c); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); + } + + /** + * Reveals around a list of origin cells using the page's settings. + * + * @param {object} ctx Page context. + * @param {number[][]} origins Cells the token occupied, in order. + * @param {object} settings Effective page settings. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealFromCells(ctx, origins, settings) { + let changed = 0; + for (const origin of origins) { + if (revealHex(ctx, hexKey(origin[0], origin[1]), settings)) { + changed++; + } + for (const cell of hexesWithin(ctx.grid, origin[0], origin[1], settings.revealDistance)) { + const key = hexKey(cell[0], cell[1]); + if (!getHex(ctx.pageId, key)) { + continue; + } + if (settings.lineOfSight && isBlocked(ctx, origin, cell)) { + continue; + } + const distance = hexDistance(ctx.grid, origin, cell); + const done = + settings.revealMode === 'glimpse' + ? glimpseHex(ctx, key, distance) + : revealHex(ctx, key, settings, { distance }); + if (done) { + changed++; + } + } + } + return changed; + } + + /** + * Reveals the hexes a token has moved through and can now see. + * + * @param {object} token Roll20 graphic. + * @param {object|null} [prev] Previous token properties from a change event. + * @param {boolean} [force=false] Skip the "which tokens reveal" check. + * @returns {number} Number of hexes revealed or glimpsed. + */ + function revealAroundToken(token, prev = null, force = false) { + const pageId = token?.get('_pageid'); + if (!pageId || getPageHexes(pageId).length === 0) { + return 0; + } + const ctx = getPageContext(pageId); + if (!ctx.ok) { + return 0; + } + const settings = getPageSettings(pageId); + if (!force && !tokenReveals(token, settings)) { + return 0; + } + return revealFromCells(ctx, travelledCells(ctx, token, prev, settings.revealPath), settings); + } + + /** + * Handles a graphic change event: reveals when a token moves or arrives on + * the token layer. + * + * @param {object} token Roll20 graphic. + * @param {object} prev Previous property values. + * @returns {void} + */ + function handleTokenChange(token, prev) { + const moved = prev && (prev.left !== token.get('left') || prev.top !== token.get('top')); + const surfaced = + prev && prev.layer !== token.get('layer') && token.get('layer') === LAYER_TOKEN; + const resized = + prev && (prev.width !== token.get('width') || prev.height !== token.get('height')); + handleCoveredChange(token, prev); + const layerChanged = prev && prev.layer !== token.get('layer'); + if (moved || surfaced || resized) { + if (revealAroundToken(token, moved ? prev : null) > 0) { + // Reveals may uncover other tokens as well as this one. + refreshPage(token.get('_pageid')); + return; + } + } + if (moved || layerChanged) { + refreshToken(token); + } + } + + /** + * Reveals every hex on a page without announcements. + * + * @param {object} ctx Page context. + * @param {(count: number) => void} onDone Completion callback. + * @returns {void} + */ + function revealPage(ctx, onDone) { + const settings = getPageSettings(ctx.pageId); + const keys = getPageHexes(ctx.pageId).map((hex) => hexKey(hex.row, hex.col)); + let count = 0; + runInBatches( + keys, + BATCH_SIZE, + (key) => { + if (revealHex(ctx, key, settings, { announce: false })) { + count++; + } + }, + () => { + refreshPage(ctx.pageId); + onDone(count); + } + ); + } + + // Settings shown in the menu, in order, with how to prompt for them. + const SETTING_ROWS = [ + { key: 'hexLayer', options: HEX_LAYER_OPTIONS }, + { key: 'fillColor', color: true }, + { key: 'strokeColor', color: true }, + { key: 'labelColor', color: true }, + { key: 'glimpseColor', color: true }, + { key: 'strokeWidth' }, + { key: 'maxDistance' }, + { key: 'revealDistance' }, + { key: 'lineOfSight', options: ['on', 'off'] }, + { key: 'revealPath', options: ['on', 'off'] }, + { key: 'revealBy', options: REVEAL_BY_OPTIONS }, + { key: 'revealMode', options: REVEAL_MODE_OPTIONS }, + { key: 'announce', options: ANNOUNCE_OPTIONS }, + { key: 'pingDiscoveries', options: ['on', 'off'] }, + { key: 'hideCoveredTokens', options: ['on', 'off'] }, + { key: 'language' }, + ]; + + /** + * Returns the active locale. + * + * @returns {string} Locale code. + */ + function lang() { + return getConfig().language; + } + + /** + * Translates a key in the active locale. + * + * @param {string} key Translation key. + * @param {object} [vars] Interpolation variables. + * @returns {string} Translated text. + */ + function tr(key, vars) { + return t(key, lang(), vars); + } + + /** + * Whispers a translated error with its hint. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `errors.` (the hint lives under `hints.`). + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function fail(playerId, key, vars) { + const hint = t(`hints.${key}`, lang(), vars); + whisperError(playerId, tr(`errors.${key}`, vars), hint === `hints.${key}` ? '' : hint); + } + + /** + * Whispers a short translated confirmation. + * + * @param {string} playerId Player ID. + * @param {string} key Key under `messages.`. + * @param {object} [vars] Interpolation variables. + * @returns {void} + */ + function done(playerId, key, vars) { + whisper(playerId, SCRIPT_NAME, `
    ${escapeHtml(tr(`messages.${key}`, vars))}
    `); + } + + /** + * Formats a setting value for display. + * + * @param {string} key Setting key. + * @param {*} value Setting value. + * @returns {string} Display text. + */ + function formatValue(key, value) { + if (typeof value === 'boolean') { + return tr(value ? 'values.on' : 'values.off'); + } + if (value === null || value === undefined) { + return tr('values.none'); + } + if (key === 'language') { + return LOCALE_LABELS[value] || value; + } + if (['hexLayer', 'revealBy', 'revealMode', 'announce'].includes(key)) { + return tr(`values.${key}.${value}`); + } + return String(value); + } + + /** + * Builds a Roll20 query prompting for a setting's new value. + * + * @param {object} row Setting row definition. + * @param {*} current Current value. + * @returns {string} Query text. + */ + function settingQuery(row, current) { + const label = tr(`settings.${row.key}.label`).replaceAll(/[|}]/g, ''); + if (row.options) { + return `?{${label}|${row.options.join('|')}}`; + } + if (row.key === 'language') { + return `?{${label}|${SUPPORTED_LOCALES.join('|')}}`; + } + const shown = current === null || current === undefined ? '' : String(current); + return `?{${label}|${shown.replaceAll(/[|}]/g, '')}}`; + } + + // --------------------------------------------------------------------------- + // Selection and page helpers + // --------------------------------------------------------------------------- + + /** + * Sorts the selection into drawn shapes, hexes and tokens. + * + * @param {object} msg Chat message. + * @returns {{paths: object[], hexes: object[], tokens: object[], pageId: string|null}} Selection. + */ + function readSelection(msg) { + const selection = { paths: [], hexes: [], tokens: [], pageId: null }; + for (const sel of msg.selected || []) { + const obj = getObj(sel._type, sel._id); + if (!obj) { + continue; + } + selection.pageId = selection.pageId || obj.get('_pageid'); + if (isPathObject(obj)) { + const found = getHexByPathId(sel._id); + if (found) { + selection.hexes.push(found); + } else { + selection.paths.push(obj); + } + } else if (sel._type === 'graphic' && obj.get('_subtype') === 'token') { + selection.tokens.push(obj); + } + } + return selection; + } + + /** + * Returns the context for the selection's page, or the GM's current page. + * Whispers an error when the page cannot be used. + * + * @param {object} msg Chat message. + * @param {object} selection Selection from readSelection. + * @returns {object|null} Page context. + */ + function pageContextFor(msg, selection) { + const ctx = getPageContext(selection.pageId || getPlayerPageId(msg.playerid)); + if (!ctx.ok) { + fail(msg.playerid, ctx.reason); + return null; + } + return ctx; + } + + /** + * Returns the cells under the selected tokens. + * + * @param {object} ctx Page context. + * @param {object[]} tokens Roll20 graphics. + * @returns {number[][]} Array of [row, col]. + */ + function cellsUnderTokens(ctx, tokens) { + return tokens.flatMap((token) => + hexesUnderToken( + ctx.grid, + Number(token.get('left')), + Number(token.get('top')), + Number(token.get('width')) || 0, + Number(token.get('height')) || 0 + ) + ); + } + + /** + * Reports the end of a fill. + * + * @param {string} playerId Player ID. + * @param {object} summary Fill summary. + * @returns {void} + */ + function reportFill(playerId, summary) { + done(playerId, 'filled', summary); + if (summary.fellBack) { + whisperWarning(playerId, tr('warnings.foregroundUnavailable')); + } + if (summary.failed > 0) { + whisperWarning(playerId, tr('warnings.someFailed', { count: summary.failed })); + } + } + + /** + * Starts a fill and reports its outcome. + * + * @param {object} msg Chat message. + * @param {object} ctx Page context. + * @param {number[][]} allCells Cells to cover (duplicates are ignored). + * @param {object[]} sources Saved source polygons. + * @param {string} kind Fill kind. + * @returns {void} + */ + function startFill(msg, ctx, allCells, sources, kind) { + const seen = new Set(); + const cells = allCells.filter(([r, c]) => { + const key = hexKey(r, c); + return seen.has(key) ? false : seen.add(key); + }); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const result = fillCells(ctx, cells, { + sources, + kind, + onDone: (summary) => { + refreshPage(ctx.pageId); + reportFill(msg.playerid, summary); + }, + }); + if (!result.started) { + fail(msg.playerid, result.reason, { count: cells.length }); + } + } + + // --------------------------------------------------------------------------- + // Command handlers + // --------------------------------------------------------------------------- + + /** + * `fill` and `fill inverse`: cover the selected polygons (or everything + * outside them) with hexes. + * + * @param {object} msg Chat message. + * @param {boolean} inverse Fill outside the polygons. + * @returns {void} + */ + function commandFill(msg, inverse) { + const selection = readSelection(msg); + if (selection.paths.length === 0) { + fail(msg.playerid, 'noPolygons'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = inverse + ? cellsOutsidePaths(ctx, selection.paths) + : cellsInPaths(ctx, selection.paths); + if (cells.length === 0) { + fail(msg.playerid, 'emptyArea'); + return; + } + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, inverse ? 'fillInverse' : 'fill'); + } + + /** + * `conceal`: cover the cells under the selected polygons and tokens again. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandConceal(msg) { + const selection = readSelection(msg); + if (selection.paths.length === 0 && selection.tokens.length === 0) { + fail(msg.playerid, 'nothingToConceal'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const cells = [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]; + const sources = consumeSourcePaths(selection.paths); + startFill(msg, ctx, cells, sources, 'conceal'); + } + + /** + * `reveal`: reveal the selected hexes and the hexes under selected polygons + * and tokens. `reveal page` reveals everything on the page silently. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReveal(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + + if (args[0] === 'page') { + revealPage(ctx, (count) => done(msg.playerid, 'revealedPage', { count })); + return; + } + + const keys = new Set(selection.hexes.filter((h) => h.pageId === ctx.pageId).map((h) => h.key)); + for (const [r, c] of [ + ...cellsInPaths(ctx, selection.paths), + ...cellsUnderTokens(ctx, selection.tokens), + ]) { + keys.add(hexKey(r, c)); + } + if (keys.size === 0) { + fail(msg.playerid, 'nothingToReveal'); + return; + } + consumeSourcePaths(selection.paths); + const settings = getPageSettings(ctx.pageId); + let count = 0; + for (const key of keys) { + if (revealHex(ctx, key, settings)) { + count++; + } + } + refreshPage(ctx.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `explore`: reveal around the selected tokens as if they had just moved + * there. Useful after moving tokens with other mods. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandExplore(msg) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const count = selection.tokens.reduce( + (sum, token) => sum + revealAroundToken(token, null, true), + 0 + ); + refreshPage(selection.pageId); + done(msg.playerid, 'revealed', { count }); + } + + /** + * `reset page [confirm]`: remove every hex on the page. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandReset(msg, args) { + if (args[0] !== 'page') { + fail(msg.playerid, 'unknownCommand', { command: `reset ${args.join(' ')}` }); + return; + } + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const count = getPageHexes(ctx.pageId).length; + if (args[1] !== 'confirm') { + whisper(msg.playerid, tr('titles.confirm'), [ + `
    ${escapeHtml(tr('messages.confirmReset', { count, page: ctx.page.get('name') }))}
    `, + `
    ${buildButton(tr('buttons.confirmReset'), `${COMMAND} reset page confirm`)}
    `, + ]); + return; + } + clearPage(ctx, (removed) => { + refreshPage(ctx.pageId); + done(msg.playerid, 'resetPage', { count: removed }); + }); + } + + /** + * `undo`: reverse the last fill. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandUndo(msg) { + const result = undoLastFill(); + if (!result.ok) { + fail(msg.playerid, result.reason); + return; + } + refreshPage(result.pageId); + done(msg.playerid, 'undone', result); + } + + /** + * `name `: name the selected hexes (or the hexes under selected tokens). + * An empty name clears it. + * + * @param {object} msg Chat message. + * @param {string} rawName Name text. + * @returns {void} + */ + function commandName(msg, rawName) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + const keys = new Set(selection.hexes.map((h) => h.key)); + for (const token of selection.tokens) { + const [r, c] = cellsUnderTokens(ctx, [token])[0]; + keys.add(hexKey(r, c)); + } + const hexes = [...keys].map((key) => getHex(ctx.pageId, key)).filter(Boolean); + if (hexes.length === 0) { + fail(msg.playerid, 'noHexes'); + return; + } + for (const hex of hexes) { + setHexName(ctx, hex, rawName); + } + done(msg.playerid, toText(rawName) ? 'named' : 'unnamed', { + count: hexes.length, + name: toText(rawName), + }); + } + + /** + * `mark` / `unmark`: turn the selected tokens into hidden locations, or back. + * + * @param {object} msg Chat message. + * @param {boolean} mark True to mark, false to unmark. + * @returns {void} + */ + function commandMark(msg, mark) { + const selection = readSelection(msg); + if (selection.tokens.length === 0) { + fail(msg.playerid, 'noTokens'); + return; + } + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (mark) { + done(msg.playerid, 'marked', markLocations(ctx, selection.tokens)); + } else { + done(msg.playerid, 'unmarked', { count: unmarkLocations(ctx, selection.tokens) }); + } + } + + /** + * `set [key] [value]`: change a global setting, or show the settings card. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandSet(msg, args) { + const [key, ...rest] = args; + if (!key) { + showSettings(msg.playerid); + return; + } + if (!(key in DEFAULT_CONFIG)) { + fail(msg.playerid, 'unknownSetting', { key }); + return; + } + const raw = rest.join(' '); + if (key === 'language' && !raw) { + showLanguages(msg.playerid); + return; + } + const result = setConfigValue(key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + if (key === 'language') { + installHandouts(); + } + if (key === 'hideCoveredTokens') { + if (result.value) { + getPageIds().forEach(refreshPage); + } else { + restoreAll(); + } + } + done(msg.playerid, 'settingChanged', { + setting: tr(`settings.${key}.label`), + value: formatValue(key, result.value), + }); + showSettings(msg.playerid); + } + + /** + * `page [set | clear]`: per-page overrides. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandPage(msg, args) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const [action, key, ...rest] = args; + if (action === 'set') { + if (!PAGE_SETTING_KEYS.includes(key)) { + fail(msg.playerid, 'unknownPageSetting', { + key: key || '', + keys: PAGE_SETTING_KEYS.join(', '), + }); + return; + } + const raw = rest.join(' '); + const result = setPageSetting(ctx.pageId, key, raw); + if (!result.valid) { + fail(msg.playerid, 'invalidValue', { key, value: raw }); + return; + } + } else if (action === 'clear') { + clearPageSettings(ctx.pageId); + } else if (action) { + fail(msg.playerid, 'unknownCommand', { command: `page ${args.join(' ')}` }); + return; + } + showPageSettings(msg.playerid, ctx); + } + + /** + * `rescan`: rebuild the page's hex list from the objects on it. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandRescan(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (ctx) { + const counts = rescanPage(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'rescanned', counts); + } + } + + /** + * `calibrate [reset]`: line the grid up with tokens snapped to hex centres. + * + * @param {object} msg Chat message. + * @param {string[]} args Arguments. + * @returns {void} + */ + function commandCalibrate(msg, args) { + const selection = readSelection(msg); + const ctx = pageContextFor(msg, selection); + if (!ctx) { + return; + } + if (args[0] === 'reset') { + const counts = resetCalibration(ctx); + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrationReset', counts); + return; + } + if (selection.tokens.length === 0) { + fail(msg.playerid, 'calibrateNeedsTokens'); + return; + } + const result = calibratePage(ctx, selection.tokens); + if (!result.ok) { + fail(msg.playerid, 'calibrateFailed'); + return; + } + refreshPage(ctx.pageId); + done(msg.playerid, 'calibrated', { + ...result.counts, + colStep: result.calibration.colStep.toFixed(2), + rowStep: result.calibration.rowStep.toFixed(2), + }); + } + + /** + * `journal rebuild`: recreate the help and Command Deck handouts. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function commandJournal(msg) { + installHandouts(); + done(msg.playerid, 'journalRebuilt', { help: HANDOUT_HELP_NAME, deck: HANDOUT_DECK_NAME }); + } + + // --------------------------------------------------------------------------- + // Cards + // --------------------------------------------------------------------------- + + /** + * Whispers the main menu. + * + * @param {string|null} playerId Player ID (null for every GM). + * @returns {void} + */ + function showMainMenu(playerId) { + const b = (key, cmd) => buildButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + const s = (key, cmd) => buildSecondaryButton(tr(`buttons.${key}`), `${COMMAND} ${cmd}`); + whisper(playerId, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, [ + buildSectionLabel(tr('menu.draw')), + `
    ${b('fill', 'fill')}${b('fillInverse', 'fill inverse')}${s('undo', 'undo')}
    `, + buildSectionLabel(tr('menu.reveal')), + `
    ${b('reveal', 'reveal')}${b('conceal', 'conceal')}${b('explore', 'explore')}
    `, + `
    ${s('revealPage', 'reveal page')}${s('resetPage', 'reset page')}
    `, + buildSectionLabel(tr('menu.locations')), + `
    ${b('mark', 'mark')}${s('unmark', 'unmark')}${b('name', `name ?{${tr('prompts.name')}}`)}
    `, + buildSectionLabel(tr('menu.tools')), + `
    ${s('settings', 'set')}${s('pageSettings', 'page')}${s('status', 'status')}
    `, + `
    ${s('rescan', 'rescan')}${s('calibrate', 'calibrate')}${s('help', 'help')}
    `, + ]); + } + + /** + * Whispers the global settings card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showSettings(playerId) { + const config = getConfig(); + const rows = SETTING_ROWS.map((row) => { + const value = config[row.key]; + const flag = + row.key === 'language' + ? buildLocaleFlag(LOCALE_DEFINITIONS.find(({ code }) => code === value)) + : ''; + const shown = row.color ? buildSwatch(value) : flag + escapeHtml(formatValue(row.key, value)); + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} set ${row.key} ${settingQuery(row, value)}` + ); + return buildRow(tr(`settings.${row.key}.label`), `${shown} ${button}`); + }); + whisper(playerId, tr('titles.settings'), [ + ...rows, + buildDivider(), + `
    ${escapeHtml(tr('menu.layerInUse', { layer: tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) }))}
    `, + `
    ${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the list of languages. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showLanguages(playerId) { + const buttons = LOCALE_DEFINITIONS.map((locale) => + buildSecondaryButton( + LOCALE_LABELS[locale.code], + `${COMMAND} set language ${locale.code}`, + buildLocaleFlag(locale) + ) + ); + whisper(playerId, tr('titles.languages'), `
    ${buttons.join('')}
    `); + } + + /** + * Whispers a page's settings and overrides. + * + * @param {string} playerId Player ID. + * @param {object} ctx Page context. + * @returns {void} + */ + function showPageSettings(playerId, ctx) { + const overrides = getPageData(ctx.pageId)?.settings || {}; + const effective = getPageSettings(ctx.pageId); + const rows = PAGE_SETTING_KEYS.map((key) => { + const row = SETTING_ROWS.find((r) => r.key === key); + const marker = key in overrides ? ' ★' : ''; + const button = buildSecondaryButton( + tr('buttons.change'), + `${COMMAND} page set ${key} ${settingQuery(row, effective[key])}` + ); + return buildRow( + `${tr(`settings.${key}.label`)}${marker}`, + `${escapeHtml(formatValue(key, effective[key]))} ${button}` + ); + }); + whisper(playerId, tr('titles.pageSettings', { page: ctx.page.get('name') }), [ + `
    ${escapeHtml(tr('menu.pageSettingsHelp'))}
    `, + ...rows, + `
    ${buildSecondaryButton(tr('buttons.clearOverrides'), `${COMMAND} page clear`)}${buildSecondaryButton(tr('buttons.menu'), COMMAND)}
    `, + ]); + } + + /** + * Whispers the status of the current page. + * + * @param {object} msg Chat message. + * @returns {void} + */ + function showStatus(msg) { + const ctx = pageContextFor(msg, readSelection(msg)); + if (!ctx) { + return; + } + const hexes = getPageHexes(ctx.pageId); + const data = getPageData(ctx.pageId); + const last = getLastFill(); + const row = (key, value) => buildRow(tr(`status.${key}`), escapeHtml(String(value))); + whisper(msg.playerid, tr('titles.status', { page: ctx.page.get('name') }), [ + row('engine', isJumpgate() ? 'Jumpgate' : 'Legacy'), + row('grid', tr(`values.orientation.${ctx.grid.orientation}`)), + row( + 'layer', + tr(`values.hexLayer.${getHexLayer() === LAYER_TOKEN ? 'objects' : 'foreground'}`) + ), + row('hexes', hexes.length), + row('named', hexes.filter((h) => h.name).length), + row('icons', hexes.filter((h) => h.iconId).length), + row('glimpsed', hexes.filter((h) => h.glimpsed).length), + row('pending', getPendingLocations(ctx.pageId).length), + row('calibrated', tr(data?.calibration ? 'values.on' : 'values.off')), + row('overrides', Object.keys(data?.settings || {}).length), + row('undo', last ? tr(`values.fillKind.${last.kind}`) : tr('values.none')), + ]); + } + + /** + * Whispers the help card. + * + * @param {string} playerId Player ID. + * @returns {void} + */ + function showHelp(playerId) { + const lines = [ + ['', 'menu'], + ['fill', 'fill'], + ['fill inverse', 'fillInverse'], + ['undo', 'undo'], + ['reveal', 'reveal'], + ['reveal page', 'revealPage'], + ['conceal', 'conceal'], + ['explore', 'explore'], + ['reset page', 'resetPage'], + ['name ', 'name'], + ['mark', 'mark'], + ['unmark', 'unmark'], + ['set ', 'set'], + ['page set ', 'pageSet'], + ['page clear', 'pageClear'], + ['rescan', 'rescan'], + ['calibrate', 'calibrate'], + ['calibrate reset', 'calibrateReset'], + ['status', 'status'], + ['journal rebuild', 'journal'], + ['help', 'help'], + ]; + const html = lines + .map( + ([cmd, key]) => + `
    ${escapeHtml(`${COMMAND} ${cmd}`.trim())}
    ${escapeHtml(tr(`help.${key}`))}
    ` + ) + .join(''); + whisper(playerId, tr('titles.help'), [ + html, + buildDivider(), + `
    ${escapeHtml(tr('help.handout', { name: HANDOUT_HELP_NAME }))}
    `, + ]); + } + + // --------------------------------------------------------------------------- + // Routing + // --------------------------------------------------------------------------- + + /** + * Routes a parsed command. + * + * @param {object} msg Chat message. + * @param {string} sub Subcommand. + * @param {string[]} args Arguments. + * @param {string} rest Raw text after the subcommand. + * @returns {void} + */ + function routeCommand(msg, sub, args, rest) { + switch (sub) { + case '': + case 'menu': + showMainMenu(msg.playerid); + return; + case 'help': + showHelp(msg.playerid); + return; + case 'fill': + commandFill(msg, args[0] === 'inverse'); + return; + case 'conceal': + case 'hide': + commandConceal(msg); + return; + case 'reveal': + commandReveal(msg, args); + return; + case 'explore': + commandExplore(msg); + return; + case 'reset': + commandReset(msg, args); + return; + case 'undo': + commandUndo(msg); + return; + case 'name': + commandName(msg, rest); + return; + case 'mark': + commandMark(msg, true); + return; + case 'unmark': + commandMark(msg, false); + return; + case 'set': + case 'config': + commandSet(msg, args); + return; + case 'page': + commandPage(msg, args); + return; + case 'rescan': + commandRescan(msg); + return; + case 'calibrate': + commandCalibrate(msg, args); + return; + case 'status': + showStatus(msg); + return; + case 'journal': + commandJournal(msg); + return; + default: + fail(msg.playerid, 'unknownCommand', { command: sub }); + } + } + + /** + * Maps a v1 command to the v2 handlers. + * + * @param {object} msg Chat message. + * @param {string} action Legacy action from LEGACY_COMMANDS. + * @param {string} rest Raw text after the command. + * @returns {void} + */ + function routeLegacy(msg, action, rest) { + const params = rest.split(LEGACY_ARG_SEPARATOR).map((p) => p.trim()); + switch (action) { + case 'fill': + commandFill(msg, false); + return; + case 'fillInverse': + commandFill(msg, true); + return; + case 'menu': + showMainMenu(msg.playerid); + return; + case 'legacyHex': + if (params[0] === 'name') { + commandName(msg, params.slice(1).join(LEGACY_ARG_SEPARATOR)); + } + return; + case 'legacyConfig': { + const [prop, ...values] = params; + // v1 defaults when a colour prompt is left empty. + const updates = { + color: () => ({ + fillColor: values[0] || 'black', + strokeColor: values[1] || 'transparent', + labelColor: values[2] || 'white', + }), + strokeWidth: () => ({ strokeWidth: values[0] || '0' }), + maxDistance: () => ({ maxDistance: values[0] || '' }), + revealDistance: () => ({ revealDistance: values[0] || '0' }), + }[prop]; + if (!updates) { + fail(msg.playerid, 'unknownSetting', { key: prop || '' }); + return; + } + for (const [key, value] of Object.entries(updates())) { + if (!setConfigValue(key, value).valid) { + fail(msg.playerid, 'invalidValue', { key, value }); + } + } + showSettings(msg.playerid); + return; + } + } + } + + /** + * Handles chat input: `!hexploration …` and the v1 commands. GM only. + * + * @param {object} msg Roll20 chat message. + * @returns {void} + */ + function handleInput(msg) { + if (msg.type !== 'api') { + return; + } + const content = toText(msg.content); + const [first] = content.split(/\s+/, 1); + const isMain = first === COMMAND; + const legacy = LEGACY_COMMANDS[first]; + if (!isMain && !legacy) { + return; + } + if (!playerIsGM(msg.playerid)) { + return; + } + + try { + const rest = content.slice(first.length).trim(); + if (legacy) { + routeLegacy(msg, legacy, rest); + return; + } + const [sub = '', ...args] = rest.split(/\s+/).filter(Boolean); + const afterSub = rest.slice(sub.length).trim(); + routeCommand(msg, sub.toLowerCase(), args, afterSub); + } catch (err) { + log(`${SCRIPT_NAME} ERROR: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + fail(msg.playerid, 'unexpected', { message: err?.message || String(err) }); + } + } + + let ready = false; + + /** + * Runs a handler, logging instead of crashing the sandbox on errors. + * + * @param {string} label Handler name for the log. + * @param {Function} fn Handler. + * @returns {Function} Wrapped handler. + */ + function guarded(label, fn) { + return (...args) => { + if (!ready) { + return; + } + try { + fn(...args); + } catch (err) { + log(`${SCRIPT_NAME} ERROR in ${label}: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }; + } + + /** + * Forgets a hex whose path was deleted by hand. + * + * @param {object} path Deleted Roll20 path. + * @returns {void} + */ + function handlePathDestroyed(path) { + const found = getHexByPathId(path.get('_id')); + if (found) { + removeLabel(found.hex); + deleteHexRecord(found.pageId, found.key); + refreshPage(found.pageId); + } + } + + /** + * Forgets a deleted token as a pending location or hidden token. + * + * @param {object} token Deleted Roll20 graphic. + * @returns {void} + */ + function handleGraphicDestroyed(token) { + setPendingLocation(token.get('_id'), null); + delete getCoveredTokens()[token.get('_id')]; + } + + /** + * Forgets a deleted page's hexes. + * + * @param {object} page Deleted Roll20 page. + * @returns {void} + */ + function handlePageDestroyed(page) { + const pageId = page.get('_id'); + if (getPageIds().includes(pageId)) { + deletePageData(pageId); + } + } + + /** + * Registers with TokenMod (if installed) so tokens it moves reveal hexes; + * the API does not raise change events for moves made by other mods. + * + * @returns {void} + */ + function observeOtherMods() { + if (typeof TokenMod !== 'undefined' && typeof TokenMod?.ObserveTokenChange === 'function') { + TokenMod.ObserveTokenChange(guarded('TokenMod observer', handleTokenChange)); + } + } + + /** + * Publishes the API other mods can call. + * + * @returns {void} + */ + function publishApi() { + globalThis.Hexploration = Object.freeze({ + version: SCRIPT_VERSION, + /** + * Reveals around a token as if it had just moved, for mods that move tokens. + * + * @param {object|string} tokenOrId Roll20 graphic or its ID. + * @param {object} [prev] Previous left/top, to reveal along the route. + * @returns {number} Number of hexes revealed or glimpsed. + */ + revealAround(tokenOrId, prev = null) { + const token = typeof tokenOrId === 'string' ? getObj('graphic', tokenOrId) : tokenOrId; + if (!ready || !token) { + return 0; + } + try { + const changed = revealAroundToken(token, prev); + refreshPage(token.get('_pageid')); + return changed; + } catch (err) { + log(`${SCRIPT_NAME} ERROR in revealAround: ${err?.message || err}`); + return 0; + } + }, + }); + } + + /** + * Startup: migrate state, clean up, install handouts and greet the GM. + * + * @returns {void} + */ + function checkInstall() { + const migratedFrom = initialiseState(); + applyGlobalConfig(); + const pruned = pruneMissingHexes(); + const repairedLabels = repairLabelFonts(getPageIds()); + if (repairedLabels > 0) { + log(`${SCRIPT_NAME}: gave ${repairedLabels} hex name label(s) a font Jumpgate can draw.`); + } + for (const pageId of new Set([ + ...getPageIds(), + ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), + ])) { + refreshPage(pageId); + } + installHandouts(); + registerEngineHandlers(); + observeOtherMods(); + publishApi(); + ready = true; + + log( + `-=> ${SCRIPT_NAME} v${SCRIPT_VERSION} [Updated: ${SCRIPT_LAST_UPDATED}] (${isJumpgate() ? 'Jumpgate' : 'Legacy'}) <=-` + ); + + const lang = getConfig().language; + const lines = [`
    ${escapeHtml(t('titles.ready', lang))}
    `]; + if (migratedFrom === 1) { + lines.push(`
    ${escapeHtml(t('messages.migrated', lang))}
    `); + } + if (pruned.dropped > 0) { + lines.push( + `
    ${escapeHtml(t('messages.pruned', lang, pruned))}
    ` + ); + } + lines.push( + `
    ${escapeHtml(t('messages.readyHint', lang))}
    ` + ); + whisper(null, `${SCRIPT_NAME} v${SCRIPT_VERSION}`, lines); + if (migratedFrom === 1 || pruned.dropped > 0) { + showMainMenu(null); + } + } + + /** + * Registers all Roll20 event handlers. + * + * @returns {void} + */ + function registerEventHandlers() { + on('ready', () => { + try { + checkInstall(); + } catch (err) { + log(`${SCRIPT_NAME} ERROR during startup: ${err?.message || err}`); + if (err?.stack) { + log(err.stack); + } + } + }); + on('chat:message', (msg) => { + if (ready) { + handleInput(msg); + } + }); + on('change:graphic', guarded('change:graphic', handleTokenChange)); + on('add:graphic', guarded('add:graphic', refreshToken)); + on('destroy:graphic', guarded('destroy:graphic', handleGraphicDestroyed)); + on('destroy:page', guarded('destroy:page', handlePageDestroyed)); + on(`destroy:${PATH_TYPE_LEGACY}`, guarded('destroy:path', handlePathDestroyed)); + } + + /** + * Registers handlers that depend on the game engine. pathv2 objects only + * exist in Jumpgate, and the engine is only known once the game has loaded. + * + * @returns {void} + */ + function registerEngineHandlers() { + if (isJumpgate()) { + on(`destroy:${PATH_TYPE_V2}`, guarded('destroy:pathv2', handlePathDestroyed)); + } + } + + registerEventHandlers(); +})(); diff --git a/Hexploration/CHANGELOG.md b/Hexploration/CHANGELOG.md index 156a8106f2..39b8b7c1d4 100644 --- a/Hexploration/CHANGELOG.md +++ b/Hexploration/CHANGELOG.md @@ -1,5 +1,16 @@ # Changelog +## 2.0.2 - 2026-10-30 + +### Fixed + +- Naming a hex no longer stops Jumpgate drawing the tabletop. Name labels were made without a font, which Jumpgate cannot draw, so Roll20 showed "Something Went Wrong" until the page was refreshed, and again whenever the page was opened. Labels now use Arial, and labels made by 2.0.0 and 2.0.1 are given the font on startup or when the page is rescanned. +- Undoing a fill no longer forgets the locations it hid. A token marked with Mark Location went back to the token layer as an ordinary token, so the next fill covered it without hiding it, and finding it was not announced. + +### Changed + +- The help handout and README explain that Jumpgate draws the GM layer below the foreground layer, so name labels only show over covered hexes when Hex Layer is set to the token layer. + ## 2.0.1 - 2026-10-30 ### Fixed diff --git a/Hexploration/DEVELOPERS.md b/Hexploration/DEVELOPERS.md index 46dc817c8c..18aeb5afa4 100644 --- a/Hexploration/DEVELOPERS.md +++ b/Hexploration/DEVELOPERS.md @@ -43,7 +43,7 @@ ```js { schemaVersion: 2, - version: '2.0.1', + version: '2.0.2', config: { language, hexLayer, fillColor, strokeColor, labelColor, glimpseColor, strokeWidth, maxDistance, revealDistance, lineOfSight, revealPath, revealBy, revealMode, announce, pingDiscoveries }, diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index d5c6ee8fcb..c305cb694d 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -4,16 +4,16 @@ * ------------------------------------------------ * Name: Hexploration * Script: Hexploration.js - * Version: 2.0.1 - * Built: 2026-10-30T15:35:23.371Z + * Version: 2.0.2 + * Built: 2026-10-30T22:13:47.401Z */ const HexplorationMod = (() => { 'use strict'; // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; - const SCRIPT_VERSION = '2.0.1'; - const SCRIPT_LAST_UPDATED = '2026-10-30T15:35:23.371Z'; + const SCRIPT_VERSION = '2.0.2'; + const SCRIPT_LAST_UPDATED = '2026-10-30T22:13:47.401Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -64,6 +64,10 @@ const HexplorationMod = (() => { const PATH_TYPE_V2 = 'pathv2'; const PATH_TYPES = [PATH_TYPE_V2, PATH_TYPE_LEGACY]; + // Font for hex name labels. Jumpgate cannot draw a text without a font. + const LABEL_FONT_FAMILY = 'Arial'; + const LABEL_FONT_SIZE = 16; + // Status marker v1 used to flag location tokens. Still honoured as a fallback. const LOCATION_MARKER = 'white-tower'; @@ -1519,7 +1523,7 @@ const HexplorationMod = (() => { "Merk ligging verander die geselekteerde tokens in versteekte liggings. 'n Token wat reeds onder 'n seshoek is, word dadelik versteek; anders word dit versteek deur die volgende vulling wat dit bedek.", 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', - "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word.", + "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', ], }, @@ -1897,7 +1901,7 @@ const HexplorationMod = (() => { "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", - "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon.", + "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], }, @@ -2256,7 +2260,7 @@ const HexplorationMod = (() => { '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', - '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。', + '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', ], }, @@ -2629,7 +2633,7 @@ const HexplorationMod = (() => { 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, @@ -3002,7 +3006,7 @@ const HexplorationMod = (() => { 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', - 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres.', + 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], }, @@ -3379,7 +3383,7 @@ const HexplorationMod = (() => { 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', - 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld.', + 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], }, @@ -3748,7 +3752,7 @@ const HexplorationMod = (() => { 'Mark Location turns the selected tokens into hidden locations. A token already under a hex is hidden straight away; otherwise it is hidden by the next fill that covers it.', 'Tokens with the white-tower status marker are also treated as locations when you fill, as in version 1.', 'Hidden location tokens are moved to the GM layer. When their hex is revealed they return to the token layer with their name shown, and their discovery is announced.', - 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed.', + 'Name Hex gives a hex a name without a token. The name is shown to the GM as a label on the GM layer and announced when the hex is revealed. Jumpgate draws the GM layer below the foreground layer, so in Jumpgate the labels only show when Hex Layer is set to the token layer.', 'Announce Discoveries chooses whether everyone, only the GM, or nobody sees the announcement. Ping Discoveries also moves the players’ view to the location.', ], }, @@ -4123,7 +4127,7 @@ const HexplorationMod = (() => { 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', - 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan.', + 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], }, @@ -4503,7 +4507,7 @@ const HexplorationMod = (() => { "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", - "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé.", + "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], }, @@ -4889,7 +4893,7 @@ const HexplorationMod = (() => { '„Standort markieren“ verwandelt die ausgewählten Token in versteckte Standorte. Ein Token, der bereits unter einem Hexfeld liegt, wird sofort versteckt; andernfalls wird er von der nächsten Füllung versteckt, die ihn bedeckt.', 'Token mit der Statusmarkierung „Weißer Turm“ werden beim Ausfüllen ebenfalls als Orte behandelt, wie in Version 1.', 'Versteckte Standortmarker werden auf die GM-Ebene verschoben. Wenn ihr Hexfeld aufgedeckt wird, kehren sie mit angezeigtem Namen zur Spielsteinebene zurück und ihre Entdeckung wird bekannt gegeben.', - '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird.', + '„Hexfeld benennen“ gibt einem Hexfeld einen Namen ohne Token. Der Name wird dem GM als Beschriftung auf der GM-Ebene angezeigt und angekündigt, wenn das Hexfeld aufgedeckt wird. Jumpgate zeichnet die GM-Ebene unterhalb der Vordergrundebene, daher sind die Beschriftungen in Jumpgate nur sichtbar, wenn „Hexfeld-Ebene“ auf die Token-Ebene gesetzt ist.', '„Entdeckungen ankündigen“ legt fest, ob alle, nur der GM oder niemand die Ankündigung sieht. „Entdeckungen anpingen“ verschiebt außerdem die Ansicht der Spieler zum Standort.', ], }, @@ -5265,7 +5269,7 @@ const HexplorationMod = (() => { 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', - 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο.', + 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], }, @@ -5632,7 +5636,7 @@ const HexplorationMod = (() => { 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', - 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף.', + 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], }, @@ -6008,7 +6012,7 @@ const HexplorationMod = (() => { 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', - 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik.', + 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, @@ -6385,7 +6389,7 @@ const HexplorationMod = (() => { 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', - "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato.", + "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], }, @@ -6758,7 +6762,7 @@ const HexplorationMod = (() => { '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', - '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。', + '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], }, @@ -7129,7 +7133,7 @@ const HexplorationMod = (() => { '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', '숨겨진 위치 토큰은 GM 레이어로 이동됩니다. 헥스가 공개되면 이름이 표시된 토큰 레이어로 돌아가고 발견이 발표됩니다.', - '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다.', + '헥스 이름 지정은 토큰 없이 헥스에 이름을 붙입니다. 이름은 GM 레이어에 라벨로 표시되어 GM에게 보이며, 헥스가 공개되면 발표됩니다. Jumpgate는 GM 레이어를 전경 레이어 아래에 그리므로, Jumpgate에서는 헥스 레이어 설정이 토큰 레이어로 되어 있을 때만 라벨이 표시됩니다.', '발견 알림은 모든 사람, GM만, 또는 아무도 알림을 보지 않을지 선택합니다. 발견 위치 핑은 플레이어의 시점도 해당 위치로 옮깁니다.', ], }, @@ -7504,7 +7508,7 @@ const HexplorationMod = (() => { 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, @@ -7881,7 +7885,7 @@ const HexplorationMod = (() => { 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', - 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], }, @@ -8258,7 +8262,7 @@ const HexplorationMod = (() => { 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', - 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado.', + 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], }, @@ -8633,7 +8637,7 @@ const HexplorationMod = (() => { '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, @@ -9012,7 +9016,7 @@ const HexplorationMod = (() => { 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', - 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono.', + 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], }, @@ -9383,7 +9387,7 @@ const HexplorationMod = (() => { 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', - 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas.', + 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], }, @@ -9758,7 +9762,7 @@ const HexplorationMod = (() => { 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', - "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur.", + "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], }, @@ -10132,7 +10136,7 @@ const HexplorationMod = (() => { '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, @@ -11385,6 +11389,43 @@ const HexplorationMod = (() => { } } + /** + * Gives a name label a font Jumpgate can draw. A text created through the API + * without one gets the font "unset", and Jumpgate stops drawing the whole + * tabletop ("Something Went Wrong") when it meets it. Labels made by 2.0.0 and + * 2.0.1 have that font. + * + * @param {object} text Roll20 text object. + * @returns {boolean} Whether the font was changed. + */ + function repairLabelFont(text) { + const font = toText(text.get('font_family')); + if (font && font !== 'unset') { + return false; + } + text.set('font_family', LABEL_FONT_FAMILY); + return true; + } + + /** + * Repairs the font of every name label Hexploration knows about. + * + * @param {string[]} pageIds Pages with hexes. + * @returns {number} Number of labels repaired. + */ + function repairLabelFonts(pageIds) { + let count = 0; + for (const pageId of pageIds) { + for (const hex of getPageHexes(pageId)) { + const text = hex.nameId ? getObj('text', hex.nameId) : null; + if (text && repairLabelFont(text)) { + count++; + } + } + } + return count; + } + /** * Sets or clears a hex's name and redraws its GM-layer label. * @@ -11409,6 +11450,8 @@ const HexplorationMod = (() => { top: y, text: clean, color: getConfig().labelColor, + font_family: LABEL_FONT_FAMILY, + font_size: LABEL_FONT_SIZE, }); if (label) { hex.nameId = label.get('_id'); @@ -12328,7 +12371,10 @@ const HexplorationMod = (() => { const token = locations.get(key); if (token && !hex.iconId) { - record.icons.push({ id: token.get('_id'), layer: token.get('layer') }); + // Remember a Mark Location token so undo can mark it again + const id = token.get('_id'); + const pending = getPendingLocations(ctx.pageId).includes(id); + record.icons.push({ id, layer: token.get('layer'), pending }); attachIcon(hex, token); summary.icons++; } @@ -12416,7 +12462,7 @@ const HexplorationMod = (() => { } } - for (const { id, layer } of record.icons || []) { + for (const { id, layer, pending } of record.icons || []) { const token = getObj('graphic', id); if (token) { for (const hex of getPageHexes(record.pageId)) { @@ -12425,6 +12471,10 @@ const HexplorationMod = (() => { } } token.set('layer', layer || LAYER_TOKEN); + // Hiding it used up its Mark Location; mark it again so the next fill hides it + if (pending) { + setPendingLocation(id, record.pageId); + } } } @@ -12560,6 +12610,7 @@ const HexplorationMod = (() => { const [cx, cy] = hexToPixel(ctx.grid, row, col); const hex = getHex(ctx.pageId, hexKey(row, col)); if (hex && !hex.nameId && Math.hypot(x - cx, y - cy) <= RESCAN_LABEL_TOLERANCE) { + repairLabelFont(text); hex.nameId = text.get('_id'); hex.name = String(text.get('text') || '').trim() || hex.name; counts.labels++; @@ -14227,6 +14278,10 @@ const HexplorationMod = (() => { const migratedFrom = initialiseState(); applyGlobalConfig(); const pruned = pruneMissingHexes(); + const repairedLabels = repairLabelFonts(getPageIds()); + if (repairedLabels > 0) { + log(`${SCRIPT_NAME}: gave ${repairedLabels} hex name label(s) a font Jumpgate can draw.`); + } for (const pageId of new Set([ ...getPageIds(), ...Object.values(getCoveredTokens()).map((entry) => entry.pageId), diff --git a/Hexploration/README.md b/Hexploration/README.md index 062b86ebe6..bcadb92aab 100644 --- a/Hexploration/README.md +++ b/Hexploration/README.md @@ -153,7 +153,7 @@ The swatch next to each colour on the settings card shows the colour with its tr // Pass its previous position to reveal along the route as well. Hexploration.revealAround(token, { left: oldLeft, top: oldTop }); Hexploration.revealAround(tokenId); -Hexploration.version; // "2.0.1" +Hexploration.version; // "2.0.2" ``` ## Credits diff --git a/Hexploration/TESTING.md b/Hexploration/TESTING.md index 9c740aa604..4430affee5 100644 --- a/Hexploration/TESTING.md +++ b/Hexploration/TESTING.md @@ -34,7 +34,7 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa ## Setup -- [ ] Install `Hexploration.js` and save. The API console shows `-=> Hexploration v2.0.1 … (Jumpgate) <=-` (or `(Legacy)`). +- [ ] Install `Hexploration.js` and save. The API console shows `-=> Hexploration v2.0.2 … (Jumpgate) <=-` (or `(Legacy)`). - [ ] The GM receives the "Hexploration is ready." whisper. - [ ] The Journal contains **Hexploration - Help** and **Hexploration - Command Deck**, neither visible to players. - [ ] Every button in the Command Deck works. @@ -86,6 +86,9 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa - [ ] A `white-tower` token is hidden when filled over. - [ ] Revealing the hex returns the token to the token layer with its name shown and announces it. - [ ] Name Hex shows a GM-only label; revealing announces the name and removes the label. +- [ ] Jumpgate: after Name Hex the tabletop keeps drawing (no "Something Went Wrong"). With Hex Layer `objects` the label shows over the covered hex. +- [ ] Mark Location, fill, Undo Fill, then fill again: the location is hidden again and announced when found. +- [ ] Jumpgate: a label made by 2.0.1 (font "unset") stops crashing the page after the sandbox restarts. - [ ] Announce Discoveries: GM only whispers to the GM; Off sends nothing. - [ ] Ping Discoveries moves the players' view. - [ ] A name containing `` appears literally in chat. @@ -98,7 +101,7 @@ For the Legacy game, install Hexploration **1.3** first (with PathMath, MatrixMa ## Upgrading from Version 1 (Legacy game) -- [ ] Replace v1.3 with v2.0.1. The startup whisper says the maps were upgraded. +- [ ] Replace v1.3 with v2.0.2. The startup whisper says the maps were upgraded. - [ ] Existing hexes reveal when tokens move; names and location tokens are announced. - [ ] Colours, border width and reveal distance match the v1 settings. - [ ] The `Hexploration_menu` macro opens the new menu; the v1 Fill buttons in old macros still work. diff --git a/Hexploration/package-lock.json b/Hexploration/package-lock.json index b31e4591e9..0979bfe080 100644 --- a/Hexploration/package-lock.json +++ b/Hexploration/package-lock.json @@ -1,12 +1,12 @@ { "name": "hexploration-roll20", - "version": "2.0.1", + "version": "2.0.2", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "hexploration-roll20", - "version": "2.0.1", + "version": "2.0.2", "devDependencies": { "prettier": "^3.5.3", "rollup": "^4.34.8" diff --git a/Hexploration/package.json b/Hexploration/package.json index c5c82fe7cb..b9edb94fd2 100644 --- a/Hexploration/package.json +++ b/Hexploration/package.json @@ -1,6 +1,6 @@ { "name": "hexploration-roll20", - "version": "2.0.1", + "version": "2.0.2", "description": "Roll20 API Mod that covers hex maps with hexes that are revealed as tokens explore.", "private": true, "type": "module", diff --git a/Hexploration/script.json b/Hexploration/script.json index a78722d4e8..de18c3e59e 100644 --- a/Hexploration/script.json +++ b/Hexploration/script.json @@ -1,13 +1,13 @@ { "name": "Hexploration", "script": "Hexploration.js", - "version": "2.0.1", + "version": "2.0.2", "previousversions": [ - "1.0", "1.1", "1.2", "1.3", - "2.0.0" + "2.0.0", + "2.0.1" ], "description": "# Hexploration\n\nCover a hex map with opaque hexes that are revealed as the party explores. Draw a polygon over the area to hide, fill it with hexes, and every hex a player token moves through (and, optionally, the hexes around it) is uncovered. Hidden locations are announced in chat when they are discovered.\n\n**Version 2.0.0 is a full rewrite that works in Jumpgate and in Legacy games.** It no longer needs PathMath, MatrixMath, Vector Math or HTML Builder. Existing v1 hex maps and the v1 `!hexploration_*` commands keep working.\n\n## Getting started\n\n1. Use a page with a **Hex (V)** or **Hex (H)** grid.\n2. Draw one or more polygons over the area to hide and select them.\n3. Type `!hexploration fill`, or open the **Hexploration - Command Deck** handout and click **Fill**.\n4. Move a player token and watch the map open up.\n\nType `!hexploration` for the menu, or `!hexploration help` for every command. The **Hexploration - Help** handout is created in the Journal on startup.\n\n## Features\n\n* Works with Jumpgate (`pathv2`) and Legacy paths, on both hex grid orientations and any cell size.\n* Hexes are drawn on the foreground layer when the game has one, otherwise on the token layer.\n* Reveals along the whole path a token travels, covers every hex a large token occupies, and respects line of sight.\n* Optional glimpse mode: nearby hexes turn see-through and clear when a token enters them.\n* Named locations and hidden location tokens, announced (and optionally pinged) when discovered.\n* Reveal or re-cover selected hexes, reveal or clear a page, undo the last fill, and per-page settings.\n* Rescan rebuilds the hex list after a page is duplicated or a Legacy game is copied to Jumpgate.\n* Grid calibration for maps whose hexes do not line up.\n* Translated into 24 languages.\n\nOriginal mod by Ada Lindberg. Version 2 is maintained by MidNiteShadow7.", "authors": "Ada Lindberg, MidNiteShadow7", From 34e401db6c1e9659f92e74016fddfb9ab50a80b8 Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:43:30 +0000 Subject: [PATCH 23/24] fix(Hexploration): Correct mistranslations in all 23 languages The machine translations rendered "hex" as the wrong word in many languages: hexadecimal (French, German, Finnish), witch (German, Danish, Dutch), spell (Portuguese, Turkish), magic (Hebrew), a hexadecagon or a solid shape (Greek, Russian) and game counters (Danish, Swedish). Some messages were partly left in English, several said the opposite of the English, and Legacy was translated as "heritage" instead of being kept as Roll20's name for the old editor. Every string in the 23 translations was proofread against the English and corrected where it was wrong: - Each language now uses one word for hex, matching its setting names, so the help and messages agree with the buttons. In Russian, Ukrainian, Polish and Czech, the two setting names that used the long word for hexagon now use the short word every other string uses. - Leftover English, broken grammar and inverted meanings are fixed, and invisible zero-width spaces left by the translator are removed. - The `!hexploration set language` command in the help is no longer translated, so it works when copied. - A corrupted colour example, rgba(0,0,0,0,8), is fixed in Czech and Hungarian. Placeholders, keys and list lengths are unchanged in every language. Signed-off-by: Steve Roberts --- Hexploration/CHANGELOG.md | 1 + Hexploration/src/locales/locale/af.js | 14 ++-- Hexploration/src/locales/locale/ca.js | 75 ++++++++--------- Hexploration/src/locales/locale/cs.js | 55 ++++++------- Hexploration/src/locales/locale/da.js | 93 +++++++++++---------- Hexploration/src/locales/locale/de.js | 70 ++++++++-------- Hexploration/src/locales/locale/el.js | 90 ++++++++++---------- Hexploration/src/locales/locale/es.js | 50 ++++++------ Hexploration/src/locales/locale/fi.js | 79 +++++++++--------- Hexploration/src/locales/locale/fr.js | 58 ++++++------- Hexploration/src/locales/locale/he.js | 88 ++++++++++---------- Hexploration/src/locales/locale/hu.js | 81 +++++++++--------- Hexploration/src/locales/locale/it.js | 79 +++++++++--------- Hexploration/src/locales/locale/ja.js | 46 +++++------ Hexploration/src/locales/locale/ko.js | 40 ++++----- Hexploration/src/locales/locale/nl.js | 100 ++++++++++++----------- Hexploration/src/locales/locale/pl.js | 53 ++++++------ Hexploration/src/locales/locale/pt-BR.js | 48 +++++------ Hexploration/src/locales/locale/pt-PT.js | 48 +++++------ Hexploration/src/locales/locale/ru.js | 73 +++++++++-------- Hexploration/src/locales/locale/sv.js | 89 ++++++++++---------- Hexploration/src/locales/locale/tr.js | 47 +++++------ Hexploration/src/locales/locale/uk.js | 64 +++++++-------- Hexploration/src/locales/locale/zh-TW.js | 96 +++++++++++----------- 24 files changed, 774 insertions(+), 763 deletions(-) diff --git a/Hexploration/CHANGELOG.md b/Hexploration/CHANGELOG.md index 39b8b7c1d4..638efb914f 100644 --- a/Hexploration/CHANGELOG.md +++ b/Hexploration/CHANGELOG.md @@ -6,6 +6,7 @@ - Naming a hex no longer stops Jumpgate drawing the tabletop. Name labels were made without a font, which Jumpgate cannot draw, so Roll20 showed "Something Went Wrong" until the page was refreshed, and again whenever the page was opened. Labels now use Arial, and labels made by 2.0.0 and 2.0.1 are given the font on startup or when the page is rescanned. - Undoing a fill no longer forgets the locations it hid. A token marked with Mark Location went back to the token layer as an ordinary token, so the next fill covered it without hiding it, and finding it was not announced. +- Translations: "hex" had been translated as hexadecimal, witch, spell or magic in several languages, some messages were partly left in English, and a few said the opposite of the English. All 23 translations were proofread; each language now uses one word for hex, and the `!hexploration set language` command in the help is no longer translated. ### Changed diff --git a/Hexploration/src/locales/locale/af.js b/Hexploration/src/locales/locale/af.js index 13ed4c21dc..1427c36144 100644 --- a/Hexploration/src/locales/locale/af.js +++ b/Hexploration/src/locales/locale/af.js @@ -135,11 +135,11 @@ const TRANSLATION = { }, announce: { label: 'Kondig ontdekkings aan', - desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + desc: "Wie sien die kletsboodskap wanneer 'n benoemde ligging ontdek word.", }, pingDiscoveries: { label: 'Ping ontdekkings', - desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + desc: "Wanneer aan, word spelers na 'n benoemde ligging geping wanneer dit ontdek word.", }, hideCoveredTokens: { label: 'Versteek bedekte tokens', @@ -291,7 +291,7 @@ const TRANSLATION = { heading: 'Opdragte', intro: "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", - colCommand: 'Bevel', + colCommand: 'Opdrag', colDesc: 'Wat dit doen', }, revealing: { @@ -303,7 +303,7 @@ const TRANSLATION = { "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Verken, of roep Hexploration.revealAround(token) vanaf jou eie mod aan.', ], }, locations: { @@ -313,7 +313,7 @@ const TRANSLATION = { 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", - 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + 'Kondig ontdekkings aan kies of almal, net die GM, of niemand die aankondiging sien nie. Ping ontdekkings skuif ook die spelers se uitsig na die ligging.', ], }, settings: { @@ -357,13 +357,13 @@ const TRANSLATION = { }, languages: { heading: 'Tale', - body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + body: "Kies 'n taal met !hexploration set language. Beskikbare tale:", colLanguage: 'Taal', colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { - heading: 'Krediete', + heading: 'Erkennings', original: 'Oorspronklike mod deur', maintainer: 'Weergawe 2 onderhou deur', marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', diff --git a/Hexploration/src/locales/locale/ca.js b/Hexploration/src/locales/locale/ca.js index a7e5fab8f8..95b9dc7fdd 100644 --- a/Hexploration/src/locales/locale/ca.js +++ b/Hexploration/src/locales/locale/ca.js @@ -95,7 +95,7 @@ const TRANSLATION = { }, strokeColor: { label: 'Color de la vora', - desc: 'Color del contorn dels nous hexagonals.', + desc: 'Color del contorn dels hexàgons nous.', }, labelColor: { label: "Color de l'etiqueta", @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Distància de visió', - desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + desc: "Quants hexàgons es revelen al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexàgons per on passa la fitxa.", }, lineOfSight: { label: 'Línia de visió', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Revela al llarg del camí', - desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + desc: "Quan està activat, es revela cada hexàgon per on passa una fitxa mentre és arrossegada (inclosos els punts de pas), no només on s'atura.", }, revealBy: { label: 'Fitxes que revelen', - desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + desc: 'Quines fitxes de la capa de fitxes revelen hexàgons: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o totes les fitxes.', }, revealMode: { label: 'Mode de revelació', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Amaga les fitxes cobertes', - desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + desc: "Roll20 dibuixa noms, barres i aures per sobre dels hexàgons. Quan està activat, a les fitxes que són sota un hexàgon cobert se'ls desactiven el nom visible per als jugadors, les barres i les aures, que es tornen a activar quan es descobreixen.", }, }, status: { @@ -162,13 +162,13 @@ const TRANSLATION = { messages: { filled: 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', - revealed: 'Hexagones revelats: {count}.', + revealed: 'Hexàgons revelats: {count}.', revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: - 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + "Últim emplenament desfet. Hexàgons eliminats: {removed}. Hexàgons amb l'estil restaurat: {restored}.", named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: @@ -176,11 +176,11 @@ const TRANSLATION = { unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", + "Reescaneig completat. Conservats: {kept}. Adoptats: {adopted}. Reubicats: {moved}. Desapareguts i oblidats: {dropped}. Etiquetes tornades a enllaçar: {labels}. Fitxes d'ubicació tornades a enllaçar: {icons}.", calibrated: - "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.', calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + "S'ha eliminat el calibratge. Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", @@ -191,26 +191,26 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + "Aquest joc no admet dibuixar a la capa de primer pla, de manera que els hexàgons s'han dibuixat a la capa de fitxes.", someFailed: - "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", + "Hexàgons que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', - emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + emptyArea: "L'àrea seleccionada no conté cap centre d'hexàgon.", + tooMany: "Això crearia massa hexàgons d'una vegada ({count}).", nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', - nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', - noTokens: 'Seleccioneu primer un o més fitxes.', - noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToReveal: 'Seleccioneu hexàgons, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer una o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexàgons (o fitxes situades en hexàgons).', nothingToUndo: 'No hi ha cap emplenament per desfer.', unknownCommand: 'Ordre desconeguda: {command}', unknownSetting: 'Configuració desconeguda: {key}', unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', invalidValue: '"{value}" no és un valor vàlid per a {key}.', - calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes ajustades als centres dels hexàgons.', calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', unexpected: "S'ha produït un error: {message}", }, @@ -235,25 +235,26 @@ const TRANSLATION = { }, help: { menu: 'Mostra el menú.', - fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexàgons.', fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', - undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + undo: "Desfà l'últim emplenament, emplenament invers o ocultació, i restaura les formes que va utilitzar.", reveal: - 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + 'Revela els hexàgons seleccionats i els hexàgons que hi ha sota les formes i fitxes seleccionades.', revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', - conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", - explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + conceal: + "Torneu a cobrir amb hexàgons l'àrea que hi ha sota les formes i fitxes seleccionades.", + explore: "Revela el voltant de les fitxes seleccionades com si s'hi acabessin de moure.", resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', - name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + name: 'Anomena els hexàgons seleccionats o els hexàgons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', - unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + unmark: 'Fa que les fitxes seleccionades deixin de ser ubicacions ocultes.', set: 'Canvia un paràmetre o mostra tots els paràmetres.', pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: - 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades ajustades als centres dels hexàgons.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", @@ -277,7 +278,7 @@ const TRANSLATION = { footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', - body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + body: "Hexploration cobreix un mapa hexagonal amb hexàgons opacs. A mesura que el grup es mou, els hexàgons per on passa (i, si voleu, els hexàgons del voltant) s'eliminen, de manera que el mapa es descobreix hexàgon a hexàgon. Les ubicacions ocultes es poden col·locar sota hexàgons i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", demo: 'Mira una petita demostració (de la versió 1)', }, quickStart: { @@ -294,7 +295,7 @@ const TRANSLATION = { heading: 'Ordres', intro: 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', - colCommand: 'Comandament', + colCommand: 'Ordre', colDesc: 'Què fa', }, revealing: { @@ -306,15 +307,15 @@ const TRANSLATION = { "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres mods. Els moviments de TokenMod es recullen automàticament; per a altres mods, seleccioneu les fitxes i feu clic a Explora, o crideu Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { - heading: 'Hexes i ubicacions anomenades', + heading: 'Hexàgons amb nom i ubicacions', points: [ - "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", - "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", - "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari, l'amaga el següent emplenament que la cobreixi.", + "Les fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa del GM. Quan es revela el seu hexàgon, tornen a la capa de fitxes amb el nom visible i s'anuncia el seu descobriment.", "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], @@ -323,7 +324,7 @@ const TRANSLATION = { heading: 'Configuració', intro: 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', - colKey: 'clau', + colKey: 'Clau', colName: 'Configuració', colDesc: 'Descripció', perPage: '(Es pot configurar per pàgina.)', @@ -345,8 +346,8 @@ const TRANSLATION = { 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], - colV1: 'Comandament de la versió 1', - colV2: 'Comandament de la versió 2', + colV1: 'Ordre de la versió 1', + colV2: 'Ordre de la versió 2', }, troubleshooting: { heading: 'Resolució de problemes', @@ -360,7 +361,7 @@ const TRANSLATION = { }, languages: { heading: 'Idiomes', - body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + body: 'Trieu un idioma amb !hexploration set language. Idiomes disponibles:', colLanguage: 'Llengua', colNative: 'Nom original', colCode: 'Codi', diff --git a/Hexploration/src/locales/locale/cs.js b/Hexploration/src/locales/locale/cs.js index d953b365db..d0b5554d21 100644 --- a/Hexploration/src/locales/locale/cs.js +++ b/Hexploration/src/locales/locale/cs.js @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Vrstva šestiúhelníků', + label: 'Vrstva hexů', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { label: 'Barva výplně', - desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0.8).', }, strokeColor: { label: 'Barva ohraničení', @@ -110,7 +110,7 @@ const TRANSLATION = { desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Vzdálenost odhalení šestiúhelníků', + label: 'Vzdálenost odhalení hexů', desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', }, revealDistance: { @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Přímá viditelnost', - desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení hexů, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', }, revealPath: { label: 'Odhalovat po cestě', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Skrýt zakryté žetony', - desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když je zapnuto, žetonům pod zakrytým hexem se vypnou jméno, pruhy a aury viditelné pro hráče a znovu se zapnou, až budou odkryty.', }, }, status: { @@ -161,26 +161,26 @@ const TRANSLATION = { }, messages: { filled: - 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + 'Vyplnění dokončeno. Nakreslené hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', revealed: 'Odhalené hexy: {count}.', - revealedPage: 'Každé odhalené hex na stránce ({count}).', + revealedPage: 'Odhaleny všechny hexy na stránce ({count}).', confirmReset: - 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + 'Odebrat všechny hexy ze stránky „{page}“ ({count})? Žetony míst se vrátí do vrstvy žetonů. Funkce Vrátit to nevrátí.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', - named: 'Hexusy s názvem „{name}“: {count}.', + named: 'Hexy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', unmarked: 'Tokeny, které již nejsou umístěními: {count}.', settingChanged: '{setting} nastaveno na {value}.', rescanned: - 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Přeřazeno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', calibrationReset: - 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + 'Kalibrace odstraněna. Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', @@ -192,14 +192,13 @@ const TRANSLATION = { warnings: { foregroundUnavailable: 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', - someFailed: - 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', + someFailed: 'Hexy, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', - emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy hexů.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', @@ -236,17 +235,17 @@ const TRANSLATION = { fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', - revealPage: 'Odhalte každé hex na stránce bez oznámení.', + revealPage: 'Odhalte každý hex na stránce bez oznámení.', conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', mark: 'Proměňte vybrané žetony na skrytá místa.', - unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + unmark: 'Zrušte u vybraných žetonů označení skrytých míst.', set: 'Změňte nastavení nebo zobrazte všechna nastavení.', pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', pageClear: 'Odstraňte přepsání aktuální stránky.', - rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + rescan: 'Znovu vytvořte seznam hexů na stránce, například po zkopírování stránky nebo hry.', calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', @@ -273,7 +272,7 @@ const TRANSLATION = { overview: { heading: 'Přehled', body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', - demo: 'Podívejte se na krátkou ukázku (od verze 1)', + demo: 'Podívejte se na krátkou ukázku (z verze 1)', }, quickStart: { heading: 'Rychlý start', @@ -297,8 +296,8 @@ const TRANSLATION = { points: [ 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', - 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', - 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení hexů.', + 'Vzdálenost odhalení hexů se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení hexů na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', @@ -307,17 +306,17 @@ const TRANSLATION = { locations: { heading: 'Pojmenované hexy a umístění', points: [ - 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak jej skryje další výplň, která jej zakryje.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva hexů nastavena na vrstvu žetonů.', 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu hexů, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -326,8 +325,8 @@ const TRANSLATION = { jumpgate: { heading: 'Jumpgate a Legacy', points: [ - 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', + 'Hexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Když je Vrstva hexů nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], @@ -361,9 +360,9 @@ const TRANSLATION = { colCode: 'Kód', }, credits: { - heading: 'Kredity', + heading: 'Autoři', original: 'Původní mod od', - maintainer: 'Verze 2 spravovaná společností', + maintainer: 'Verzi 2 spravuje', marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', support: 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', diff --git a/Hexploration/src/locales/locale/da.js b/Hexploration/src/locales/locale/da.js index 3ce729ed25..e530e23caa 100644 --- a/Hexploration/src/locales/locale/da.js +++ b/Hexploration/src/locales/locale/da.js @@ -91,15 +91,15 @@ const TRANSLATION = { }, fillColor: { label: 'Fyldfarve', - desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + desc: 'Farve på nye hexfelter. Brug rgba() til gennemsigtige hexfelter, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfarve', - desc: 'Farve på omridset af nye sekskanter.', + desc: 'Farve på omridset af nye hexfelter.', }, labelColor: { label: 'Etiketfarve', - desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + desc: 'Farven på navneetiketterne, som kun GM kan se, på navngivne hexfelter.', }, glimpseColor: { label: 'Glimtfarve', @@ -107,7 +107,7 @@ const TRANSLATION = { }, strokeWidth: { label: 'Kantbredde', - desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + desc: 'Bredden af omridset af nye hexfelter, i pixels (0 til 20).', }, maxDistance: { label: 'Afsløringsafstand for hexfelter', @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Synsafstand', - desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + desc: 'Hvor mange hexfelter omkring et token i bevægelse afsløres (0 til 20). 0 afslører kun de hexfelter, som tokenet passerer igennem.', }, lineOfSight: { label: 'Synslinje', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Afslør langs ruten', - desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + desc: 'Når den er tændt, afsløres hvert hexfelt, et token passerer igennem, mens det trækkes (inklusive mellempunkter), ikke kun hvor det stopper.', }, revealBy: { label: 'Afslørende tokens', - desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + desc: 'Hvilke tokens på tokenlaget afslører hexfelter: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller alle tokens.', }, revealMode: { label: 'Afsløringstilstand', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Skjul dækkede tokens', - desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + desc: 'Roll20 tegner navne, bjælker og auraer over hexfelter. Når den er tændt, får tokens under et dækket hexfelt deres spillersynlige navn, bjælker og auraer slået fra, og de slås til igen, når tokens afdækkes.', }, }, status: { @@ -160,26 +160,27 @@ const TRANSLATION = { undo: 'Fortryd tilgængelig', }, messages: { - filled: 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', - revealed: 'Hexer afsløret: {count}.', - revealedPage: 'Hver hex på siden afsløret ({count}).', + filled: + 'Udfyldning færdig. Hexfelter tegnet: {created}. Stil ændret: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexfelter afsløret: {count}.', + revealedPage: 'Alle hexfelter på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: 'Hexer fjernet fra siden: {count}.', + 'Vil du fjerne alle hexfelter fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexfelter fjernet fra siden: {count}.', undone: - 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', - named: 'Hexer med navnet "{name}": {count}.', + 'Sidste udfyldning fortrydet. Hexfelter fjernet: {removed}. Hexfelter med ændret stil gendannet: {restored}.', + named: 'Hexfelter med navnet "{name}": {count}.', unnamed: 'Navne ryddet: {count}.', marked: - 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + 'Placeringer skjult i eksisterende hexfelter: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', unmarked: 'Tokens, der ikke længere er placeringer: {count}.', settingChanged: '{setting} indstillet til {value}.', rescanned: - 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', + 'Genscanning fuldført. Beholdt: {kept}. Overtaget: {adopted}. Omplaceret: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', calibrationReset: - 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', @@ -190,25 +191,25 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', - someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', + 'Dette spil understøtter ikke tegning på forgrundslaget, så hexfelterne blev tegnet på tokenlaget.', + someFailed: 'Hexfelter, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { noPage: 'Kunne ikke finde siden at arbejde på.', notHex: 'Denne side bruger ikke et hex-gitter.', noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', - emptyArea: 'Det valgte område indeholder ingen hex-centre.', - tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + emptyArea: 'Det valgte område indeholder ingen hexfeltcentre.', + tooMany: 'Det ville skabe for mange hexfelter på én gang ({count}).', nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', - nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + nothingToReveal: 'Vælg hexfelter, tegnede figurer eller tokens, der skal afsløres.', noTokens: 'Vælg først et eller flere tokens.', - noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + noHexes: 'Vælg først et eller flere hexfelter (eller tokens, der står på hexfelter).', nothingToUndo: 'Der er ingen udfyldning at fortryde.', unknownCommand: 'Ukendt kommando: {command}', unknownSetting: 'Ukendt indstilling: {key}', unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', - calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hexfeltcentre.', calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', unexpected: 'Noget gik galt: {message}', }, @@ -219,34 +220,36 @@ const TRANSLATION = { 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', - noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + noHexes: + 'Hexfelterne ligger på forgrundslaget eller tokenlaget; skift til det lag for at vælge dem.', unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', calibrateNeedsTokens: - 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + 'Fastgør et token til midten af et hexfelt, og vælg det. Vælg et andet token, der er fastgjort til et tilstødende hexfelt i samme række (Hex V) eller kolonne (Hex H), for også at rette hexfeltstørrelsen.', calibrateFailed: - 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), mindst ét hexfelt fra hinanden.', unexpected: 'Detaljer er i API-konsolloggen.', }, help: { menu: 'Vis menuen.', - fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fill: 'Dæk de valgte tegnede figurer med hexfelter.', fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', - reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', - revealPage: 'Afslør hver hex på siden uden meddelelser.', - conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + reveal: 'Afslør de valgte hexfelter og hexfelterne under de valgte former og tokens.', + revealPage: 'Afslør alle hexfelter på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med hexfelter igen.', explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', - resetPage: 'Fjern hver hex på siden (spørg først).', - name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + resetPage: 'Fjern alle hexfelter på siden (spørger først).', + name: 'Navngiv de valgte hexfelter eller hexfelterne under de valgte tokens. Lad navnet stå tomt for at rydde det.', mark: 'Gør de valgte tokens til skjulte placeringer.', unmark: 'Stop de valgte tokens med at være skjulte placeringer.', set: 'Skift en indstilling, eller vis alle indstillinger.', pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', pageClear: 'Fjern den aktuelle sides tilsidesættelser.', - rescan: 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + rescan: + 'Genopbyg sidens liste over hexfelter, for eksempel efter at have kopieret en side eller et spil.', calibrate: - 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hexfeltcentre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', journal: 'Genopbyg uddelingsarkene Help og Command Deck.', @@ -259,18 +262,18 @@ const TRANSLATION = { revealDesc: 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: - 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + 'Vælg tokens for at skjule dem som placeringer under hexfelter. Vælg hexfelter eller tokens for at navngive et hexfelt.', toolsDesc: 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-udforskning for Roll20', + subtitle: 'Udforskning hexfelt for hexfelt i Roll20', footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', overview: { heading: 'Oversigt', - body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + body: 'Hexploration dækker et hexkort med uigennemsigtige hexfelter. Efterhånden som gruppen bevæger sig, fjernes de hexfelter, den passerer igennem (og, hvis du vil, hexfelterne omkring den), så kortet afdækkes ét hexfelt ad gangen. Skjulte steder kan placeres under hexfelter og annonceres, når de findes. Det fungerer i Jumpgate- og Legacy-spil, på Hex (V)- og Hex (H)-gitre af enhver størrelse.', demo: 'Se en kort demo (fra version 1)', }, quickStart: { @@ -303,11 +306,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Navngivne Hekser og Steder', + heading: 'Navngivne hexfelter og steder', points: [ 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', - 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hexfelt afsløres, vender de tilbage til tokenlaget med deres navn vist, og deres opdagelse annonceres.', 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], @@ -334,7 +337,7 @@ const TRANSLATION = { heading: 'Opgradering fra version 1', points: [ 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', - 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Eksisterende hexkort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], @@ -353,13 +356,13 @@ const TRANSLATION = { }, languages: { heading: 'Sprog', - body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + body: 'Vælg et sprog med !hexploration set language. Tilgængelige sprog:', colLanguage: 'Sprog', colNative: 'Eget navn', colCode: 'Kode', }, credits: { - heading: 'Kreditter', + heading: 'Medvirkende', original: 'Original mod af', maintainer: 'Version 2 vedligeholdes af', marketplace: 'Adas kunstpakker på Roll20 Marketplace', diff --git a/Hexploration/src/locales/locale/de.js b/Hexploration/src/locales/locale/de.js index e693fa309e..32c71b2e9d 100644 --- a/Hexploration/src/locales/locale/de.js +++ b/Hexploration/src/locales/locale/de.js @@ -91,7 +91,7 @@ const TRANSLATION = { }, fillColor: { label: 'Füllfarbe', - desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexfelder, zum Beispiel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randfarbe', @@ -127,7 +127,7 @@ const TRANSLATION = { }, revealBy: { label: 'Aufdeckende Token', - desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + desc: 'Welche Token auf der Token-Ebene Hexfelder aufdecken: Token, die von einem Spieler gesteuert werden, Token, die einen beliebigen Charakter darstellen, oder alle Token.', }, revealMode: { label: 'Aufdeckmodus', @@ -161,26 +161,26 @@ const TRANSLATION = { }, messages: { filled: - 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', - revealed: 'Aufgedeckte Verhexungen: {count}.', - revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + 'Füllen abgeschlossen. Gezeichnete Hexfelder: {created}. Neu gestaltet: {restyled}. Versteckte Standorte: {icons}.', + revealed: 'Aufgedeckte Hexfelder: {count}.', + revealedPage: 'Alle Hexfelder auf der Seite aufgedeckt ({count}).', confirmReset: - 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', - resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + 'Alle Hexfelder aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Von der Seite entfernte Hexfelder: {count}.', undone: - 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', - named: 'Hexen mit dem Namen „{name}“: {count}.', + 'Letzte Füllung rückgängig gemacht. Entfernte Hexfelder: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexfelder mit dem Namen „{name}“: {count}.', unnamed: 'Gelöschte Namen: {count}.', marked: 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', unmarked: 'Token, die keine Standorte mehr sind: {count}.', settingChanged: '{setting} wird auf {value} gesetzt.', rescanned: - 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + 'Erneuter Scan abgeschlossen. Behalten: {kept}. Übernommen: {adopted}. Neu zugeordnet: {moved}. Fehlend und vergessen: {dropped}. Neu verknüpfte Beschriftungen: {labels}. Neu verknüpfte Standort-Token: {icons}.', calibrated: - 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Raster kalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', calibrationReset: - 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', @@ -193,18 +193,18 @@ const TRANSLATION = { foregroundUnavailable: 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', someFailed: - 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + 'Hexfelder, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', }, errors: { noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', notHex: 'Diese Seite verwendet kein Hex-Raster.', noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', - emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', - tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + emptyArea: 'Der ausgewählte Bereich enthält keine Hexfeld-Mittelpunkte.', + tooMany: 'Das würde zu viele Hexfelder auf einmal erzeugen ({count}).', nothingToConceal: - 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + 'Wählen Sie gezeichnete Formen oder Spielsteine aus, die Sie verbergen möchten.', nothingToReveal: - 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine aus, die Sie aufdecken möchten.', noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', noHexes: 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', @@ -214,7 +214,7 @@ const TRANSLATION = { unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', calibrateNeedsTokens: - 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + 'Wählen Sie ein oder zwei Token aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', unexpected: 'Es ist ein Fehler aufgetreten: {message}', }, @@ -227,38 +227,38 @@ const TRANSLATION = { tooMany: 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', noHexes: - 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + 'Hexfelder liegen auf der Vordergrund- oder Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', calibrateNeedsTokens: 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', calibrateFailed: - 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + 'Zwei Spielsteine müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hexfeld voneinander entfernt sein.', unexpected: 'Details finden Sie im API-Konsolenprotokoll.', }, help: { menu: 'Zeigen Sie das Menü an.', - fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexfeldern ab.', fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', - undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + undo: 'Machen Sie die letzte Füllung, umgekehrte Füllung oder Verbergung rückgängig und stellen Sie die dabei verwendeten Formen wieder her.', reveal: 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', - revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + revealPage: 'Decken Sie alle Hexfelder auf der Seite ohne Ankündigungen auf.', conceal: - 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexfeldern ab.', explore: - 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', - resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + 'Decken Sie die Umgebung der ausgewählten Spielsteine auf, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entfernen Sie alle Hexfelder auf der Seite (mit Rückfrage).', name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', - mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine in versteckte Orte.', unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', - pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageSet: 'Überschreiben Sie eine Aufdeck-Einstellung nur auf der aktuellen Seite.', pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', rescan: - 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + 'Erstellen Sie die Hexfeldliste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', calibrate: - 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + 'Richten Sie das Hexfeld-Raster an einem oder zwei ausgewählten Spielsteinen aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', @@ -271,18 +271,18 @@ const TRANSLATION = { revealDesc: 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: - 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + 'Wählen Sie Spielsteine aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-für-Hex-Erkundung für Roll20', + subtitle: 'Erkundung Hexfeld für Hexfeld in Roll20', footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', overview: { heading: 'Überblick', - body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + body: 'Hexploration deckt eine Hexfeldkarte mit undurchsichtigen Hexfeldern ab. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum), entfernt, sodass die Karte Hexfeld für Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen, auf Hex (V)- und Hex (H)-Rastern jeder Größe.', demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', }, quickStart: { @@ -303,7 +303,7 @@ const TRANSLATION = { colDesc: 'Was es bewirkt', }, revealing: { - heading: 'Wie Offenlegung funktioniert', + heading: 'Wie das Aufdecken funktioniert', points: [ 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', @@ -346,7 +346,7 @@ const TRANSLATION = { heading: 'Upgrade von Version 1', points: [ 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', - 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Vorhandene Hexkarten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], diff --git a/Hexploration/src/locales/locale/el.js b/Hexploration/src/locales/locale/el.js index 127354dbbb..c3e18b76e1 100644 --- a/Hexploration/src/locales/locale/el.js +++ b/Hexploration/src/locales/locale/el.js @@ -91,11 +91,11 @@ const TRANSLATION = { }, fillColor: { label: 'Χρώμα πλήρωσης', - desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + desc: 'Χρώμα νέων εξαγώνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', }, strokeColor: { label: 'Χρώμα περιγράμματος', - desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + desc: 'Χρώμα του περιγράμματος των νέων εξαγώνων.', }, labelColor: { label: 'Χρώμα ετικετών', @@ -107,7 +107,7 @@ const TRANSLATION = { }, strokeWidth: { label: 'Πλάτος περιγράμματος', - desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + desc: 'Πλάτος του περιγράμματος των νέων εξαγώνων, σε pixel (0 έως 20).', }, maxDistance: { label: 'Απόσταση αποκάλυψης εξαγώνων', @@ -127,7 +127,7 @@ const TRANSLATION = { }, revealBy: { label: 'Διακριτικά που αποκαλύπτουν', - desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + desc: 'Ποια διακριτικά στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: διακριτικά που ελέγχει ένας παίκτης, διακριτικά που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', @@ -139,11 +139,11 @@ const TRANSLATION = { }, pingDiscoveries: { label: 'Ping στις ανακαλύψεις', - desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες λαμβάνουν ping σε μια τοποθεσία με όνομα όταν αυτή ανακαλυφθεί.', }, hideCoveredTokens: { label: 'Απόκρυψη καλυμμένων διακριτικών', - desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από τα εξάγωνα. Όταν είναι ενεργοποιημένο, στα διακριτικά κάτω από καλυμμένο εξάγωνο απενεργοποιούνται το ορατό στους παίκτες όνομα, οι μπάρες και οι αύρες, και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { @@ -161,26 +161,26 @@ const TRANSLATION = { }, messages: { filled: - 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + 'Το γέμισμα ολοκληρώθηκε. Εξάγωνα που σχεδιάστηκαν: {created}. Με νέα μορφοποίηση: {restyled}. Κρυμμένες τοποθεσίες: {icons}.', revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', - revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + revealedPage: 'Αποκαλύφθηκαν όλα τα εξάγωνα της σελίδας ({count}).', confirmReset: 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', undone: - 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', - named: 'Hexes με όνομα "{name}": {count}.', + 'Το τελευταίο γέμισμα αναιρέθηκε. Εξάγωνα που αφαιρέθηκαν: {removed}. Εξάγωνα που επανήλθαν στην αρχική μορφή: {restored}.', + named: 'Εξάγωνα με όνομα "{name}": {count}.', unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', marked: - 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + 'Τοποθεσίες κρυμμένες σε υπάρχοντα εξάγωνα: {attached}. Σε αναμονή για το επόμενο γέμισμα που θα τις καλύψει: {pending}.', unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', settingChanged: 'Το {setting} ορίστηκε σε {value}.', rescanned: - 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + 'Η επανασάρωση ολοκληρώθηκε. Διατηρήθηκαν: {kept}. Υιοθετήθηκαν: {adopted}. Μετακινήθηκαν: {moved}. Λείπουν και ξεχάστηκαν: {dropped}. Επανασυνδεδεμένες ετικέτες: {labels}. Επανασυνδεδεμένα διακριτικά τοποθεσίας: {icons}.', calibrated: - 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Το πλέγμα βαθμονομήθηκε (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', calibrationReset: - 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Η βαθμονόμηση καταργήθηκε. Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', @@ -191,44 +191,44 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο επίπεδο πρώτου πλάνου, οπότε τα εξάγωνα σχεδιάστηκαν στο επίπεδο διακριτικών.', someFailed: - 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + 'Εξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', }, errors: { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', - noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για γέμισμα.', emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', - nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', - nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή διακριτικά για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή διακριτικά για αποκάλυψη.', noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', - noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή διακριτικά που στέκονται σε εξάγωνα).', nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', unknownCommand: 'Άγνωστη εντολή: {command}', unknownSetting: 'Άγνωστη ρύθμιση: {key}', unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', - calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', unexpected: 'Κάτι πήγε στραβά: {message}', }, hints: { noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', - notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + notHex: 'Ορίστε το πλέγμα της σελίδας σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', noPolygons: - 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', - emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα με ελεύθερο χέρι γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος της σελίδας.', tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', noHexes: - 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + 'Τα εξάγωνα βρίσκονται στο επίπεδο πρώτου πλάνου ή στο επίπεδο διακριτικών· μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', calibrateNeedsTokens: - 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + 'Κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό κουμπωμένο σε γειτονικό εξάγωνο της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', calibrateFailed: - 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + 'Τα δύο διακριτικά πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), σε απόσταση τουλάχιστον ενός εξαγώνου μεταξύ τους.', unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', }, help: { @@ -237,21 +237,21 @@ const TRANSLATION = { fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', reveal: - 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και διακριτικά.', revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', - conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', - explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + conceal: 'Καλύψτε ξανά με εξάγωνα την περιοχή κάτω από τα επιλεγμένα σχήματα και διακριτικά.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', - unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + unmark: 'Τα επιλεγμένα διακριτικά παύουν να είναι κρυφές τοποθεσίες.', set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: - 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', @@ -264,18 +264,18 @@ const TRANSLATION = { revealDesc: 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: - 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα εξάγωνα. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', }, handout: { - versionLabel: 'Εκδοχή', - subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + versionLabel: 'Έκδοση', + subtitle: 'Εξερεύνηση εξάγωνο προς εξάγωνο για το Roll20', footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', overview: { heading: 'Επισκόπηση', - body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + body: 'Το Hexploration καλύπτει έναν εξαγωνικό χάρτη με αδιαφανή εξάγωνα. Καθώς η ομάδα κινείται, τα εξάγωνα από τα οποία περνά (και, αν θέλετε, τα εξάγωνα γύρω της) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', }, quickStart: { @@ -291,7 +291,7 @@ const TRANSLATION = { commands: { heading: 'Εντολές', intro: - 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότερες ενεργούν στα επιλεγμένα αντικείμενα· οι υπόλοιπες ενεργούν στη σελίδα που βλέπετε.', colCommand: 'Εντολή', colDesc: 'Τι κάνει', }, @@ -308,11 +308,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Με όνομα Hexes and Locations', + heading: 'Εξάγωνα με όνομα και τοποθεσίες', points: [ 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', - 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', - 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν κάνετε γέμισμα, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλυφθεί, επιστρέφουν στο επίπεδο διακριτικών με ορατό το όνομά τους και η ανακάλυψή τους ανακοινώνεται.', 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], @@ -322,14 +322,14 @@ const TRANSLATION = { intro: 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', - colName: 'Σύνθεση', + colName: 'Ρύθμιση', colDesc: 'Περιγραφή', perPage: '(Μπορεί να οριστεί ανά σελίδα.)', }, jumpgate: { heading: 'Jumpgate και Legacy', points: [ - 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Το Hexploration εντοπίζει ποια μηχανή χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που έχουν σχεδιαστεί σε οποιονδήποτε από τους δύο επεξεργαστές μπορούν να γεμιστούν.', 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', @@ -361,12 +361,12 @@ const TRANSLATION = { body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', colNative: 'Όνομα στη γλώσσα της', - colCode: 'Κώδικας', + colCode: 'Κωδικός', }, credits: { - heading: 'Πιστώσεις', + heading: 'Συντελεστές', original: 'Πρωτότυπο mod από', - maintainer: 'Έκδοση 2 που διατηρείται από', + maintainer: 'Η έκδοση 2 συντηρείται από', marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', support: 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', diff --git a/Hexploration/src/locales/locale/es.js b/Hexploration/src/locales/locale/es.js index 1808289dd7..bb9b497502 100644 --- a/Hexploration/src/locales/locale/es.js +++ b/Hexploration/src/locales/locale/es.js @@ -99,7 +99,7 @@ const TRANSLATION = { }, labelColor: { label: 'Color de la etiqueta', - desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + desc: 'Color de las etiquetas de nombre, visibles solo para el DJ, en los hexágonos con nombre.', }, glimpseColor: { label: 'Color de vistazo', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Ocultar fichas cubiertas', - desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + desc: 'Roll20 dibuja nombres, barras y auras sobre los hexágonos. Cuando está activado, las fichas bajo un hexágono cubierto tienen desactivados su nombre, barras y auras visibles para los jugadores, que se vuelven a activar cuando se descubren.', }, }, status: { @@ -165,22 +165,22 @@ const TRANSLATION = { revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: - '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', - resetPage: 'Hexes eliminados de la página: {count}.', + '¿Eliminar todos los hexágonos de "{page}" ({count})? Las fichas de ubicación regresan a la capa de fichas. Deshacer no puede revertir esto.', + resetPage: 'Hexágonos eliminados de la página: {count}.', undone: 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nombres borrados: {count}.', marked: 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', - unmarked: 'Tokens que ya no son ubicaciones: {count}.', + unmarked: 'Fichas que ya no son ubicaciones: {count}.', settingChanged: '{setting} establecido en {value}.', rescanned: - 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + 'Nuevo escaneo completado. Conservados: {kept}. Adoptados: {adopted}. Reubicados: {moved}. Desaparecidos y olvidados: {dropped}. Etiquetas vinculadas de nuevo: {labels}. Fichas de ubicación vinculadas de nuevo: {icons}.', calibrated: - 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', calibrationReset: - 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Se eliminó la calibración. Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', @@ -203,7 +203,7 @@ const TRANSLATION = { tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', - noTokens: 'Seleccione uno o más tokens primero.', + noTokens: 'Seleccione una o más fichas primero.', noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', nothingToUndo: 'No hay ningún relleno que deshacer.', unknownCommand: 'Comando desconocido: {command}', @@ -228,32 +228,32 @@ const TRANSLATION = { unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', calibrateNeedsTokens: - 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', calibrateFailed: - 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + 'Las dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hexágono.', unexpected: 'Los detalles se encuentran en el registro de la consola API.', }, help: { menu: 'Mostrar el menú.', fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', - undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + undo: 'Deshace el último relleno, relleno inverso u ocultación, y restaura las formas que usó.', reveal: 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', revealPage: 'Revela cada hexágono de la página sin anuncios.', conceal: 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', - explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + explore: 'Revela alrededor de las fichas seleccionadas como si acabaran de moverse allí.', resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', - unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + unmark: 'Hace que las fichas seleccionadas dejen de ser ubicaciones ocultas.', set: 'Cambie una configuración o muestre todas las configuraciones.', pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: - 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas ajustadas a los centros de los hexágonos.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', @@ -277,7 +277,7 @@ const TRANSLATION = { footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', overview: { heading: 'Descripción general', - body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + body: 'Hexploration cubre un mapa hexagonal con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', demo: 'Vea una breve demostración (de la versión 1)', }, quickStart: { @@ -286,22 +286,22 @@ const TRANSLATION = { 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', - 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Opcional: antes de rellenar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Quedan ocultas debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], }, commands: { heading: 'Comandos', intro: - 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', - colCommand: 'Dominio', - colDesc: 'que hace', + 'Solo los DJ pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Comando', + colDesc: 'Qué hace', }, revealing: { heading: 'Cómo funciona la revelación', points: [ 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', - 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrada, incluidos los puntos de ruta.', 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', @@ -313,8 +313,8 @@ const TRANSLATION = { heading: 'Hexágonos y ubicaciones con nombre', points: [ 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', - 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', - 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando rellenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa del DJ. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], @@ -323,13 +323,13 @@ const TRANSLATION = { heading: 'Ajustes', intro: 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', - colKey: 'Llave', + colKey: 'Clave', colName: 'Configuración', colDesc: 'Descripción', perPage: '(Se puede configurar por página).', }, jumpgate: { - heading: 'Jumpgate y legado', + heading: 'Jumpgate y Legacy', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', diff --git a/Hexploration/src/locales/locale/fi.js b/Hexploration/src/locales/locale/fi.js index 09b4f033a7..9056ed9aa1 100644 --- a/Hexploration/src/locales/locale/fi.js +++ b/Hexploration/src/locales/locale/fi.js @@ -91,15 +91,15 @@ const TRANSLATION = { }, fillColor: { label: 'Täyttöväri', - desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + desc: 'Uusien heksojen väri. Käytä rgba()-funktiota läpikuultaville heksoille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { label: 'Reunan väri', - desc: 'Uusien kuusioiden ääriviivan väri.', + desc: 'Uusien heksojen ääriviivan väri.', }, labelColor: { label: 'Nimilappujen väri', - desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + desc: 'Vain GM:n näkemien nimilappujen väri nimetyissä heksoissa.', }, glimpseColor: { label: 'Vilkaisun väri', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Paljasta reitin varrelta', - desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + desc: 'Kun se on päällä, jokainen heksa, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { label: 'Paljastavat merkit', - desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + desc: 'Mitkä merkkitason merkit paljastavat heksoja: pelaajan hallitsemat merkit, mitä tahansa hahmoa edustavat merkit tai kaikki merkit.', }, revealMode: { label: 'Paljastustila', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Piilota peitetyt merkit', - desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + desc: 'Roll20 piirtää nimet, palkit ja aurat heksojen päälle. Kun se on päällä, peitetyn heksan alla olevien merkkien pelaajille näkyvä nimi, palkit ja aurat kytketään pois päältä ja takaisin päälle, kun merkit paljastuvat.', }, }, status: { @@ -165,22 +165,22 @@ const TRANSLATION = { revealed: 'Heksat paljastettiin: {count}.', revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', confirmReset: - 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', - resetPage: 'Heksit poistettu sivulta: {count}.', + 'Poistetaanko kaikki heksat sivulta "{page}" ({count})? Sijaintimerkit palaavat merkkitasolle. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Sivulta poistetut heksat: {count}.', undone: - 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', - named: 'Heksaalit nimeltä "{name}": {count}.', + 'Viimeinen täyttö kumottu. Poistetut heksat: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksat nimeltä "{name}": {count}.', unnamed: 'Poistetut nimet: {count}.', marked: - 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', - unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + 'Olemassa oleviin heksoihin piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Merkit, jotka eivät ole enää sijainteja: {count}.', settingChanged: '{setting} asetettu arvoon {value}.', rescanned: - 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Otettu käyttöön: {adopted}. Sijoitettu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt nimilaput: {labels}. Uudelleen linkitetyt sijaintimerkit: {icons}.', calibrated: - 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Ruudukko kalibroitu (sarakeaskel {colStep}px, riviaskel {rowStep}px). Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', calibrationReset: - 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Kalibrointi poistettu. Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', @@ -191,26 +191,27 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + 'Tämä peli ei tue piirtämistä etualan tasolle, joten heksat piirrettiin merkkitasolle.', someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', }, errors: { noPage: 'Työstettävää sivua ei löytynyt.', - notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + notHex: 'Tämä sivu ei käytä heksaruudukkoa.', noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', - nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat heksat, piirretyt muodot tai merkit.', noTokens: 'Valitse ensin yksi tai useampi merkki.', - noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova merkki).', nothingToUndo: 'Kumoavaa täyttöä ei ole.', unknownCommand: 'Tuntematon komento: {command}', unknownSetting: 'Tuntematon asetus: {key}', unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', - calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', - calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + calibrateNeedsTokens: + 'Valitse yksi tai kaksi merkkiä, jotka on kiinnitetty heksojen keskipisteisiin.', + calibrateFailed: 'Näitä merkkejä ei voi käyttää kalibrointiin.', unexpected: 'Jotain meni pieleen: {message}', }, hints: { @@ -221,36 +222,36 @@ const TRANSLATION = { emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', noHexes: - 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + 'Heksat ovat etualan tasolla tai merkkitasolla; vaihda kyseiselle tasolle valitaksesi ne.', unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: - 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + 'Kahden merkin on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', }, help: { menu: 'Näytä valikko.', - fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fill: 'Peitä valitut piirretyt muodot heksoilla.', fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', - undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', - reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', - revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', - conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai peitto ja palauta sen käyttämät muodot.', + reveal: 'Paljasta valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun kaikki heksat ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen heksoilla.', explore: - 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', - resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + 'Paljasta valittujen merkkien ympäristö ikään kuin ne olisivat juuri siirtyneet sinne.', + resetPage: 'Poista sivulta kaikki heksat (kysyy ensin).', name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', - mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', - unmark: 'Estä valittujen merkkien piilottaminen.', + mark: 'Muuta valitut merkit piilotetuiksi sijainneiksi.', + unmark: 'Lopeta valittujen merkkien käyttö piilotettuina sijainteina.', set: 'Muuta asetusta tai näytä kaikki asetukset.', pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: - 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + 'Kohdista heksaruudukko yhteen tai kahteen valittuun merkkiin, jotka on kiinnitetty heksojen keskipisteisiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', @@ -270,11 +271,11 @@ const TRANSLATION = { }, handout: { versionLabel: 'Versio', - subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + subtitle: 'Tutkimista heksa kerrallaan Roll20:lle', footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', overview: { heading: 'Yleiskatsaus', - body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + body: 'Hexploration peittää heksakartan läpinäkymättömillä heksoilla. Kun seurue liikkuu, heksat, joiden läpi se kulkee (ja halutessasi sen ympärillä olevat heksat), poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V)- ja Hex (H) -ruudukoissa.', demo: 'Katso lyhyt esittely (versiosta 1)', }, quickStart: { @@ -288,7 +289,7 @@ const TRANSLATION = { ], }, commands: { - heading: 'komennot', + heading: 'Komennot', intro: 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', colCommand: 'Komento', @@ -307,11 +308,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Nimetty Heksit ja sijainnit', + heading: 'Nimetyt heksat ja sijainnit', points: [ 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', - 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', - 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Valkoisen tornin tilamerkillä varustetut merkit käsitellään myös sijainteina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintimerkit siirretään GM-tasolle. Kun niiden heksa paljastetaan, ne palaavat merkkitasolle nimi näkyvissä, ja niiden löytymisestä ilmoitetaan.', 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], diff --git a/Hexploration/src/locales/locale/fr.js b/Hexploration/src/locales/locale/fr.js index 0ea43abbc0..48f1c39578 100644 --- a/Hexploration/src/locales/locale/fr.js +++ b/Hexploration/src/locales/locale/fr.js @@ -99,7 +99,7 @@ const TRANSLATION = { }, labelColor: { label: "Couleur de l'étiquette", - desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + desc: 'Couleur des étiquettes de nom réservées au MJ sur les hexagones nommés.', }, glimpseColor: { label: "Couleur d'aperçu", @@ -107,7 +107,7 @@ const TRANSLATION = { }, strokeWidth: { label: 'Largeur de la bordure', - desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + desc: 'Largeur du contour des nouveaux hexagones, en pixels (0 à 20).', }, maxDistance: { label: 'Distance de révélation des hexagones', @@ -123,7 +123,7 @@ const TRANSLATION = { }, revealPath: { label: 'Révéler le long du chemin', - desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les points de passage) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { label: 'Jetons révélateurs', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Masquer les jetons couverts', - desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsque cette option est activée, les jetons situés sous un hexagone couvert ont leur nom visible par les joueurs, leurs barres et leurs auras désactivés, puis réactivés lorsqu'ils sont découverts.", }, }, status: { @@ -162,21 +162,21 @@ const TRANSLATION = { messages: { filled: 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', - revealed: 'Hexs révélés : {count}.', + revealed: 'Hexagones révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: - 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', - resetPage: 'Hexs supprimés de la page : {count}.', + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent sur le calque des jetons. Annuler le remplissage ne pourra pas revenir sur cette action.', + resetPage: 'Hexagones supprimés de la page : {count}.', undone: - 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', - named: 'Hexs nommés "{name}" : {count}.', + 'Dernier remplissage annulé. Hexagones supprimés : {removed}. Hexagones restylés restaurés : {restored}.', + named: 'Hexagones nommés "{name}" : {count}.', unnamed: 'Noms effacés : {count}.', marked: - 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + 'Emplacements cachés dans les hexagones existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', settingChanged: '{setting} défini sur {value}.', rescanned: - 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + "Nouvelle analyse terminée. Conservés : {kept}. Adoptés : {adopted}. Reclassés : {moved}. Manquants et oubliés : {dropped}. Libellés réassociés : {labels}. Jetons d'emplacement réassociés : {icons}.", calibrated: 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', calibrationReset: @@ -185,7 +185,7 @@ const TRANSLATION = { migrated: "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", pruned: - "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + "Hexagones enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, @@ -193,11 +193,11 @@ const TRANSLATION = { foregroundUnavailable: 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', someFailed: - "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + "Hexagones qui n'ont pas pu être dessinés : {count}. Consultez la console API pour plus de détails.", }, errors: { noPage: 'Impossible de trouver la page sur laquelle travailler.', - notHex: "Cette page n'utilise pas de grille hexadécimale.", + notHex: "Cette page n'utilise pas de grille hexagonale.", noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", @@ -230,21 +230,21 @@ const TRANSLATION = { calibrateNeedsTokens: "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", calibrateFailed: - "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + "Les deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hexagone l'un de l'autre.", unexpected: 'Les détails se trouvent dans le journal de la console API.', }, help: { menu: 'Afficher le menu.', fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", - undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + undo: "Annulez le dernier remplissage, remplissage inversé ou masquage, et restaurez les formes qu'il a utilisées.", reveal: 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', revealPage: 'Révélez chaque hexagone de la page sans annonce.', conceal: 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", - resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + resetPage: 'Supprimez tous les hexagones de la page (avec confirmation).', name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", mark: 'Transformez les jetons sélectionnés en emplacements cachés.', unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", @@ -252,7 +252,7 @@ const TRANSLATION = { pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', pageClear: 'Supprimez les remplacements de la page actuelle.', rescan: - 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + 'Reconstruisez la liste des hexagones de la page, par exemple après avoir copié une page ou un jeu.', calibrate: 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', @@ -269,16 +269,16 @@ const TRANSLATION = { locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: - 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + 'Paramètres, remplacements de page, statut, nouvelle analyse des pages copiées et calibrage de la grille.', footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', }, handout: { versionLabel: 'Version', - subtitle: 'Exploration hex par hex pour Roll20', + subtitle: 'Exploration hexagone par hexagone pour Roll20', footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', overview: { - heading: 'Aperçu', - body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + heading: "Vue d'ensemble", + body: "Hexploration recouvre une carte hexagonale d'hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", demo: 'Regardez une courte démo (à partir de la version 1)', }, quickStart: { @@ -288,7 +288,7 @@ const TRANSLATION = { 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", - "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + "Déplacez un jeton de joueur. Chaque hexagone qu'il traverse, ainsi que les hexagones situés dans sa Distance de vue, sont révélés.", ], }, commands: { @@ -302,7 +302,7 @@ const TRANSLATION = { heading: 'Comment fonctionne la révélation', points: [ 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', - "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + "Un jeton révèle chaque hexagone qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hexagone du trajet le long duquel il a été déplacé, y compris les points de passage.", "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", @@ -311,11 +311,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Hexs et emplacements nommés', + heading: 'Hexagones nommés et emplacements', points: [ "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', - "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Les jetons d'emplacement cachés sont déplacés vers le calque MJ. Lorsque leur hexagone est révélé, ils retournent sur le calque des jetons avec leur nom affiché et leur découverte est annoncée.", "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], @@ -330,7 +330,7 @@ const TRANSLATION = { perPage: '(Peut être défini par page.)', }, jumpgate: { - heading: 'Jumpgate et héritage', + heading: 'Jumpgate et Legacy', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", @@ -353,8 +353,8 @@ const TRANSLATION = { heading: 'Dépannage', points: [ 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', - 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', - "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + 'Les hexagones sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexagones répartis sur la carte.', + "Les hexagones ne sont plus révélés après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], diff --git a/Hexploration/src/locales/locale/he.js b/Hexploration/src/locales/locale/he.js index d7d5eee2cd..27841134d5 100644 --- a/Hexploration/src/locales/locale/he.js +++ b/Hexploration/src/locales/locale/he.js @@ -87,19 +87,19 @@ const TRANSLATION = { }, hexLayer: { label: 'שכבת המשושים', - desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים), ואם המשחק אינו תומך בה, משתמש בשכבת האסימונים.', }, fillColor: { label: 'צבע מילוי', - desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + desc: 'צבע המשושים החדשים. השתמש ב-rgba() למשושים שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { label: 'צבע מסגרת', - desc: 'צבע קווי המתאר של משושות חדשות.', + desc: 'צבע קווי המתאר של משושים חדשים.', }, labelColor: { label: 'צבע תווית', - desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + desc: 'צבע תוויות השם, הגלויות ל-GM בלבד, על משושים בעלי שם.', }, glimpseColor: { label: 'צבע הצצה', @@ -163,45 +163,45 @@ const TRANSLATION = { filled: 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', revealed: 'נחשפו משושים: {count}.', - revealedPage: 'כל hex בדף נחשף ({count}).', + revealedPage: 'כל המשושים בדף נחשפו ({count}).', confirmReset: - 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', - resetPage: 'הקסים הוסרו מהדף: {count}.', - undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', - named: 'hexes בשם "{name}": {count}.', + 'להסיר את כל המשושים מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימונים. לא ניתן לבטל את זה.', + resetPage: 'משושים שהוסרו מהדף: {count}.', + undone: + 'המילוי האחרון בוטל. משושים שהוסרו: {removed}. משושים ששוחזר עיצובם המקורי: {restored}.', + named: 'משושים בשם "{name}": {count}.', unnamed: 'שמות נוקו: {count}.', - marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + marked: 'מיקומים שהוסתרו במשושים קיימים: {attached}. ממתינים למילוי הבא שיכסה אותם: {pending}.', unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', settingChanged: '{setting} מוגדר ל-{value}.', rescanned: - 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + 'הסריקה מחדש הושלמה. נשמרו: {kept}. אומצו: {adopted}. שויכו מחדש: {moved}. חסרים ונשכחו: {dropped}. תוויות שקושרו מחדש: {labels}. אסימוני מיקום שקושרו מחדש: {icons}.', calibrated: - 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', - calibrationReset: - 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + 'הרשת כוילה (מרווח עמודות {colStep}px, מרווח שורות {rowStep}px). סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', + calibrationReset: 'הכיול הוסר. סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: - 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי לאתר שוב את המשושים שלו.', readyHint: 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: - 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', - someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + 'משחק זה אינו תומך בציור על שכבת החזית, ולכן המשושים צוירו על שכבת האסימונים.', + someFailed: 'משושים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', }, errors: { noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', - notHex: 'דף זה אינו משתמש ברשת משושה.', + notHex: 'דף זה אינו משתמש ברשת משושים.', noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', - emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', - tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי משושים.', + tooMany: 'זה ייצור יותר מדי משושים בבת אחת ({count}).', nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', noTokens: 'תחילה בחר אסימון אחד או יותר.', - noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + noHexes: 'בחר תחילה משושה אחד או יותר (או אסימונים העומדים על משושים).', nothingToUndo: 'אין מילוי לבטל.', unknownCommand: 'פקודה לא ידועה: {command}', unknownSetting: 'הגדרה לא ידועה: {key}', @@ -213,38 +213,38 @@ const TRANSLATION = { }, hints: { noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', - notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + notHex: 'הגדר את רשת הדף ל-Hex (V) או Hex (H) בהגדרות הדף.', noPolygons: 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', - emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות הרשת של הדף.', tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', calibrateNeedsTokens: - 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שהוצמד למשושה סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', calibrateFailed: - 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + 'שני האסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), במרחק של משושה אחד לפחות זה מזה.', unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', }, help: { menu: 'הצג את התפריט.', - fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fill: 'כסה את הצורות המצוירות שנבחרו במשושים.', fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', - undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + undo: 'בטל את המילוי, המילוי ההפוך או ההסתרה האחרונים, ושחזר את הצורות שבהן נעשה שימוש.', reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', - revealPage: 'חשוף כל קסם בדף ללא הודעות.', - conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + revealPage: 'חשוף את כל המשושים בדף ללא הכרזות.', + conceal: 'כסה שוב במשושים את השטח שמתחת לצורות ולאסימונים שנבחרו.', explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', - resetPage: 'הסר כל hex בדף (שואל תחילה).', - name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + resetPage: 'הסר את כל המשושים בדף (מבקש אישור תחילה).', + name: 'תן שם למשושים שנבחרו, או למשושים שמתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', - unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + unmark: 'הפסק להתייחס לאסימונים שנבחרו כמיקומים מוסתרים.', set: 'שנה הגדרה או הצג את כל ההגדרות.', pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', pageClear: 'הסר את העקיפות של הדף הנוכחי.', - rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', - calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + rescan: 'בנה מחדש את רשימת המשושים של הדף, למשל לאחר העתקת דף או משחק.', + calibrate: 'יישר את רשת המשושים לפי אסימון אחד או שניים שנבחרו ומוצמדים למרכזי משושים.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', @@ -262,7 +262,7 @@ const TRANSLATION = { }, handout: { versionLabel: 'גִרְסָה', - subtitle: 'חקירה משושה אחר קסם עבור Roll20', + subtitle: 'חקירה משושה אחר משושה עבור Roll20', footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', @@ -287,7 +287,7 @@ const TRANSLATION = { colDesc: 'מה זה עושה', }, revealing: { - heading: 'איך עובד גילוי', + heading: 'איך החשיפה עובדת', points: [ 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', @@ -299,11 +299,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'בשם משושים ומיקומים', + heading: 'משושים בעלי שם ומיקומים', points: [ 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', - 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'אסימוני מיקום מוסתרים מועברים לשכבת ה-GM. כאשר המשושה שלהם נחשף הם חוזרים לשכבת האסימונים כששמם מוצג, והגילוי שלהם מוכרז.', 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], @@ -313,7 +313,7 @@ const TRANSLATION = { intro: 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', - colName: 'סְבִיבָה', + colName: 'הגדרה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, @@ -327,15 +327,15 @@ const TRANSLATION = { ], }, upgrading: { - heading: 'משדרג מגרסה 1', + heading: 'שדרוג מגרסה 1', points: [ 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', - 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'מפות משושים קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהפעלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], - colV1: 'פקודה גרסה 1', - colV2: 'פקודה גרסה 2', + colV1: 'פקודה בגרסה 1', + colV2: 'פקודה בגרסה 2', }, troubleshooting: { heading: 'פתרון בעיות', @@ -343,7 +343,7 @@ const TRANSLATION = { 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', - 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'מילוי אומר שלאזור אין מרכזי משושים: הצורה חייבת להכיל את המרכז של משושה אחד לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], }, diff --git a/Hexploration/src/locales/locale/hu.js b/Hexploration/src/locales/locale/hu.js index c033514743..1f08ee11e6 100644 --- a/Hexploration/src/locales/locale/hu.js +++ b/Hexploration/src/locales/locale/hu.js @@ -91,7 +91,7 @@ const TRANSLATION = { }, fillColor: { label: 'Kitöltés színe', - desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + desc: 'Új hatszögek színe. Áttetsző hatszögekhez használjon rgba()-t, például rgba(0,0,0,0.8).', }, strokeColor: { label: 'Szegély színe', @@ -99,7 +99,7 @@ const TRANSLATION = { }, labelColor: { label: 'Címke színe', - desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + desc: 'A csak GM-nek szánt névcímkék színe az elnevezett hatszögeken.', }, glimpseColor: { label: 'Bepillantás színe', @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Látótávolság', - desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + desc: 'Hány hatszög fedődik fel egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket fedi fel, amelyeken a token áthalad.', }, lineOfSight: { label: 'Látóvonal', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Felfedés az útvonal mentén', - desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + desc: 'Ha be van kapcsolva, minden hatszög felfedődik, amelyen a token a húzás közben áthalad (az útpontokat is beleértve), nem csak az, ahol megáll.', }, revealBy: { label: 'Felfedő tokenek', - desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + desc: 'Mely tokenek fedik fel a hatszögeket a tokenrétegen: a játékos által irányított tokenek, a bármely karaktert ábrázoló tokenek vagy minden token.', }, revealMode: { label: 'Felfedési mód', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Lefedett tokenek elrejtése', - desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + desc: 'A Roll20 a neveket, sávokat és aurákat a hatszögek fölé rajzolja. Ha be van kapcsolva, a lefedett hatszög alatti tokenek játékosok által látható neve, sávjai és aurái kikapcsolnak, majd a tokenek felfedésekor újra bekapcsolnak.', }, }, status: { @@ -163,25 +163,25 @@ const TRANSLATION = { filled: 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', revealed: 'Felfedezett hatszögek: {count}.', - revealedPage: 'Az oldalon minden hex látható ({count}).', + revealedPage: 'Az oldal minden hatszöge felfedve ({count}).', confirmReset: - 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + 'Eltávolítja az összes hatszöget innen: „{page}” ({count})? A helyszíntokenek visszakerülnek a tokenrétegre. A visszavonás ezt nem tudja visszafordítani.', resetPage: 'Az oldalról eltávolított hatszögek: {count}.', undone: 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', named: '"{name}" nevű hatszögek: {count}.', unnamed: 'Törölt nevek: {count}.', marked: - 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + 'Meglévő hatszögekben rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', unmarked: 'Tokenek, amelyek már nem helyek: {count}.', settingChanged: '{setting} értéke {value}.', rescanned: - 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Áthelyezve: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', calibrated: - 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', calibrationReset: - 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', - journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', + journalRebuilt: 'A(z) „{help}” és „{deck}” tájékoztató újra elkészült.', migrated: 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: @@ -191,26 +191,26 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + 'Ez a játék nem támogatja az előtérrétegre való rajzolást, ezért a hatszögek a tokenrétegre kerültek.', someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', }, errors: { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', - notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + notHex: 'Ez az oldal nem használ hatszögrácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', - tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', - nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + tooMany: 'Ez túl sok hatszöget hozna létre egyszerre ({count}).', + nothingToConceal: 'Jelölje ki az elrejtendő rajzolt alakzatokat vagy tokeneket.', nothingToReveal: - 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + 'Válassza ki a hatszögeket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', noTokens: 'Először válasszon ki egy vagy több tokent.', - noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + noHexes: 'Először jelöljön ki egy vagy több hatszöget (vagy hatszögön álló tokent).', nothingToUndo: 'Nincs visszavonható kitöltés.', unknownCommand: 'Ismeretlen parancs: {command}', unknownSetting: 'Ismeretlen beállítás: {key}', unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', - calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateNeedsTokens: 'Jelöljön ki egy vagy két, hatszögközéppontra illesztett tokent.', calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', unexpected: 'Hiba történt: {message}', }, @@ -233,17 +233,16 @@ const TRANSLATION = { }, help: { menu: 'Mutasd a menüt.', - fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fill: 'Fedje le a kijelölt rajzolt alakzatokat hatszögekkel.', fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', reveal: 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', - revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', - conceal: - 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + revealPage: 'Fedjen fel minden hatszöget az oldalon bejelentések nélkül.', + conceal: 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögekkel.', explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', - resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', - name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + resetPage: 'Távolítson el minden hatszöget az oldalon (először rákérdez).', + name: 'Nevezze el a kijelölt hatszögeket vagy a kijelölt tokenek alatti hatszögeket. A név törléséhez hagyja üresen.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', @@ -251,7 +250,7 @@ const TRANSLATION = { pageClear: 'Távolítsa el az aktuális oldal felülírásait.', rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: - 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + 'Igazítsa a hatszögrácsot egy vagy két kijelölt, hatszögközéppontra illesztett tokenhez.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', @@ -264,24 +263,24 @@ const TRANSLATION = { revealDesc: 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: - 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + 'Jelöljön ki tokeneket, hogy helyszínként elrejtse őket a hatszögek alatt. Jelöljön ki hatszögeket vagy tokeneket egy hatszög elnevezéséhez.', toolsDesc: 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', }, handout: { versionLabel: 'Változat', - subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + subtitle: 'Hatszögről hatszögre haladó felfedezés a Roll20-hoz', footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', - demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verzióból)', }, quickStart: { heading: 'Gyors kezdés', steps: [ - 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Nyisson meg egy oldalt, amelynek rácsa Hex (V) vagy Hex (H) beállítású.', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', @@ -308,20 +307,20 @@ const TRANSLATION = { ], }, locations: { - heading: 'Hexák és helyek neve', + heading: 'Elnevezett hatszögek és helyszínek', points: [ 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', - 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük felfedődik, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { - heading: 'Beállítások elemre', + heading: 'Beállítások', intro: 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', - colKey: 'Kulcsfontosságú', + colKey: 'Kulcs', colName: 'Beállítás', colDesc: 'Leírás', perPage: '(Oldalonként beállítható.)', @@ -329,7 +328,7 @@ const TRANSLATION = { jumpgate: { heading: 'Jumpgate és Legacy', points: [ - 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'A Hexploration megállapítja, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', @@ -338,8 +337,8 @@ const TRANSLATION = { upgrading: { heading: 'Frissítés az 1-es verzióról', points: [ - 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', - 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML Builderre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hatszögtérképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], @@ -353,7 +352,7 @@ const TRANSLATION = { 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', - 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + 'Minden más esetben ellenőrizze az API-konzol naplóját, és segítségkéréskor mellékelje az üzeneteit.', ], }, languages: { @@ -364,12 +363,12 @@ const TRANSLATION = { colCode: 'Kód', }, credits: { - heading: 'Kredit', + heading: 'Készítők', original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: - 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + 'Ha hibát talál, vagy ötlete van, írjon a Roll20 Mod fórumba, vagy nyisson hibajegyet a GitHubon, és mellékelje az API-konzol naplójának üzeneteit.', }, }, }; diff --git a/Hexploration/src/locales/locale/it.js b/Hexploration/src/locales/locale/it.js index 90b582e9e3..2fdec6369d 100644 --- a/Hexploration/src/locales/locale/it.js +++ b/Hexploration/src/locales/locale/it.js @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Rivela lungo il percorso', - desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un segnalino mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', }, revealBy: { label: 'Segnalini che rivelano', - desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + desc: 'Quali segnalini sul livello dei segnalini rivelano esagoni: segnalini controllati da un giocatore, segnalini che rappresentano qualsiasi personaggio o tutti i segnalini.', }, revealMode: { label: 'Modalità di rivelazione', @@ -139,11 +139,11 @@ const TRANSLATION = { }, pingDiscoveries: { label: 'Ping sulle scoperte', - desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + desc: 'Quando è attivo, i giocatori ricevono un ping su una posizione con nome quando viene scoperta.', }, hideCoveredTokens: { label: 'Nascondi i segnalini coperti', - desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando è attivo, i segnalini sotto un esagono coperto hanno il nome visibile ai giocatori, le barre e le aure disattivati, e riattivati quando vengono scoperti.', }, }, status: { @@ -161,11 +161,11 @@ const TRANSLATION = { }, messages: { filled: - 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + 'Riempimento completato. Esagoni tracciati: {created}. Con stile aggiornato: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: - 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + 'Rimuovere ogni esagono da "{page}" ({count})? I segnalini di posizione tornano al livello dei segnalini. Annulla riempimento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', undone: 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', @@ -173,14 +173,14 @@ const TRANSLATION = { unnamed: 'Nomi cancellati: {count}.', marked: 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', - unmarked: 'Token che non rappresentano più posizioni: {count}.', + unmarked: 'Segnalini che non rappresentano più posizioni: {count}.', settingChanged: '{setting} impostato su {value}.', rescanned: - 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + 'Nuova scansione completata. Conservati: {kept}. Adottati: {adopted}. Ricollocati: {moved}. Mancanti e dimenticati: {dropped}. Etichette ricollegate: {labels}. Segnalini di posizione ricollegati: {icons}.', calibrated: - 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', calibrationReset: - 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Calibrazione rimossa. Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', @@ -191,7 +191,7 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei segnalini.', someFailed: 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', }, @@ -201,17 +201,17 @@ const TRANSLATION = { noPolygons: 'Seleziona una o più forme disegnate da riempire.', emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', - nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', - nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', - noTokens: 'Seleziona prima uno o più token.', - noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToConceal: 'Seleziona forme disegnate o segnalini da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o segnalini da rivelare.', + noTokens: 'Seleziona prima uno o più segnalini.', + noHexes: 'Seleziona prima uno o più esagoni (o segnalini che si trovano sugli esagoni).', nothingToUndo: "Non c'è nessun riempimento da annullare.", unknownCommand: 'Comando sconosciuto: {command}', unknownSetting: 'Impostazione sconosciuta: {key}', unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', invalidValue: '"{value}" non è un valore valido per {key}.', - calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', - calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + calibrateNeedsTokens: 'Seleziona uno o due segnalini agganciati ai centri degli esagoni.', + calibrateFailed: 'Questi segnalini non possono essere utilizzati per calibrare.', unexpected: 'Qualcosa è andato storto: {message}', }, hints: { @@ -223,40 +223,41 @@ const TRANSLATION = { 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", noHexes: - 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + 'Gli esagoni si trovano sul livello in primo piano o sul livello dei segnalini; passa a quel livello per selezionarli.', unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: - 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + 'I due segnalini devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', }, help: { menu: 'Mostra il menù.', fill: 'Copri le forme disegnate selezionate con esagoni.', fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", - undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", - reveal: 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + undo: "Annulla l'ultimo riempimento, riempimento inverso o occultamento e ripristina le forme che ha usato.", + reveal: + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i segnalini selezionati.', revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', - conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", - explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + conceal: "Copri nuovamente con esagoni l'area sotto le forme e i segnalini selezionati.", + explore: 'Rivela attorno ai segnalini selezionati come se si fossero appena spostati lì.', resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', - name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', - mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', - unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i segnalini selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i segnalini selezionati in posizioni nascoste.', + unmark: 'Fai in modo che i segnalini selezionati non siano più posizioni nascoste.', set: "Modifica un'impostazione o mostra tutte le impostazioni.", - pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageSet: "Sostituisci un'impostazione di rivelazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: - 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + 'Allinea la griglia esagonale con uno o due segnalini selezionati agganciati ai centri degli esagoni.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', - handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + handout: 'Le istruzioni complete si trovano nella dispensa "{name}".', }, deck: { drawDesc: @@ -264,18 +265,18 @@ const TRANSLATION = { revealDesc: 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: - 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + 'Seleziona i segnalini per nasconderli come posizioni sotto gli esagoni. Seleziona esagoni o segnalini per nominare un esagono.', toolsDesc: 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', - footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + footer: 'Consulta la dispensa "{help}" per le istruzioni complete.', }, handout: { versionLabel: 'Versione', subtitle: 'Esplorazione esagono per esagono per Roll20', - footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + footer: 'Usa la dispensa "{deck}" per i controlli con un clic.', overview: { heading: 'Panoramica', - body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + body: 'Hexploration copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.', demo: 'Guarda una breve demo (dalla versione 1)', }, quickStart: { @@ -291,7 +292,7 @@ const TRANSLATION = { commands: { heading: 'Comandi', intro: - 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisce sulla pagina che stai visualizzando.', colCommand: 'Comando', colDesc: 'Cosa fa', }, @@ -299,7 +300,7 @@ const TRANSLATION = { heading: 'Come funziona la rivelazione', points: [ 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', - 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i punti di passaggio.', 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', @@ -311,8 +312,8 @@ const TRANSLATION = { heading: 'Esagoni e posizioni con nome', points: [ 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', - "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", - 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Anche i segnalini con l'indicatore di stato della torre bianca vengono trattati come posizioni quando riempi, come nella versione 1.", + 'I segnalini di posizione nascosti vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei segnalini con il loro nome mostrato e la loro scoperta viene annunciata.', "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], @@ -322,14 +323,14 @@ const TRANSLATION = { intro: 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', - colName: 'Collocamento', + colName: 'Impostazione', colDesc: 'Descrizione', perPage: '(Può essere impostato per pagina.)', }, jumpgate: { heading: 'Jumpgate e Legacy', points: [ - "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + 'Hexploration determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.', "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', diff --git a/Hexploration/src/locales/locale/ja.js b/Hexploration/src/locales/locale/ja.js index 878f3b33f1..30167c2880 100644 --- a/Hexploration/src/locales/locale/ja.js +++ b/Hexploration/src/locales/locale/ja.js @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: '視界距離', - desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + desc: '移動するトークンの周囲で何ヘクス先まで公開するか (0 ～ 20)。0 の場合は、トークンが通過するヘクスのみを公開します。', }, lineOfSight: { label: '視線', @@ -127,7 +127,7 @@ const TRANSLATION = { }, revealBy: { label: '公開するトークン', - desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + desc: 'トークンレイヤー上のどのトークンがヘクスを公開するか: プレイヤーが操作するトークン、いずれかのキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { label: '公開モード', @@ -139,7 +139,7 @@ const TRANSLATION = { }, pingDiscoveries: { label: '発見地点をピン', - desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + desc: 'オンにすると、名前付きの場所が発見されたときに、プレイヤーにその場所が ping されます。', }, hideCoveredTokens: { label: '覆われたトークンを隠す', @@ -161,29 +161,29 @@ const TRANSLATION = { }, messages: { filled: - '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + '塗りつぶし完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」からすべてのヘクス ({count}) を削除しますか? 場所トークンはトークンレイヤーに戻ります。「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', named: '「{name}」という名前のヘクス: {count}。', unnamed: '削除された名前: {count}。', marked: - '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + '既存のヘクスに隠された場所: {attached}。それらを覆う次の塗りつぶしを待っている場所: {pending}。', unmarked: '場所ではなくなったトークン: {count}。', settingChanged: '{setting} を {value} に設定します。', rescanned: - '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + '再スキャンが完了しました。保持: {kept}。採用: {adopted}。再配置: {moved}。見つからず破棄: {dropped}。再リンクされたラベル: {labels}。再リンクされた場所トークン: {icons}。', calibrated: - 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', calibrationReset: - 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + '調整が削除されました。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x のヘクスマップがアップグレードされました。このゲームが Legacy ゲームからコピーされた場合は、各ヘクスマップページで再スキャンを実行してください。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: @@ -199,7 +199,7 @@ const TRANSLATION = { noPage: '作業するページが見つかりませんでした。', notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', - emptyArea: '選択した領域には六角中心が含まれていません。', + emptyArea: '選択した領域にはヘクスの中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', @@ -210,7 +210,7 @@ const TRANSLATION = { unknownSetting: '不明な設定: {key}', unknownPageSetting: 'ページごとに設定できる設定: {keys}', invalidValue: '「{value}」は、{key} の有効な値ではありません。', - calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateNeedsTokens: 'ヘクスの中心にスナップされた 1 つまたは 2 つのトークンを選択します。', calibrateFailed: 'これらのトークンは調整には使用できません。', unexpected: '問題が発生しました: {message}', }, @@ -232,12 +232,12 @@ const TRANSLATION = { }, help: { menu: 'メニューを表示します。', - fill: '選択した描画形状を六角形で覆います。', + fill: '選択した描画形状をヘクスで覆います。', fillInverse: '選択した図形の内側を除いてページ全体を覆います。', - undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + undo: '最後の塗りつぶし、反転塗りつぶし、または「隠す」を元に戻し、使用した図形を復元します。', reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', - conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + conceal: '選択した図形とトークンの下の領域を再びヘクスで覆います。', explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', @@ -248,7 +248,7 @@ const TRANSLATION = { pageClear: '現在のページのオーバーライドを削除します。', rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: - '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + 'ヘクスの中心にスナップした 1 つまたは 2 つの選択トークンに、ヘクスグリッドを合わせます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', journal: 'ヘルプと Command Deck の配布資料を再構築します。', @@ -261,7 +261,7 @@ const TRANSLATION = { revealDesc: 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: - 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + 'トークンを選択すると、ヘクスの下に場所として隠せます。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', footer: '完全な手順については、配布資料「{help}」を参照してください。', }, @@ -288,11 +288,11 @@ const TRANSLATION = { heading: 'コマンド', intro: 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', - colCommand: '指示', + colCommand: 'コマンド', colDesc: '何をするのか', }, revealing: { - heading: '暴露の仕組み', + heading: '公開の仕組み', points: [ 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', @@ -307,8 +307,8 @@ const TRANSLATION = { heading: '名前付きヘクスと場所', points: [ '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', - 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', - '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'バージョン 1 と同様に、白い塔のステータスマーカーが付いたトークンも、塗りつぶすときに場所として扱われます。', + '非表示の場所トークンは GM レイヤーに移動されます。そのヘクスが公開されると、名前が表示された状態でトークンレイヤーに戻り、発見がアナウンスされます。', '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], @@ -317,7 +317,7 @@ const TRANSLATION = { heading: '設定', intro: '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', - colKey: '鍵', + colKey: 'キー', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', @@ -335,7 +335,7 @@ const TRANSLATION = { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクスマップ、名前、場所トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], diff --git a/Hexploration/src/locales/locale/ko.js b/Hexploration/src/locales/locale/ko.js index 0bd4a1eb1e..8c9bbdd4d2 100644 --- a/Hexploration/src/locales/locale/ko.js +++ b/Hexploration/src/locales/locale/ko.js @@ -95,11 +95,11 @@ const TRANSLATION = { }, strokeColor: { label: '테두리 색상', - desc: '새로운 육각형의 윤곽선 색상입니다.', + desc: '새 헥스의 윤곽선 색상입니다.', }, labelColor: { label: '라벨 색상', - desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + desc: '이름이 지정된 헥스에 표시되는 GM 전용 이름 라벨의 색상입니다.', }, glimpseColor: { label: '반투명 색상', @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: '시야 거리', - desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + desc: '움직이는 토큰 주변에서 공개되는 헥스 수입니다(0~20). 0이면 토큰이 통과하는 헥스만 공개합니다.', }, lineOfSight: { label: '시선', @@ -176,11 +176,11 @@ const TRANSLATION = { unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: - '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + '다시 스캔이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 재배치됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', calibrated: - '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '그리드가 보정되었습니다(열 간격 {colStep}px, 행 간격 {rowStep}px). 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', calibrationReset: - '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '보정이 제거되었습니다. 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', @@ -191,17 +191,17 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', - someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 헥스를 그렸습니다.', + someFailed: '그릴 수 없는 헥스: {count}. 자세한 내용은 API 콘솔을 확인하세요.', }, errors: { noPage: '작업할 페이지를 찾을 수 없습니다.', - notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + notHex: '이 페이지는 헥스 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', - nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + nothingToReveal: '공개할 헥스, 그려진 도형 또는 토큰을 선택하세요.', noTokens: '먼저 하나 이상의 토큰을 선택하세요.', noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', nothingToUndo: '실행 취소할 채우기가 없습니다.', @@ -209,7 +209,7 @@ const TRANSLATION = { unknownSetting: '알 수 없는 설정: {key}', unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', - calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateNeedsTokens: '헥스 중심에 스냅된 토큰을 하나 또는 두 개 선택하세요.', calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', unexpected: '문제가 발생했습니다: {message}', }, @@ -220,7 +220,7 @@ const TRANSLATION = { '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', - noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + noHexes: '헥스는 전경 레이어나 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: @@ -231,10 +231,10 @@ const TRANSLATION = { }, help: { menu: '메뉴를 보여주세요.', - fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fill: '선택한 그려진 도형을 헥스로 덮습니다.', fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', - undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', - reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + undo: '마지막 채우기, 반전 채우기 또는 숨기기를 취소하고, 사용한 도형을 복원합니다.', + reveal: '선택한 헥스와, 선택한 도형 및 토큰 아래의 헥스를 공개합니다.', revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', @@ -298,11 +298,11 @@ const TRANSLATION = { '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 감지됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { - heading: '명명된 육각형 및 위치', + heading: '이름 붙은 헥스와 위치', points: [ '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', @@ -315,8 +315,8 @@ const TRANSLATION = { heading: '설정', intro: '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', - colKey: '열쇠', - colName: '환경', + colKey: '키', + colName: '설정', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, @@ -355,7 +355,7 @@ const TRANSLATION = { body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', colNative: '현지어 이름', - colCode: '암호', + colCode: '코드', }, credits: { heading: '크레딧', diff --git a/Hexploration/src/locales/locale/nl.js b/Hexploration/src/locales/locale/nl.js index c4bb042a89..2fe5bfe32a 100644 --- a/Hexploration/src/locales/locale/nl.js +++ b/Hexploration/src/locales/locale/nl.js @@ -91,15 +91,15 @@ const TRANSLATION = { }, fillColor: { label: 'Vulkleur', - desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + desc: 'Kleur van nieuwe zeshoeken. Gebruik rgba() voor doorzichtige zeshoeken, bijvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randkleur', - desc: 'Kleur van de omtrek van nieuwe vakjes.', + desc: 'Kleur van de omtrek van nieuwe zeshoeken.', }, labelColor: { label: 'Labelkleur', - desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + desc: 'Kleur van de naamlabels die alleen de GM ziet, op benoemde zeshoeken.', }, glimpseColor: { label: 'Glimpkleur', @@ -107,7 +107,7 @@ const TRANSLATION = { }, strokeWidth: { label: 'Randbreedte', - desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + desc: 'Breedte van de omtrek van nieuwe zeshoeken, in pixels (0 tot 20).', }, maxDistance: { label: 'Onthullingsafstand van zeshoeken', @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Zichtafstand', - desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + desc: 'Hoeveel zeshoeken rond een bewegend token worden onthuld (0 tot 20). 0 onthult alleen de zeshoeken waar het token doorheen gaat.', }, lineOfSight: { label: 'Zichtlijn', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Onthullen langs pad', - desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke zeshoek waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { label: 'Tokens die onthullen', - desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + desc: 'Welke tokens op de tokenlaag zeshoeken onthullen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', }, revealMode: { label: 'Onthullingsmodus', @@ -135,15 +135,15 @@ const TRANSLATION = { }, announce: { label: 'Ontdekkingen aankondigen', - desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + desc: 'Wie het chatbericht ziet wanneer een benoemde locatie wordt ontdekt.', }, pingDiscoveries: { label: 'Ontdekkingen pingen', - desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een benoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { label: 'Bedekte tokens verbergen', - desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + desc: "Roll20 tekent namen, balken en aura's boven zeshoeken. Wanneer deze optie is ingeschakeld, worden de voor spelers zichtbare naam, balken en aura's van tokens onder een bedekte zeshoek uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { @@ -161,26 +161,26 @@ const TRANSLATION = { }, messages: { filled: - 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', - revealed: 'Hexen onthuld: {count}.', - revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + 'Vullen voltooid. Getekende zeshoeken: {created}. Opnieuw opgemaakt: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Zeshoeken onthuld: {count}.', + revealedPage: 'Alle zeshoeken op de pagina onthuld ({count}).', confirmReset: - 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', - resetPage: 'Hexes verwijderd van de pagina: {count}.', + 'Alle zeshoeken verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Zeshoeken verwijderd van de pagina: {count}.', undone: - 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', - named: 'Hexen met de naam "{name}": {count}.', + 'Laatste vulling ongedaan gemaakt. Zeshoeken verwijderd: {removed}. Opnieuw opgemaakte zeshoeken hersteld: {restored}.', + named: 'Zeshoeken met de naam "{name}": {count}.', unnamed: 'Namen gewist: {count}.', marked: - 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + 'Locaties verborgen in bestaande zeshoeken: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', unmarked: 'Tokens die niet langer locaties zijn: {count}.', settingChanged: '{setting} ingesteld op {value}.', rescanned: - 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + 'Opnieuw scannen voltooid. Behouden: {kept}. Overgenomen: {adopted}. Opnieuw ingedeeld: {moved}. Ontbrekend en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', calibrated: - 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', calibrationReset: - 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', @@ -191,20 +191,20 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden de zeshoeken op de tokenlaag getekend.', someFailed: - 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + 'Zeshoeken die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', }, errors: { noPage: 'Kon de pagina niet vinden om aan te werken.', notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', - emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', - tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + emptyArea: 'Het geselecteerde gebied bevat geen middelpunten van zeshoeken.', + tooMany: 'Dat zou te veel zeshoeken in één keer creëren ({count}).', nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', - nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + nothingToReveal: 'Selecteer zeshoeken, getekende vormen of tokens om te onthullen.', noTokens: 'Selecteer eerst een of meer tokens.', - noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + noHexes: 'Selecteer eerst een of meer zeshoeken (of tokens die op zeshoeken staan).', nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', unknownCommand: 'Onbekend commando: {command}', unknownSetting: 'Onbekende instelling: {key}', @@ -223,26 +223,28 @@ const TRANSLATION = { emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', noHexes: - 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + 'Zeshoeken bevinden zich op de voorgrondlaag of de tokenlaag; ga naar die laag om ze te selecteren.', unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', calibrateNeedsTokens: - 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + 'Zet een token vast op het midden van een zeshoek en selecteer het. Selecteer een tweede token dat is vastgezet op een aangrenzende zeshoek in dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', calibrateFailed: - 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', - unexpected: 'Details staan ​​in het API-consolelogboek.', + 'Twee tokens moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, minstens één zeshoek uit elkaar.', + unexpected: 'Details staan in het API-consolelogboek.', }, help: { - menu: 'Laat de menukaart zien.', - fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + menu: 'Toon het menu.', + fill: 'Bedek de geselecteerde getekende vormen met zeshoeken.', fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', - undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', - reveal: 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', - revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', - conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', - explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', - resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', - name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + undo: 'Maak de laatste vulling, omgekeerde vulling of verberging ongedaan, en herstel de gebruikte vormen.', + reveal: + 'Onthul de geselecteerde zeshoeken en de zeshoeken onder de geselecteerde vormen en tokens.', + revealPage: 'Onthul alle zeshoeken op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en tokens opnieuw met zeshoeken.', + explore: + 'Onthul de omgeving van de geselecteerde tokens alsof ze er net naartoe zijn verplaatst.', + resetPage: 'Verwijder alle zeshoeken op de pagina (vraagt eerst om bevestiging).', + name: 'Geef de geselecteerde zeshoeken een naam, of de zeshoeken onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', mark: 'Verander de geselecteerde tokens in verborgen locaties.', unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', set: 'Wijzig een instelling of toon alle instellingen.', @@ -251,7 +253,7 @@ const TRANSLATION = { rescan: 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een zeshoek zijn vastgezet.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', @@ -264,18 +266,18 @@ const TRANSLATION = { revealDesc: 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: - 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + 'Selecteer tokens om ze als locaties onder zeshoeken te verbergen. Selecteer zeshoeken of tokens om een zeshoek een naam te geven.', toolsDesc: "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", footer: 'Zie de hand-out "{help}" voor volledige instructies.', }, handout: { versionLabel: 'Versie', - subtitle: 'Hex-voor-hex verkenning voor Roll20', + subtitle: 'Verkenning zeshoek voor zeshoek in Roll20', footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', overview: { heading: 'Overzicht', - body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + body: 'Hexploration bedekt een hexkaart met ondoorzichtige zeshoeken. Terwijl het gezelschap beweegt, worden de zeshoeken waar het doorheen gaat (en, als je wilt, de zeshoeken eromheen) verwijderd, zodat de kaart zeshoek voor zeshoek wordt blootgelegd. Verborgen locaties kunnen onder zeshoeken worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V)- en Hex (H)-rasters van elke grootte.', demo: 'Bekijk een korte demo (vanaf versie 1)', }, quickStart: { @@ -308,11 +310,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Genoemde velden en locaties', + heading: 'Benoemde zeshoeken en locaties', points: [ 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', - 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Verborgen locatietokens worden verplaatst naar de GM-laag. Wanneer hun zeshoek wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], @@ -327,7 +329,7 @@ const TRANSLATION = { perPage: '(Kan per pagina worden ingesteld.)', }, jumpgate: { - heading: 'Jumpgate en erfenis', + heading: 'Jumpgate en Legacy', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', @@ -358,13 +360,13 @@ const TRANSLATION = { }, languages: { heading: 'Talen', - body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + body: 'Kies een taal met !hexploration set language. Beschikbare talen:', colLanguage: 'Taal', colNative: 'Eigen naam', colCode: 'Code', }, credits: { - heading: 'Kredieten', + heading: 'Credits', original: 'Originele mod door', maintainer: 'Versie 2 onderhouden door', marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", diff --git a/Hexploration/src/locales/locale/pl.js b/Hexploration/src/locales/locale/pl.js index 2ab6f3846f..3fd550a369 100644 --- a/Hexploration/src/locales/locale/pl.js +++ b/Hexploration/src/locales/locale/pl.js @@ -86,7 +86,7 @@ const TRANSLATION = { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa heksagonów', + label: 'Warstwa heksów', desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { @@ -99,7 +99,7 @@ const TRANSLATION = { }, labelColor: { label: 'Kolor etykiety', - desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + desc: 'Kolor etykiet z nazwami tylko dla MG na nazwanych heksach.', }, glimpseColor: { label: 'Kolor przebłysku', @@ -110,7 +110,7 @@ const TRANSLATION = { desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość odkrywania heksagonów', + label: 'Odległość odkrywania heksów', desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', }, revealDistance: { @@ -119,11 +119,11 @@ const TRANSLATION = { }, lineOfSight: { label: 'Linia wzroku', - desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', }, revealPath: { label: 'Odkrywaj wzdłuż ścieżki', - desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + desc: 'Kiedy jest włączone, odkrywany jest każdy heks, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { label: 'Żetony odkrywające', @@ -149,7 +149,7 @@ const TRANSLATION = { status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa heksagonów', + layer: 'Warstwa heksów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', @@ -161,14 +161,14 @@ const TRANSLATION = { }, messages: { filled: - 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + 'Wypełnienie zakończone. Narysowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', revealed: 'Ujawnione heksy: {count}.', - revealedPage: 'Każdy odkryty heks na stronie ({count}).', + revealedPage: 'Odkryto wszystkie heksy na stronie ({count}).', confirmReset: 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', resetPage: 'Heksy usunięte ze strony: {count}.', undone: - 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + 'Cofnięto ostatnie wypełnienie. Usunięte heksy: {removed}. Przywrócone heksy ze zmienionym stylem: {restored}.', named: 'Heksy o nazwie „{name}”: {count}.', unnamed: 'Nazwy zostały usunięte: {count}.', marked: @@ -176,11 +176,11 @@ const TRANSLATION = { unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', settingChanged: '{setting} ustawiony na {value}.', rescanned: - 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Przeniesione: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', calibrated: - 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', calibrationReset: - 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', @@ -235,7 +235,7 @@ const TRANSLATION = { menu: 'Pokaż menu.', fill: 'Zakryj wybrane narysowane kształty heksami.', fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', - undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + undo: 'Cofnij ostatnie wypełnienie, odwrotne wypełnienie lub zakrycie i przywróć użyte kształty.', reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', @@ -270,12 +270,11 @@ const TRANSLATION = { handout: { versionLabel: 'Wersja', subtitle: 'Eksploracja heks po heksie dla Roll20', - footer: - 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + footer: 'Używaj materiału informacyjnego „{deck}”, aby sterować jednym kliknięciem.', overview: { heading: 'Przegląd', - body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', - demo: 'Obejrzyj krótkie demo (od wersji 1)', + body: 'Hexploration zakrywa mapę heksową nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (z wersji 1)', }, quickStart: { heading: 'Szybki start', @@ -299,8 +298,8 @@ const TRANSLATION = { points: [ 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', - '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', - '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksów”.', + '„Odległość odkrywania heksów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', @@ -309,27 +308,27 @@ const TRANSLATION = { locations: { heading: 'Nazwane heksy i lokalizacje', points: [ - 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które go zakryje.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', - 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę MG. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z widoczną nazwą, a ich odkrycie zostaje ogłoszone.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksów” jest ustawiona na warstwę żetonów.', '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', }, jumpgate: { - heading: 'Jumpgate i Dziedzictwo', + heading: 'Jumpgate i Legacy', points: [ - 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Hexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy „Warstwa heksów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], @@ -363,7 +362,7 @@ const TRANSLATION = { colCode: 'Kod', }, credits: { - heading: 'Kredyty', + heading: 'Autorzy', original: 'Oryginalny mod autorstwa', maintainer: 'Wersja 2 obsługiwana przez', marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', diff --git a/Hexploration/src/locales/locale/pt-BR.js b/Hexploration/src/locales/locale/pt-BR.js index 64a46854af..65306dacc2 100644 --- a/Hexploration/src/locales/locale/pt-BR.js +++ b/Hexploration/src/locales/locale/pt-BR.js @@ -111,11 +111,11 @@ const TRANSLATION = { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos ao redor de um token em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', }, lineOfSight: { label: 'Linha de visão', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Revelar ao longo do caminho', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + desc: 'Quando ativado, cada hexágono pelo qual um token passa enquanto é arrastado (incluindo pontos de passagem) é revelado, não apenas onde ele para.', }, revealBy: { label: 'Tokens que revelam', - desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + desc: 'Quais tokens na camada de tokens revelam hexágonos: tokens controlados por um jogador, tokens que representam qualquer personagem ou todos os tokens.', }, revealMode: { label: 'Modo de revelação', @@ -162,7 +162,7 @@ const TRANSLATION = { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', @@ -172,15 +172,15 @@ const TRANSLATION = { named: 'Hexágonos chamados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cubra: {pending}.', unmarked: 'Tokens que não são mais locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + 'Reescaneamento concluído. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de local vinculados novamente: {icons}.', calibrated: - 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grade calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', @@ -191,7 +191,7 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + 'Este jogo não suporta desenho na camada de primeiro plano, então os hexágonos foram desenhados na camada de tokens.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', }, @@ -201,17 +201,17 @@ const TRANSLATION = { noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', - nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', - nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + nothingToConceal: 'Selecione formas desenhadas ou tokens para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou tokens para revelar.', noTokens: 'Selecione um ou mais tokens primeiro.', - noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou tokens sobre hexágonos) primeiro.', nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', - calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + calibrateFailed: 'Esses tokens não podem ser usados para calibrar.', unexpected: 'Algo deu errado: {message}', }, hints: { @@ -222,7 +222,7 @@ const TRANSLATION = { emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', tooMany: 'Preencha uma área menor ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de tokens; mude para essa camada para selecioná-los.', unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: @@ -235,10 +235,10 @@ const TRANSLATION = { menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', - reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que ele usou.', + reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e tokens selecionados.', revealPage: 'Revele cada hexágono da página sem anúncios.', - conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + conceal: 'Cubra novamente com hexágonos a área sob as formas e tokens selecionados.', explore: 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta antes).', @@ -266,7 +266,7 @@ const TRANSLATION = { locationsDesc: 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: - 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + 'Configurações, substituições de páginas, status, reescaneamento de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { @@ -308,11 +308,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Os tokens de local ocultos são movidos para a camada do GM. Quando seu hexágono é revelado, eles retornam à camada de tokens com seu nome à mostra e sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], @@ -327,7 +327,7 @@ const TRANSLATION = { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', @@ -350,7 +350,7 @@ const TRANSLATION = { heading: 'Solução de problemas', points: [ 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', - 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos estão deslocados em relação à grade: use Calibrar e depois verifique com um token em alguns hexágonos pelo mapa.', 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', @@ -359,7 +359,7 @@ const TRANSLATION = { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', - colLanguage: 'Linguagem', + colLanguage: 'Idioma', colNative: 'Nome original', colCode: 'Código', }, diff --git a/Hexploration/src/locales/locale/pt-PT.js b/Hexploration/src/locales/locale/pt-PT.js index 686aeeedd6..2d8c6283ee 100644 --- a/Hexploration/src/locales/locale/pt-PT.js +++ b/Hexploration/src/locales/locale/pt-PT.js @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos por onde a ficha passa.', }, lineOfSight: { label: 'Linha de visão', @@ -123,7 +123,7 @@ const TRANSLATION = { }, revealPath: { label: 'Revelar ao longo do percurso', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + desc: 'Quando ativado, cada hexágono por onde uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde para.', }, revealBy: { label: 'Fichas que revelam', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Ocultar fichas cobertas', - desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + desc: 'O Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, as fichas sob um hexágono coberto têm o seu nome, barras e auras visíveis para os jogadores desligados, que voltam a ser ligados quando as fichas são descobertas.', }, }, status: { @@ -162,7 +162,7 @@ const TRANSLATION = { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', @@ -172,15 +172,15 @@ const TRANSLATION = { named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', - unmarked: 'Tokens que já não são locais: {count}.', + 'Locais escondidos em hexágonos existentes: {attached}. A aguardar o próximo preenchimento que os cubra: {pending}.', + unmarked: 'Fichas que já não são locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + 'Reanálise concluída. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos novamente ligados: {labels}. Fichas de local novamente ligadas: {icons}.', calibrated: - 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grelha calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', @@ -191,7 +191,7 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que os hexágonos foram desenhados na camada de fichas.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', }, @@ -203,15 +203,15 @@ const TRANSLATION = { tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', - noTokens: 'Selecione primeiro um ou mais tokens.', + noTokens: 'Selecione primeiro uma ou mais fichas.', noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', - nothingToUndo: 'Não há enchimento para desfazer.', + nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', - calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + calibrateFailed: 'Estas fichas não podem ser utilizadas para calibrar.', unexpected: 'Algo correu mal: {message}', }, hints: { @@ -222,7 +222,7 @@ const TRANSLATION = { emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de fichas; mude para essa camada para os selecionar.', unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: @@ -235,15 +235,15 @@ const TRANSLATION = { menu: 'Mostre o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que este utilizou.', reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', explore: 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', - name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', - mark: 'Transforme os tokens selecionados em locais ocultos.', - unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob as fichas selecionadas. Deixe o nome vazio para o limpar.', + mark: 'Transforme as fichas selecionadas em locais ocultos.', + unmark: 'Faça com que as fichas selecionadas deixem de ser locais ocultos.', set: 'Altere uma definição ou mostre todas as definições.', pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', @@ -265,7 +265,7 @@ const TRANSLATION = { locationsDesc: 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: - 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + 'Definições, substituições de páginas, estado, reanálise de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { @@ -307,11 +307,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', - 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'As fichas com o marcador de estado da torre branca também são tratadas como locais quando preenche, como na versão 1.', + 'As fichas de local ocultas são movidas para a camada do GM. Quando o seu hexágono é revelado, regressam à camada de fichas com o nome visível e a sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], @@ -326,7 +326,7 @@ const TRANSLATION = { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', @@ -365,7 +365,7 @@ const TRANSLATION = { credits: { heading: 'Créditos', original: 'Mod original de', - maintainer: 'Versão 2 mantida pela', + maintainer: 'Versão 2 mantida por', marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', support: 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', diff --git a/Hexploration/src/locales/locale/ru.js b/Hexploration/src/locales/locale/ru.js index 5e2c28031c..dd9d2a34a1 100644 --- a/Hexploration/src/locales/locale/ru.js +++ b/Hexploration/src/locales/locale/ru.js @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Слой шестиугольников', + label: 'Слой гексов', desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', - desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных гексов, например rgba(0,0,0,0.8).', }, strokeColor: { label: 'Цвет границы', @@ -99,7 +99,7 @@ const TRANSLATION = { }, labelColor: { label: 'Цвет меток', - desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + desc: 'Цвет меток с именами, предназначенными только для ГМ, на именованных гексах.', }, glimpseColor: { label: 'Цвет проблеска', @@ -107,10 +107,10 @@ const TRANSLATION = { }, strokeWidth: { label: 'Ширина границы', - desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + desc: 'Ширина контура новых гексов в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Дальность раскрытия шестиугольников', + label: 'Дальность раскрытия гексов', desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Линия видимости', - desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия гексов», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', }, revealPath: { label: 'Раскрывать вдоль пути', @@ -139,11 +139,11 @@ const TRANSLATION = { }, pingDiscoveries: { label: 'Пинговать находки', - desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + desc: 'Если эта функция включена, при обнаружении именованной локации вид игроков переводится на неё.', }, hideCoveredTokens: { label: 'Скрывать токены под гексами', - desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, у токенов под закрытым гексом отключаются видимые игрокам имя, полосы и ауры, а когда токены открываются, они снова включаются.', }, }, status: { @@ -166,21 +166,21 @@ const TRANSLATION = { revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', - resetPage: 'Со страницы удалены шестигранники: {count}.', + resetPage: 'Со страницы удалены гексы: {count}.', undone: - 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', - named: 'Шестигранники с именем "{name}": {count}.', + 'Последнее заполнение отменено. Удалены гексы: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Гексы с именем "{name}": {count}.', unnamed: 'Имена удалены: {count}.', marked: 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', unmarked: 'Токены, которые больше не являются локациями: {count}.', settingChanged: 'Для {setting} установлено значение {value}.', rescanned: - 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Перенесено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', calibrated: - 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', calibrationReset: - 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', @@ -191,18 +191,18 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому гексы рисовались на слое жетонов.', someFailed: 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', }, errors: { noPage: 'Не удалось найти страницу для работы.', - notHex: 'На этой странице не используется шестигранная сетка.', + notHex: 'На этой странице не используется гексовая сетка.', noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', - emptyArea: 'Выбранная область не содержит шестигранных центров.', - tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + emptyArea: 'Выбранная область не содержит центров гексов.', + tooMany: 'Это создаст слишком много гексов за один раз ({count}).', nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', - nothingToReveal: 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + nothingToReveal: 'Выберите гексы, нарисованные фигуры или жетоны, чтобы их показать.', noTokens: 'Сначала выберите один или несколько жетонов.', noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', nothingToUndo: 'Нет заливки, которую можно было бы отменить.', @@ -210,7 +210,7 @@ const TRANSLATION = { unknownSetting: 'Неизвестная настройка: {key}.', unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', invalidValue: '«{value}» не является допустимым значением для {key}.', - calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к центрам гексов.', calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', unexpected: 'Что-то пошло не так: {message}', }, @@ -222,7 +222,7 @@ const TRANSLATION = { emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', noHexes: - 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + 'Гексы находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: @@ -233,23 +233,24 @@ const TRANSLATION = { }, help: { menu: 'Покажите меню.', - fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fill: 'Покройте выбранные нарисованные фигуры гексами.', fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', - undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + undo: 'Отмените последнюю заливку, обратную заливку или скрытие и восстановите использованные фигуры.', reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', revealPage: 'Раскройте каждый гекс на странице без объявлений.', - conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', - explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами гексами.', + explore: + 'Раскройте гексы вокруг выбранных жетонов, как будто они только что туда переместились.', resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', - pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageSet: 'Переопределить настройку раскрытия только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: - 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + 'Выровняйте гексовую сетку с помощью одного или двух выбранных жетонов, привязанных к центрам гексов.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', @@ -289,7 +290,7 @@ const TRANSLATION = { commands: { heading: 'Команды', intro: - 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + 'Только ГМ могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', colCommand: 'Команда', colDesc: 'Что он делает', }, @@ -298,8 +299,8 @@ const TRANSLATION = { points: [ 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', - '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', - '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия гексов».', + '«Дальность раскрытия гексов» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия гексов» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', @@ -310,25 +311,25 @@ const TRANSLATION = { points: [ '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', - 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', + 'Жетоны скрытых локаций перемещаются на слой ГМ. Когда их гекс раскрывается, они возвращаются на слой жетонов с показанным именем, и об их обнаружении объявляется.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой гексов» выбран слой токенов.', '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой гексов», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', perPage: '(Можно установить для каждой страницы.)', }, jumpgate: { - heading: 'Джампгейт и Наследие', + heading: 'Jumpgate и Legacy', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Если для «Слоя гексов» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], @@ -362,7 +363,7 @@ const TRANSLATION = { colCode: 'Код', }, credits: { - heading: 'Кредиты', + heading: 'Авторы', original: 'Оригинальный мод от', maintainer: 'Версия 2 поддерживается', marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', diff --git a/Hexploration/src/locales/locale/sv.js b/Hexploration/src/locales/locale/sv.js index 78aa958960..76f1bb4923 100644 --- a/Hexploration/src/locales/locale/sv.js +++ b/Hexploration/src/locales/locale/sv.js @@ -87,7 +87,7 @@ const TRANSLATION = { }, hexLayer: { label: 'Lager för hexar', - desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + desc: 'Var nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', @@ -95,11 +95,11 @@ const TRANSLATION = { }, strokeColor: { label: 'Kantfärg', - desc: 'Färg på konturerna av nya sexkanter.', + desc: 'Färg på konturerna av nya hexar.', }, labelColor: { label: 'Etikettfärg', - desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + desc: 'Färgen på namnetiketterna endast för GM på namngivna hexar.', }, glimpseColor: { label: 'Glimtfärg', @@ -107,7 +107,7 @@ const TRANSLATION = { }, strokeWidth: { label: 'Kantbredd', - desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + desc: 'Bredden på konturerna av nya hexar, i pixlar (0 till 20).', }, maxDistance: { label: 'Avslöjandeavstånd för hexar', @@ -123,11 +123,11 @@ const TRANSLATION = { }, revealPath: { label: 'Avslöja längs vägen', - desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive mellanpunkter), inte bara där den stannar.', }, revealBy: { label: 'Tokens som avslöjar', - desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + desc: 'Vilka tokens på tokenlagret som avslöjar hexar: tokens som kontrolleras av en spelare, tokens som representerar vilken rollperson som helst eller alla tokens.', }, revealMode: { label: 'Avslöjandeläge', @@ -143,7 +143,7 @@ const TRANSLATION = { }, hideCoveredTokens: { label: 'Dölj täckta tokens', - desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexarna. När den är på stängs det namn, de staplar och de auror som spelarna kan se av för tokens under en täckt hex, och slås på igen när de avtäcks.', }, }, status: { @@ -160,26 +160,27 @@ const TRANSLATION = { undo: 'Ångra tillgängligt', }, messages: { - filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', - revealed: 'Hexen avslöjade: {count}.', - revealedPage: 'Varje hex på sidan avslöjas ({count}).', + filled: + 'Fyllning klar. Ritade hexar: {created}. Omformaterade: {restyled}. Gömda platser: {icons}.', + revealed: 'Avslöjade hexar: {count}.', + revealedPage: 'Alla hexar på sidan avslöjade ({count}).', confirmReset: - 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', - resetPage: 'Hexen har tagits bort från sidan: {count}.', + 'Ta bort alla hexar från "{page}" ({count})? Platstokens återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexar som tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', - named: 'Hex med namnet "{name}": {count}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omformaterade hexar som återställts: {restored}.', + named: 'Hexar med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: - 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + 'Omsökningen är klar. Behållna: {kept}. Övertagna: {adopted}. Omplacerade: {moved}. Saknade och glömda: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', calibrated: - 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', calibrationReset: - 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', @@ -190,25 +191,25 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', - someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + 'Det här spelet stöder inte ritning på förgrundslagret, så hexarna ritades på tokenlagret.', + someFailed: 'Hexar som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', }, errors: { noPage: 'Kunde inte hitta sidan att arbeta på.', notHex: 'Den här sidan använder inte ett hex-rutnät.', noPolygons: 'Välj en eller flera ritade former att fylla.', - emptyArea: 'Det valda området innehåller inga hexa-center.', + emptyArea: 'Det valda området innehåller inga hexmittpunkter.', tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', nothingToConceal: 'Välj ritade former eller tokens att dölja.', - nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + nothingToReveal: 'Välj hexar, ritade former eller tokens att avslöja.', noTokens: 'Välj först en eller flera tokens.', - noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + noHexes: 'Välj en eller flera hexar (eller tokens som står på hexar) först.', nothingToUndo: 'Det finns ingen fyllning att ångra.', unknownCommand: 'Okänt kommando: {command}', unknownSetting: 'Okänd inställning: {key}', unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', invalidValue: '"{value}" är inte ett giltigt värde för {key}.', - calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateNeedsTokens: 'Välj en eller två tokens som är fästa i hexmittpunkter.', calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', unexpected: 'Något gick fel: {message}', }, @@ -219,7 +220,8 @@ const TRANSLATION = { 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', tooMany: 'Fyll ett mindre område, eller dela området i flera former.', - noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + noHexes: + 'Hexarna ligger på förgrundslagret eller tokenlagret; växla till det lagret för att välja dem.', unknownCommand: 'Skriv !hexploration help för att lista kommandona.', unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', calibrateNeedsTokens: @@ -230,22 +232,23 @@ const TRANSLATION = { }, help: { menu: 'Visa menyn.', - fill: 'Täck de utvalda ritade formerna med hex.', + fill: 'Täck de valda ritade formerna med hexar.', fillInverse: 'Täck hela sidan utom inuti de valda formerna.', - undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', - reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', - revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', - conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + undo: 'Ångra den senaste fyllningen, omvända fyllningen eller döljningen och återställ formerna den använde.', + reveal: 'Avslöja de valda hexarna och hexarna under de valda formerna och tokens.', + revealPage: 'Avslöja alla hexar på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och tokens med hexar igen.', explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', - resetPage: 'Ta bort varje hex på sidan (frågar först).', - name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + resetPage: 'Ta bort alla hexar på sidan (frågar först).', + name: 'Namnge de valda hexarna, eller hexarna under de valda tokens. Lämna namnet tomt för att rensa det.', mark: 'Förvandla de valda tokens till dolda platser.', unmark: 'Stoppa de valda tokens från att vara dolda platser.', set: 'Ändra en inställning eller visa alla inställningar.', pageSet: 'Åsidosätt en avslöjningsinställning endast på den aktuella sidan.', pageClear: 'Ta bort den aktuella sidans åsidosättningar.', rescan: 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', - calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrate: + 'Rikta in hex-rutnätet efter en eller två valda tokens som är fästa i hexmittpunkter.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', journal: 'Bygg om handouterna Help och Command Deck.', @@ -258,18 +261,18 @@ const TRANSLATION = { revealDesc: 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: - 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + 'Välj tokens för att dölja dem som platser under hexar. Välj hexar eller tokens för att namnge en hex.', toolsDesc: 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', footer: 'Se "{help}"-handouten för fullständiga instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-utforskning för Roll20', + subtitle: 'Utforskning hex för hex i Roll20', footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', overview: { heading: 'Översikt', - body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + body: 'Hexploration täcker en hexkarta med ogenomskinliga hexar. När sällskapet rör sig tas hexarna det passerar igenom (och, om du vill, hexarna runt det) bort, så att kartan avslöjas en hex i taget. Dolda platser kan placeras under hexar och tillkännages när de hittas. Det fungerar i Jumpgate- och Legacy-spel, på Hex (V)- och Hex (H)-rutnät av alla storlekar.', demo: 'Se en kort demo (från version 1)', }, quickStart: { @@ -278,7 +281,7 @@ const TRANSLATION = { 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', - 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De göms under hexarna och tillkännages när de upptäcks.', 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, @@ -302,11 +305,11 @@ const TRANSLATION = { ], }, locations: { - heading: 'Namngivna Hex och platser', + heading: 'Namngivna hexar och platser', points: [ 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', - 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Dolda platstokens flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med sitt namn visat, och deras upptäckt tillkännages.', 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], @@ -316,7 +319,7 @@ const TRANSLATION = { intro: 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', - colName: 'Miljö', + colName: 'Inställning', colDesc: 'Beskrivning', perPage: '(Kan ställas in per sida.)', }, @@ -344,7 +347,7 @@ const TRANSLATION = { heading: 'Felsökning', points: [ 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', - 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexarna är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', @@ -352,13 +355,13 @@ const TRANSLATION = { }, languages: { heading: 'Språk', - body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + body: 'Välj ett språk med !hexploration set language. Tillgängliga språk:', colLanguage: 'Språk', colNative: 'Eget namn', - colCode: 'Koda', + colCode: 'Kod', }, credits: { - heading: 'Krediter', + heading: 'Medverkande', original: 'Originalmod av', maintainer: 'Version 2 underhålls av', marketplace: 'Adas konstpaket på Roll20 Marketplace', diff --git a/Hexploration/src/locales/locale/tr.js b/Hexploration/src/locales/locale/tr.js index eb2e00efa8..121bf37e03 100644 --- a/Hexploration/src/locales/locale/tr.js +++ b/Hexploration/src/locales/locale/tr.js @@ -115,7 +115,7 @@ const TRANSLATION = { }, revealDistance: { label: 'Görüş Mesafesi', - desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + desc: 'Hareket eden bir jetonun çevresinde kaç altıgenin açığa çıkacağı (0 ila 20). 0 yalnızca jetonun geçtiği altıgenleri açığa çıkarır.', }, lineOfSight: { label: 'Görüş Hattı', @@ -123,7 +123,7 @@ const TRANSLATION = { }, revealPath: { label: 'Yol Boyunca Açığa Çıkar', - desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + desc: 'Açık olduğunda, bir jetonun yalnızca durduğu yer değil, sürüklenirken geçtiği her altıgen (ara noktalar dahil) açığa çıkar.', }, revealBy: { label: 'Açığa Çıkaran Jetonlar', @@ -139,11 +139,11 @@ const TRANSLATION = { }, pingDiscoveries: { label: 'Keşifleri Pingle', - desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + desc: 'Açık olduğunda, adlandırılmış bir konum keşfedildiğinde oyunculara o konuma ping atılır.', }, hideCoveredTokens: { label: 'Örtülü Jetonları Gizle', - desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + desc: 'Roll20 adları, çubukları ve auraları altıgenlerin üzerine çizer. Açıkken, örtülü bir altıgenin altındaki jetonların oyunculara görünen adı, çubukları ve auraları kapatılır ve açığa çıktıklarında yeniden açılır.', }, }, status: { @@ -162,10 +162,10 @@ const TRANSLATION = { messages: { filled: 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', - revealed: 'Büyüler ortaya çıktı: {count}.', + revealed: 'Açığa çıkan altıgenler: {count}.', revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: - '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + '"{page}" sayfasındaki tüm altıgenler ({count}) kaldırılsın mı? Konum jetonları jeton katmanına geri döner. Geri Al bunu tersine çeviremez.', resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', @@ -190,7 +190,7 @@ const TRANSLATION = { }, warnings: { foregroundUnavailable: - 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, altıgenler jeton katmanına çizildi.', someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', }, errors: { @@ -199,7 +199,7 @@ const TRANSLATION = { noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', - nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya jetonları seçin.', nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', noTokens: 'Önce bir veya daha fazla jeton seçin.', noHexes: 'Önce bir veya daha fazla altıgen (veya altıgenlerin üzerinde duran jetonlar) seçin.', @@ -219,7 +219,8 @@ const TRANSLATION = { 'Alanın çevresine çokgen, dikdörtgen, elips veya serbest şekil çizin, seçin ve tekrar deneyin.', emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', - noHexes: 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + noHexes: + 'Altıgenler ön plan katmanında veya jeton katmanındadır; bunları seçmek için o katmana geçin.', unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: @@ -232,18 +233,18 @@ const TRANSLATION = { menu: 'Menüyü göster.', fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', - undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + undo: 'Son doldurmayı, ters doldurmayı veya gizlemeyi geri alın ve kullandığı şekilleri geri yükleyin.', reveal: - 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + 'Seçilen altıgenleri ve seçilen şekillerin ve jetonların altındaki altıgenleri açığa çıkarın.', revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', - name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + name: 'Seçilen altıgenleri veya seçilen jetonların altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', mark: 'Seçilen jetonları gizli konumlara dönüştürün.', - unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + unmark: 'Seçilen jetonların gizli konum olmasını sonlandırın.', set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', - pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageSet: 'Yalnızca geçerli sayfadaki bir açığa çıkarma ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', @@ -261,14 +262,14 @@ const TRANSLATION = { revealDesc: 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: - 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + 'Jetonları altıgenlerin altında konum olarak gizlemek için seçin. Bir altıgeni adlandırmak için altıgenleri veya jetonları seçin.', toolsDesc: 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', }, handout: { versionLabel: 'Sürüm', - subtitle: 'Roll20 için hex-hex keşif', + subtitle: 'Roll20 için altıgen altıgen keşif', footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', @@ -288,8 +289,8 @@ const TRANSLATION = { commands: { heading: 'Komutlar', intro: - "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", - colCommand: 'Emretmek', + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçili nesneler üzerinde çalışır; geri kalanı görüntülediğiniz sayfada çalışır.", + colCommand: 'Komut', colDesc: 'Ne işe yarar', }, revealing: { @@ -309,7 +310,7 @@ const TRANSLATION = { points: [ 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", - 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + 'Gizli konum jetonları GM katmanına taşınır. Altıgenleri açığa çıktığında adları görünür şekilde jeton katmanına geri dönerler ve keşifleri duyurulur.', "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], @@ -324,7 +325,7 @@ const TRANSLATION = { perPage: '(Sayfa başına ayarlanabilir.)', }, jumpgate: { - heading: 'Jumpgate ve Eski', + heading: 'Jumpgate ve Legacy', points: [ 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', @@ -336,7 +337,7 @@ const TRANSLATION = { heading: "Sürüm 1'den yükseltme", points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", - 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Mevcut altıgen haritalar, adlar, konum jetonları ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], @@ -361,9 +362,9 @@ const TRANSLATION = { colCode: 'Kod', }, credits: { - heading: 'Kredi', + heading: 'Emeği Geçenler', original: 'Orijinal modun yapımcısı', - maintainer: 'Versiyon 2 tarafından sürdürülen', + maintainer: "Sürüm 2'nin bakımını yapan", marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", diff --git a/Hexploration/src/locales/locale/uk.js b/Hexploration/src/locales/locale/uk.js index a993e6c28b..c34c1e6783 100644 --- a/Hexploration/src/locales/locale/uk.js +++ b/Hexploration/src/locales/locale/uk.js @@ -86,12 +86,12 @@ const TRANSLATION = { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шар шестикутників', + label: 'Шар гексів', desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', - desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих гексів, наприклад rgba(0,0,0,0.8).', }, strokeColor: { label: 'Колір контуру', @@ -110,7 +110,7 @@ const TRANSLATION = { desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Відстань розкриття шестикутників', + label: 'Відстань розкриття гексів', desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { @@ -119,7 +119,7 @@ const TRANSLATION = { }, lineOfSight: { label: 'Лінія видимості', - desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття гексів», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', }, revealPath: { label: 'Розкривати вздовж шляху', @@ -135,21 +135,21 @@ const TRANSLATION = { }, announce: { label: 'Оголошувати відкриття', - desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + desc: 'Хто бачить повідомлення в чаті, коли виявлено іменовану локацію.', }, pingDiscoveries: { label: 'Пінгувати знахідки', - desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + desc: 'Коли ввімкнено, під час виявлення іменованої локації погляд гравців переміщується до неї.', }, hideCoveredTokens: { label: 'Ховати маркери під гексами', - desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, у маркерів під закритим гексом вимикаються видимі гравцям ім’я, смужки та аури, а коли маркери відкривають, вони знову вмикаються.', }, }, status: { engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шар шестикутників', + layer: 'Шар гексів', hexes: 'Гекси', named: 'Іменовані гекси', icons: 'Маркери локацій', @@ -166,7 +166,7 @@ const TRANSLATION = { revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', - resetPage: 'Зі сторінки видалено шестигранники: {count}.', + resetPage: 'Зі сторінки видалено гекси: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', named: 'Гекси з назвою "{name}": {count}.', @@ -176,11 +176,11 @@ const TRANSLATION = { unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', settingChanged: '{setting} встановлено на {value}.', rescanned: - 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Переміщено: {moved}. Відсутні й забуті: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', calibrated: - 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', calibrationReset: - 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Калібрування видалено. Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', @@ -199,10 +199,10 @@ const TRANSLATION = { noPage: 'Не вдалося знайти сторінку для роботи.', notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', - emptyArea: 'Вибрана область не містить шестигранних центрів.', + emptyArea: 'Вибрана область не містить центрів гексів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', - nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + nothingToReveal: 'Виберіть гекси, намальовані фігури або жетони, щоб розкрити їх.', noTokens: 'Спочатку виберіть один або кілька токенів.', noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', nothingToUndo: 'Немає заповнення, яке можна скасувати.', @@ -210,7 +210,7 @@ const TRANSLATION = { unknownSetting: 'Невідоме налаштування: {key}', unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', invalidValue: '"{value}" не є дійсним значенням для {key}.', - calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до центрів гексів.', calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', unexpected: 'Щось пішло не так: {message}', }, @@ -226,26 +226,26 @@ const TRANSLATION = { unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', calibrateNeedsTokens: - 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + 'Прив’яжіть жетон до центру гекса та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього гекса в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір гекса.', calibrateFailed: - 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гекс.', unexpected: 'Подробиці в журналі консолі API.', }, help: { menu: 'Показати меню.', - fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fill: 'Покрийте вибрані намальовані форми гексами.', fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', - conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами гексами.', explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', mark: 'Перетворіть вибрані жетони на приховані місця.', - unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + unmark: 'Зробіть так, щоб вибрані маркери більше не були прихованими місцями.', set: 'Змінити налаштування або показати всі налаштування.', - pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageSet: 'Перевизначити налаштування розкриття лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: @@ -273,7 +273,7 @@ const TRANSLATION = { footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', - body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + body: 'Hexploration накриває гексову карту непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', demo: 'Перегляньте коротку демонстрацію (з версії 1)', }, quickStart: { @@ -298,8 +298,8 @@ const TRANSLATION = { points: [ 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', - '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', - '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття гексів».', + '«Відстань розкриття гексів» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття гексів» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', @@ -310,25 +310,25 @@ const TRANSLATION = { points: [ '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', - 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', + 'Маркери прихованих локацій переміщуються на шар GM. Коли їхній гекс розкривається, вони повертаються на шар маркерів із показаним ім’ям, а про їхнє виявлення оголошується.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар гексів» вибрано шар маркерів.', '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', - colKey: 'ключ', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар гексів», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', + colKey: 'Ключ', colName: 'Налаштування', - colDesc: 'опис', + colDesc: 'Опис', perPage: '(Можна встановити на сторінку.)', }, jumpgate: { heading: 'Jumpgate і Legacy', points: [ - 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Hexploration визначає, який рушій використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для «Шару гексів» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], @@ -362,7 +362,7 @@ const TRANSLATION = { colCode: 'Код', }, credits: { - heading: 'Кредити', + heading: 'Автори', original: 'Оригінальний мод від', maintainer: 'Версія 2 підтримується', marketplace: 'Художні набори Ади на Roll20 Marketplace', diff --git a/Hexploration/src/locales/locale/zh-TW.js b/Hexploration/src/locales/locale/zh-TW.js index 2f4b68f034..10634568d5 100644 --- a/Hexploration/src/locales/locale/zh-TW.js +++ b/Hexploration/src/locales/locale/zh-TW.js @@ -16,7 +16,7 @@ const TRANSLATION = { reveal: '揭示與隱藏', locations: '地點', tools: '工具', - layerInUse: '正在 {layer} 上繪製新的六角形。', + layerInUse: '正在 {layer} 上繪製新的六角格。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { @@ -86,7 +86,7 @@ const TRANSLATION = { }, hexLayer: { label: '六角格圖層', - desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + desc: '新六角格的繪製位置。「自動」會先嘗試前景層（令牌上方），若遊戲不支援，則改用令牌層。', }, fillColor: { label: '填充顏色', @@ -94,11 +94,11 @@ const TRANSLATION = { }, strokeColor: { label: '邊框顏色', - desc: '新六邊形輪廓的顏色。', + desc: '新六角格輪廓的顏色。', }, labelColor: { label: '標籤顏色', - desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + desc: '已命名六角格上僅限 GM 可見的名稱標籤顏色。', }, glimpseColor: { label: '瞥見顏色', @@ -106,7 +106,7 @@ const TRANSLATION = { }, strokeWidth: { label: '邊框寬度', - desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + desc: '新六角格輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { label: '六角格揭示距離', @@ -114,7 +114,7 @@ const TRANSLATION = { }, revealDistance: { label: '視距', - desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + desc: '移動中的令牌周圍會揭示多少格六角格（0 到 20）。設為 0 時只揭示令牌經過的六角格。', }, lineOfSight: { label: '視線', @@ -122,7 +122,7 @@ const TRANSLATION = { }, revealPath: { label: '沿路徑顯示', - desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + desc: '啟用後，令牌在拖曳過程中經過的每個六角格（包括路徑點）都會被揭示，而不只是其停下的位置。', }, revealBy: { label: '可揭示的令牌', @@ -134,15 +134,15 @@ const TRANSLATION = { }, announce: { label: '公告發現', - desc: '當發現指定位置時誰會看到聊天訊息。', + desc: '發現已命名的地點時，誰會看到聊天訊息。', }, pingDiscoveries: { label: '標示發現位置', - desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + desc: '啟用後，當已命名的地點被發現時，會對玩家 ping 該地點。', }, hideCoveredTokens: { label: '隱藏被覆蓋的令牌', - desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + desc: 'Roll20 會在六角格上方繪製名稱、條和光環。啟用後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，並在被揭開時重新開啟。', }, }, status: { @@ -159,50 +159,50 @@ const TRANSLATION = { undo: '可撤銷', }, messages: { - filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', - revealed: '六角形顯示：{count}。', + filled: '填充完成。繪製的六角格：{created}。重新套用樣式：{restyled}。隱藏的地點：{icons}。', + revealed: '已揭示的六角格：{count}。', revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', resetPage: '已從頁面移除的六角格：{count}。', - undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', - named: '名為「{name}」的六角形：{count}。', + undone: '上次填充已撤銷。已移除的六角格：{removed}。已恢復原樣式的六角格：{restored}。', + named: '名為「{name}」的六角格：{count}。', unnamed: '已清除的名稱：{count}。', - marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', - unmarked: '不再是位置的標記：{count}。', + marked: '隱藏在現有六角格中的地點：{attached}。等待下一次填充覆蓋的地點：{pending}。', + unmarked: '不再是地點的令牌：{count}。', settingChanged: '{setting} 設定為 {value}。', rescanned: - '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。地點令牌重新連結：{icons}。', calibrated: - '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + '網格已校準（行步長 {colStep}px，列步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從 Legacy 遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { - foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', - someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', + foregroundUnavailable: '此遊戲不支援在前景層上繪製，因此六角格改為繪製在令牌層上。', + someFailed: '無法繪製的六角格：{count}。請檢查 API 控制台以了解詳細資訊。', }, errors: { noPage: '找不到要處理的頁面。', notHex: '此頁面不使用六角網格。', noPolygons: '選擇一個或多個要填滿的繪製形狀。', - emptyArea: '所選區域不包含任何六角形中心。', - tooMany: '這會一次建立太多的六角形 ({count})。', - nothingToConceal: '選擇要隱藏的繪製形狀或標記。', - nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + emptyArea: '所選區域不包含任何六角格中心。', + tooMany: '這會一次建立太多六角格（{count}）。', + nothingToConceal: '選擇要隱藏的繪製形狀或令牌。', + nothingToReveal: '選擇要揭示的六角格、繪製的形狀或令牌。', noTokens: '首先選擇一個或多個令牌。', - noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + noHexes: '首先選擇一個或多個六角格（或站在六角格上的令牌）。', nothingToUndo: '沒有可撤消的填充。', unknownCommand: '未知指令：{command}', unknownSetting: '未知設定：{key}', unknownPageSetting: '每頁可設定的設定：{keys}', invalidValue: '“{value}”對於 {key} 不是有效值。', - calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角格中心的令牌。', calibrateFailed: '這些令牌不能用於校準。', unexpected: '出了點問題：{message}', }, @@ -212,32 +212,32 @@ const TRANSLATION = { noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', - noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + noHexes: '六角格位於前景層或令牌層；切換到該層以選取它們。', unknownCommand: '鍵入 !hexploration help 以列出指令。', unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: - '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + '將令牌吸附到六角格的中心並選取它。若再選取一個吸附在同一列 (Hex V) 或同一行 (Hex H) 相鄰六角格中的令牌，也可以修正六角格大小。', calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { menu: '顯示選單。', - fill: '用六角形覆蓋選定的繪製形狀。', + fill: '用六角格覆蓋選取的繪製形狀。', fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', - reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + reveal: '揭示選取的六角格，以及選取的形狀和令牌下方的六角格。', revealPage: '揭示頁面上的所有六角格，不發布公告。', - conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', - explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + conceal: '再次用六角格覆蓋所選形狀和令牌下方的區域。', + explore: '揭示所選令牌的周圍，就像它們剛移動到那裡一樣。', resetPage: '移除頁面上的所有六角格（會先確認）。', - name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', - mark: '將選取的標記變成隱藏位置。', - unmark: '停止將選定的標記隱藏在位置。', + name: '為選取的六角格或選取令牌下的六角格命名。將名稱留空即可清除。', + mark: '將選取的令牌變成隱藏地點。', + unmark: '讓選取的令牌不再是隱藏地點。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', - calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrate: '將六角格網格與一或兩個吸附到六角格中心的選取令牌對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', journal: '重建說明與 Command Deck 講義。', @@ -247,7 +247,7 @@ const TRANSLATION = { deck: { drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: - '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + '選取六角格、形狀或令牌以揭示或再次覆蓋它們。「探索」會揭示所選令牌的周圍，就像它們已移動過去一樣。', locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', @@ -268,7 +268,7 @@ const TRANSLATION = { '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', - '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + '移動玩家令牌。它經過的每個六角格以及其視距內的六角格都會被揭示。', ], }, commands: { @@ -282,7 +282,7 @@ const TRANSLATION = { heading: '揭示如何運作', points: [ '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', - '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '令牌會揭示它覆蓋的每個六角格（大型令牌會覆蓋數個），若啟用「沿路徑顯示」，還會揭示它被拖曳經過的路線上的每個六角格，包括路徑點。', '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', @@ -291,10 +291,10 @@ const TRANSLATION = { ], }, locations: { - heading: '命名六角形和位置', + heading: '命名六角格和地點', points: [ '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', - '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '與版本 1 一樣，帶有白塔狀態標記的令牌在填充時也會被視為地點。', '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', @@ -304,8 +304,8 @@ const TRANSLATION = { heading: '設定', intro: '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', - colKey: '鑰匙', - colName: '環境', + colKey: '鍵', + colName: '設定', colDesc: '描述', perPage: '（可按頁設定。）', }, @@ -314,8 +314,8 @@ const TRANSLATION = { points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', - 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', - '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與 Legacy 六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', + '當頁面或遊戲被複製時，其六角格會獲得新的 ID。在頁面上執行「重新掃描」，即可重新取回它們及其名稱標籤和地點令牌。', ], }, upgrading: { @@ -333,7 +333,7 @@ const TRANSLATION = { heading: '故障排除', points: [ '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', - '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '六角格偏離網格：使用「校準」，然後在地圖各處的幾個六角格上放置令牌進行檢查。', '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', @@ -344,7 +344,7 @@ const TRANSLATION = { body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', colNative: '原文名稱', - colCode: '程式碼', + colCode: '代碼', }, credits: { heading: '製作人員', From d842ff42d773ea6e3994f90407309bb5f9b1c90c Mon Sep 17 00:00:00 2001 From: Steve Roberts Date: Fri, 30 Oct 2026 23:43:31 +0000 Subject: [PATCH 24/24] chore(Hexploration): Rebuild 2.0.2 with the corrected translations The translations are bundled into the script, so rebuild it and refresh the 2.0.2 snapshot folder to match. Signed-off-by: Steve Roberts --- Hexploration/2.0.2/Hexploration.js | 1534 ++++++++++++++-------------- Hexploration/Hexploration.js | 1534 ++++++++++++++-------------- 2 files changed, 1542 insertions(+), 1526 deletions(-) diff --git a/Hexploration/2.0.2/Hexploration.js b/Hexploration/2.0.2/Hexploration.js index c305cb694d..49a011f9ec 100644 --- a/Hexploration/2.0.2/Hexploration.js +++ b/Hexploration/2.0.2/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.2 - * Built: 2026-10-30T22:13:47.401Z + * Built: 2026-10-30T23:43:06.779Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.2'; - const SCRIPT_LAST_UPDATED = '2026-10-30T22:13:47.401Z'; + const SCRIPT_LAST_UPDATED = '2026-10-30T23:43:06.779Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1345,11 +1345,11 @@ const HexplorationMod = (() => { }, announce: { label: 'Kondig ontdekkings aan', - desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + desc: "Wie sien die kletsboodskap wanneer 'n benoemde ligging ontdek word.", }, pingDiscoveries: { label: 'Ping ontdekkings', - desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + desc: "Wanneer aan, word spelers na 'n benoemde ligging geping wanneer dit ontdek word.", }, hideCoveredTokens: { label: 'Versteek bedekte tokens', @@ -1502,7 +1502,7 @@ const HexplorationMod = (() => { heading: 'Opdragte', intro: "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", - colCommand: 'Bevel', + colCommand: 'Opdrag', colDesc: 'Wat dit doen', }, revealing: { @@ -1514,7 +1514,7 @@ const HexplorationMod = (() => { "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Verken, of roep Hexploration.revealAround(token) vanaf jou eie mod aan.', ], }, locations: { @@ -1524,7 +1524,7 @@ const HexplorationMod = (() => { 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", - 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + 'Kondig ontdekkings aan kies of almal, net die GM, of niemand die aankondiging sien nie. Ping ontdekkings skuif ook die spelers se uitsig na die ligging.', ], }, settings: { @@ -1568,13 +1568,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Tale', - body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + body: "Kies 'n taal met !hexploration set language. Beskikbare tale:", colLanguage: 'Taal', colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { - heading: 'Krediete', + heading: 'Erkennings', original: 'Oorspronklike mod deur', maintainer: 'Weergawe 2 onderhou deur', marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', @@ -1681,7 +1681,7 @@ const HexplorationMod = (() => { }, strokeColor: { label: 'Color de la vora', - desc: 'Color del contorn dels nous hexagonals.', + desc: 'Color del contorn dels hexàgons nous.', }, labelColor: { label: "Color de l'etiqueta", @@ -1701,7 +1701,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Distància de visió', - desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + desc: "Quants hexàgons es revelen al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexàgons per on passa la fitxa.", }, lineOfSight: { label: 'Línia de visió', @@ -1709,11 +1709,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revela al llarg del camí', - desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + desc: "Quan està activat, es revela cada hexàgon per on passa una fitxa mentre és arrossegada (inclosos els punts de pas), no només on s'atura.", }, revealBy: { label: 'Fitxes que revelen', - desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + desc: 'Quines fitxes de la capa de fitxes revelen hexàgons: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o totes les fitxes.', }, revealMode: { label: 'Mode de revelació', @@ -1729,7 +1729,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Amaga les fitxes cobertes', - desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + desc: "Roll20 dibuixa noms, barres i aures per sobre dels hexàgons. Quan està activat, a les fitxes que són sota un hexàgon cobert se'ls desactiven el nom visible per als jugadors, les barres i les aures, que es tornen a activar quan es descobreixen.", }, }, status: { @@ -1748,13 +1748,13 @@ const HexplorationMod = (() => { messages: { filled: 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', - revealed: 'Hexagones revelats: {count}.', + revealed: 'Hexàgons revelats: {count}.', revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: - 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + "Últim emplenament desfet. Hexàgons eliminats: {removed}. Hexàgons amb l'estil restaurat: {restored}.", named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: @@ -1762,11 +1762,11 @@ const HexplorationMod = (() => { unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", + "Reescaneig completat. Conservats: {kept}. Adoptats: {adopted}. Reubicats: {moved}. Desapareguts i oblidats: {dropped}. Etiquetes tornades a enllaçar: {labels}. Fitxes d'ubicació tornades a enllaçar: {icons}.", calibrated: - "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.', calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + "S'ha eliminat el calibratge. Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", @@ -1777,26 +1777,26 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + "Aquest joc no admet dibuixar a la capa de primer pla, de manera que els hexàgons s'han dibuixat a la capa de fitxes.", someFailed: - "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", + "Hexàgons que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', - emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + emptyArea: "L'àrea seleccionada no conté cap centre d'hexàgon.", + tooMany: "Això crearia massa hexàgons d'una vegada ({count}).", nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', - nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', - noTokens: 'Seleccioneu primer un o més fitxes.', - noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToReveal: 'Seleccioneu hexàgons, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer una o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexàgons (o fitxes situades en hexàgons).', nothingToUndo: 'No hi ha cap emplenament per desfer.', unknownCommand: 'Ordre desconeguda: {command}', unknownSetting: 'Configuració desconeguda: {key}', unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', invalidValue: '"{value}" no és un valor vàlid per a {key}.', - calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes ajustades als centres dels hexàgons.', calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', unexpected: "S'ha produït un error: {message}", }, @@ -1821,25 +1821,26 @@ const HexplorationMod = (() => { }, help: { menu: 'Mostra el menú.', - fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexàgons.', fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', - undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + undo: "Desfà l'últim emplenament, emplenament invers o ocultació, i restaura les formes que va utilitzar.", reveal: - 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + 'Revela els hexàgons seleccionats i els hexàgons que hi ha sota les formes i fitxes seleccionades.', revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', - conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", - explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + conceal: + "Torneu a cobrir amb hexàgons l'àrea que hi ha sota les formes i fitxes seleccionades.", + explore: "Revela el voltant de les fitxes seleccionades com si s'hi acabessin de moure.", resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', - name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + name: 'Anomena els hexàgons seleccionats o els hexàgons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', - unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + unmark: 'Fa que les fitxes seleccionades deixin de ser ubicacions ocultes.', set: 'Canvia un paràmetre o mostra tots els paràmetres.', pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: - 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades ajustades als centres dels hexàgons.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", @@ -1863,7 +1864,7 @@ const HexplorationMod = (() => { footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', - body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + body: "Hexploration cobreix un mapa hexagonal amb hexàgons opacs. A mesura que el grup es mou, els hexàgons per on passa (i, si voleu, els hexàgons del voltant) s'eliminen, de manera que el mapa es descobreix hexàgon a hexàgon. Les ubicacions ocultes es poden col·locar sota hexàgons i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", demo: 'Mira una petita demostració (de la versió 1)', }, quickStart: { @@ -1880,7 +1881,7 @@ const HexplorationMod = (() => { heading: 'Ordres', intro: 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', - colCommand: 'Comandament', + colCommand: 'Ordre', colDesc: 'Què fa', }, revealing: { @@ -1892,15 +1893,15 @@ const HexplorationMod = (() => { "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres mods. Els moviments de TokenMod es recullen automàticament; per a altres mods, seleccioneu les fitxes i feu clic a Explora, o crideu Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { - heading: 'Hexes i ubicacions anomenades', + heading: 'Hexàgons amb nom i ubicacions', points: [ - "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", - "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", - "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari, l'amaga el següent emplenament que la cobreixi.", + "Les fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa del GM. Quan es revela el seu hexàgon, tornen a la capa de fitxes amb el nom visible i s'anuncia el seu descobriment.", "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], @@ -1909,7 +1910,7 @@ const HexplorationMod = (() => { heading: 'Configuració', intro: 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', - colKey: 'clau', + colKey: 'Clau', colName: 'Configuració', colDesc: 'Descripció', perPage: '(Es pot configurar per pàgina.)', @@ -1931,8 +1932,8 @@ const HexplorationMod = (() => { 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], - colV1: 'Comandament de la versió 1', - colV2: 'Comandament de la versió 2', + colV1: 'Ordre de la versió 1', + colV2: 'Ordre de la versió 2', }, troubleshooting: { heading: 'Resolució de problemes', @@ -1946,7 +1947,7 @@ const HexplorationMod = (() => { }, languages: { heading: 'Idiomes', - body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + body: 'Trieu un idioma amb !hexploration set language. Idiomes disponibles:', colLanguage: 'Llengua', colNative: 'Nom original', colCode: 'Codi', @@ -1980,7 +1981,7 @@ const HexplorationMod = (() => { reveal: '揭示與隱藏', locations: '地點', tools: '工具', - layerInUse: '正在 {layer} 上繪製新的六角形。', + layerInUse: '正在 {layer} 上繪製新的六角格。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { @@ -2050,7 +2051,7 @@ const HexplorationMod = (() => { }, hexLayer: { label: '六角格圖層', - desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + desc: '新六角格的繪製位置。「自動」會先嘗試前景層（令牌上方），若遊戲不支援，則改用令牌層。', }, fillColor: { label: '填充顏色', @@ -2058,11 +2059,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: '邊框顏色', - desc: '新六邊形輪廓的顏色。', + desc: '新六角格輪廓的顏色。', }, labelColor: { label: '標籤顏色', - desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + desc: '已命名六角格上僅限 GM 可見的名稱標籤顏色。', }, glimpseColor: { label: '瞥見顏色', @@ -2070,7 +2071,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: '邊框寬度', - desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + desc: '新六角格輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { label: '六角格揭示距離', @@ -2078,7 +2079,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '視距', - desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + desc: '移動中的令牌周圍會揭示多少格六角格（0 到 20）。設為 0 時只揭示令牌經過的六角格。', }, lineOfSight: { label: '視線', @@ -2086,7 +2087,7 @@ const HexplorationMod = (() => { }, revealPath: { label: '沿路徑顯示', - desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + desc: '啟用後，令牌在拖曳過程中經過的每個六角格（包括路徑點）都會被揭示，而不只是其停下的位置。', }, revealBy: { label: '可揭示的令牌', @@ -2098,15 +2099,15 @@ const HexplorationMod = (() => { }, announce: { label: '公告發現', - desc: '當發現指定位置時誰會看到聊天訊息。', + desc: '發現已命名的地點時，誰會看到聊天訊息。', }, pingDiscoveries: { label: '標示發現位置', - desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + desc: '啟用後，當已命名的地點被發現時，會對玩家 ping 該地點。', }, hideCoveredTokens: { label: '隱藏被覆蓋的令牌', - desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + desc: 'Roll20 會在六角格上方繪製名稱、條和光環。啟用後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，並在被揭開時重新開啟。', }, }, status: { @@ -2123,50 +2124,50 @@ const HexplorationMod = (() => { undo: '可撤銷', }, messages: { - filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', - revealed: '六角形顯示：{count}。', + filled: '填充完成。繪製的六角格：{created}。重新套用樣式：{restyled}。隱藏的地點：{icons}。', + revealed: '已揭示的六角格：{count}。', revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', resetPage: '已從頁面移除的六角格：{count}。', - undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', - named: '名為「{name}」的六角形：{count}。', + undone: '上次填充已撤銷。已移除的六角格：{removed}。已恢復原樣式的六角格：{restored}。', + named: '名為「{name}」的六角格：{count}。', unnamed: '已清除的名稱：{count}。', - marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', - unmarked: '不再是位置的標記：{count}。', + marked: '隱藏在現有六角格中的地點：{attached}。等待下一次填充覆蓋的地點：{pending}。', + unmarked: '不再是地點的令牌：{count}。', settingChanged: '{setting} 設定為 {value}。', rescanned: - '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。地點令牌重新連結：{icons}。', calibrated: - '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + '網格已校準（行步長 {colStep}px，列步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從 Legacy 遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { - foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', - someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', + foregroundUnavailable: '此遊戲不支援在前景層上繪製，因此六角格改為繪製在令牌層上。', + someFailed: '無法繪製的六角格：{count}。請檢查 API 控制台以了解詳細資訊。', }, errors: { noPage: '找不到要處理的頁面。', notHex: '此頁面不使用六角網格。', noPolygons: '選擇一個或多個要填滿的繪製形狀。', - emptyArea: '所選區域不包含任何六角形中心。', - tooMany: '這會一次建立太多的六角形 ({count})。', - nothingToConceal: '選擇要隱藏的繪製形狀或標記。', - nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + emptyArea: '所選區域不包含任何六角格中心。', + tooMany: '這會一次建立太多六角格（{count}）。', + nothingToConceal: '選擇要隱藏的繪製形狀或令牌。', + nothingToReveal: '選擇要揭示的六角格、繪製的形狀或令牌。', noTokens: '首先選擇一個或多個令牌。', - noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + noHexes: '首先選擇一個或多個六角格（或站在六角格上的令牌）。', nothingToUndo: '沒有可撤消的填充。', unknownCommand: '未知指令：{command}', unknownSetting: '未知設定：{key}', unknownPageSetting: '每頁可設定的設定：{keys}', invalidValue: '“{value}”對於 {key} 不是有效值。', - calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角格中心的令牌。', calibrateFailed: '這些令牌不能用於校準。', unexpected: '出了點問題：{message}', }, @@ -2176,32 +2177,32 @@ const HexplorationMod = (() => { noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', - noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + noHexes: '六角格位於前景層或令牌層；切換到該層以選取它們。', unknownCommand: '鍵入 !hexploration help 以列出指令。', unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: - '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + '將令牌吸附到六角格的中心並選取它。若再選取一個吸附在同一列 (Hex V) 或同一行 (Hex H) 相鄰六角格中的令牌，也可以修正六角格大小。', calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { menu: '顯示選單。', - fill: '用六角形覆蓋選定的繪製形狀。', + fill: '用六角格覆蓋選取的繪製形狀。', fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', - reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + reveal: '揭示選取的六角格，以及選取的形狀和令牌下方的六角格。', revealPage: '揭示頁面上的所有六角格，不發布公告。', - conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', - explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + conceal: '再次用六角格覆蓋所選形狀和令牌下方的區域。', + explore: '揭示所選令牌的周圍，就像它們剛移動到那裡一樣。', resetPage: '移除頁面上的所有六角格（會先確認）。', - name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', - mark: '將選取的標記變成隱藏位置。', - unmark: '停止將選定的標記隱藏在位置。', + name: '為選取的六角格或選取令牌下的六角格命名。將名稱留空即可清除。', + mark: '將選取的令牌變成隱藏地點。', + unmark: '讓選取的令牌不再是隱藏地點。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', - calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrate: '將六角格網格與一或兩個吸附到六角格中心的選取令牌對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', journal: '重建說明與 Command Deck 講義。', @@ -2211,7 +2212,7 @@ const HexplorationMod = (() => { deck: { drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: - '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + '選取六角格、形狀或令牌以揭示或再次覆蓋它們。「探索」會揭示所選令牌的周圍，就像它們已移動過去一樣。', locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', @@ -2232,7 +2233,7 @@ const HexplorationMod = (() => { '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', - '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + '移動玩家令牌。它經過的每個六角格以及其視距內的六角格都會被揭示。', ], }, commands: { @@ -2246,7 +2247,7 @@ const HexplorationMod = (() => { heading: '揭示如何運作', points: [ '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', - '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '令牌會揭示它覆蓋的每個六角格（大型令牌會覆蓋數個），若啟用「沿路徑顯示」，還會揭示它被拖曳經過的路線上的每個六角格，包括路徑點。', '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', @@ -2255,10 +2256,10 @@ const HexplorationMod = (() => { ], }, locations: { - heading: '命名六角形和位置', + heading: '命名六角格和地點', points: [ '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', - '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '與版本 1 一樣，帶有白塔狀態標記的令牌在填充時也會被視為地點。', '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', @@ -2268,8 +2269,8 @@ const HexplorationMod = (() => { heading: '設定', intro: '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', - colKey: '鑰匙', - colName: '環境', + colKey: '鍵', + colName: '設定', colDesc: '描述', perPage: '（可按頁設定。）', }, @@ -2278,8 +2279,8 @@ const HexplorationMod = (() => { points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', - 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', - '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與 Legacy 六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', + '當頁面或遊戲被複製時，其六角格會獲得新的 ID。在頁面上執行「重新掃描」，即可重新取回它們及其名稱標籤和地點令牌。', ], }, upgrading: { @@ -2297,7 +2298,7 @@ const HexplorationMod = (() => { heading: '故障排除', points: [ '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', - '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '六角格偏離網格：使用「校準」，然後在地圖各處的幾個六角格上放置令牌進行檢查。', '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', @@ -2308,7 +2309,7 @@ const HexplorationMod = (() => { body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', colNative: '原文名稱', - colCode: '程式碼', + colCode: '代碼', }, credits: { heading: '製作人員', @@ -2409,12 +2410,12 @@ const HexplorationMod = (() => { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Vrstva šestiúhelníků', + label: 'Vrstva hexů', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { label: 'Barva výplně', - desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0.8).', }, strokeColor: { label: 'Barva ohraničení', @@ -2433,7 +2434,7 @@ const HexplorationMod = (() => { desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Vzdálenost odhalení šestiúhelníků', + label: 'Vzdálenost odhalení hexů', desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', }, revealDistance: { @@ -2442,7 +2443,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Přímá viditelnost', - desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení hexů, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', }, revealPath: { label: 'Odhalovat po cestě', @@ -2466,7 +2467,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Skrýt zakryté žetony', - desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když je zapnuto, žetonům pod zakrytým hexem se vypnou jméno, pruhy a aury viditelné pro hráče a znovu se zapnou, až budou odkryty.', }, }, status: { @@ -2484,26 +2485,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + 'Vyplnění dokončeno. Nakreslené hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', revealed: 'Odhalené hexy: {count}.', - revealedPage: 'Každé odhalené hex na stránce ({count}).', + revealedPage: 'Odhaleny všechny hexy na stránce ({count}).', confirmReset: - 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + 'Odebrat všechny hexy ze stránky „{page}“ ({count})? Žetony míst se vrátí do vrstvy žetonů. Funkce Vrátit to nevrátí.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', - named: 'Hexusy s názvem „{name}“: {count}.', + named: 'Hexy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', unmarked: 'Tokeny, které již nejsou umístěními: {count}.', settingChanged: '{setting} nastaveno na {value}.', rescanned: - 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Přeřazeno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', calibrationReset: - 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + 'Kalibrace odstraněna. Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', @@ -2516,13 +2517,13 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', someFailed: - 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', + 'Hexy, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', - emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy hexů.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', @@ -2559,17 +2560,17 @@ const HexplorationMod = (() => { fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', - revealPage: 'Odhalte každé hex na stránce bez oznámení.', + revealPage: 'Odhalte každý hex na stránce bez oznámení.', conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', mark: 'Proměňte vybrané žetony na skrytá místa.', - unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + unmark: 'Zrušte u vybraných žetonů označení skrytých míst.', set: 'Změňte nastavení nebo zobrazte všechna nastavení.', pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', pageClear: 'Odstraňte přepsání aktuální stránky.', - rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + rescan: 'Znovu vytvořte seznam hexů na stránce, například po zkopírování stránky nebo hry.', calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', @@ -2596,7 +2597,7 @@ const HexplorationMod = (() => { overview: { heading: 'Přehled', body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', - demo: 'Podívejte se na krátkou ukázku (od verze 1)', + demo: 'Podívejte se na krátkou ukázku (z verze 1)', }, quickStart: { heading: 'Rychlý start', @@ -2620,8 +2621,8 @@ const HexplorationMod = (() => { points: [ 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', - 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', - 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení hexů.', + 'Vzdálenost odhalení hexů se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení hexů na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', @@ -2630,17 +2631,17 @@ const HexplorationMod = (() => { locations: { heading: 'Pojmenované hexy a umístění', points: [ - 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak jej skryje další výplň, která jej zakryje.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva hexů nastavena na vrstvu žetonů.', 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu hexů, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -2649,8 +2650,8 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate a Legacy', points: [ - 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', + 'Hexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Když je Vrstva hexů nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], @@ -2684,9 +2685,9 @@ const HexplorationMod = (() => { colCode: 'Kód', }, credits: { - heading: 'Kredity', + heading: 'Autoři', original: 'Původní mod od', - maintainer: 'Verze 2 spravovaná společností', + maintainer: 'Verzi 2 spravuje', marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', support: 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', @@ -2787,15 +2788,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Fyldfarve', - desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + desc: 'Farve på nye hexfelter. Brug rgba() til gennemsigtige hexfelter, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfarve', - desc: 'Farve på omridset af nye sekskanter.', + desc: 'Farve på omridset af nye hexfelter.', }, labelColor: { label: 'Etiketfarve', - desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + desc: 'Farven på navneetiketterne, som kun GM kan se, på navngivne hexfelter.', }, glimpseColor: { label: 'Glimtfarve', @@ -2803,7 +2804,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Kantbredde', - desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + desc: 'Bredden af omridset af nye hexfelter, i pixels (0 til 20).', }, maxDistance: { label: 'Afsløringsafstand for hexfelter', @@ -2811,7 +2812,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Synsafstand', - desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + desc: 'Hvor mange hexfelter omkring et token i bevægelse afsløres (0 til 20). 0 afslører kun de hexfelter, som tokenet passerer igennem.', }, lineOfSight: { label: 'Synslinje', @@ -2819,11 +2820,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Afslør langs ruten', - desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + desc: 'Når den er tændt, afsløres hvert hexfelt, et token passerer igennem, mens det trækkes (inklusive mellempunkter), ikke kun hvor det stopper.', }, revealBy: { label: 'Afslørende tokens', - desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + desc: 'Hvilke tokens på tokenlaget afslører hexfelter: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller alle tokens.', }, revealMode: { label: 'Afsløringstilstand', @@ -2839,7 +2840,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Skjul dækkede tokens', - desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + desc: 'Roll20 tegner navne, bjælker og auraer over hexfelter. Når den er tændt, får tokens under et dækket hexfelt deres spillersynlige navn, bjælker og auraer slået fra, og de slås til igen, når tokens afdækkes.', }, }, status: { @@ -2857,26 +2858,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', - revealed: 'Hexer afsløret: {count}.', - revealedPage: 'Hver hex på siden afsløret ({count}).', + 'Udfyldning færdig. Hexfelter tegnet: {created}. Stil ændret: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexfelter afsløret: {count}.', + revealedPage: 'Alle hexfelter på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: 'Hexer fjernet fra siden: {count}.', + 'Vil du fjerne alle hexfelter fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexfelter fjernet fra siden: {count}.', undone: - 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', - named: 'Hexer med navnet "{name}": {count}.', + 'Sidste udfyldning fortrydet. Hexfelter fjernet: {removed}. Hexfelter med ændret stil gendannet: {restored}.', + named: 'Hexfelter med navnet "{name}": {count}.', unnamed: 'Navne ryddet: {count}.', marked: - 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + 'Placeringer skjult i eksisterende hexfelter: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', unmarked: 'Tokens, der ikke længere er placeringer: {count}.', settingChanged: '{setting} indstillet til {value}.', rescanned: - 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', + 'Genscanning fuldført. Beholdt: {kept}. Overtaget: {adopted}. Omplaceret: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', calibrationReset: - 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', @@ -2887,25 +2888,25 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', - someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', + 'Dette spil understøtter ikke tegning på forgrundslaget, så hexfelterne blev tegnet på tokenlaget.', + someFailed: 'Hexfelter, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { noPage: 'Kunne ikke finde siden at arbejde på.', notHex: 'Denne side bruger ikke et hex-gitter.', noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', - emptyArea: 'Det valgte område indeholder ingen hex-centre.', - tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + emptyArea: 'Det valgte område indeholder ingen hexfeltcentre.', + tooMany: 'Det ville skabe for mange hexfelter på én gang ({count}).', nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', - nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + nothingToReveal: 'Vælg hexfelter, tegnede figurer eller tokens, der skal afsløres.', noTokens: 'Vælg først et eller flere tokens.', - noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + noHexes: 'Vælg først et eller flere hexfelter (eller tokens, der står på hexfelter).', nothingToUndo: 'Der er ingen udfyldning at fortryde.', unknownCommand: 'Ukendt kommando: {command}', unknownSetting: 'Ukendt indstilling: {key}', unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', - calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hexfeltcentre.', calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', unexpected: 'Noget gik galt: {message}', }, @@ -2916,35 +2917,36 @@ const HexplorationMod = (() => { 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', - noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + noHexes: + 'Hexfelterne ligger på forgrundslaget eller tokenlaget; skift til det lag for at vælge dem.', unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', calibrateNeedsTokens: - 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + 'Fastgør et token til midten af et hexfelt, og vælg det. Vælg et andet token, der er fastgjort til et tilstødende hexfelt i samme række (Hex V) eller kolonne (Hex H), for også at rette hexfeltstørrelsen.', calibrateFailed: - 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), mindst ét hexfelt fra hinanden.', unexpected: 'Detaljer er i API-konsolloggen.', }, help: { menu: 'Vis menuen.', - fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fill: 'Dæk de valgte tegnede figurer med hexfelter.', fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', - reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', - revealPage: 'Afslør hver hex på siden uden meddelelser.', - conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + reveal: 'Afslør de valgte hexfelter og hexfelterne under de valgte former og tokens.', + revealPage: 'Afslør alle hexfelter på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med hexfelter igen.', explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', - resetPage: 'Fjern hver hex på siden (spørg først).', - name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + resetPage: 'Fjern alle hexfelter på siden (spørger først).', + name: 'Navngiv de valgte hexfelter eller hexfelterne under de valgte tokens. Lad navnet stå tomt for at rydde det.', mark: 'Gør de valgte tokens til skjulte placeringer.', unmark: 'Stop de valgte tokens med at være skjulte placeringer.', set: 'Skift en indstilling, eller vis alle indstillinger.', pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', pageClear: 'Fjern den aktuelle sides tilsidesættelser.', rescan: - 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + 'Genopbyg sidens liste over hexfelter, for eksempel efter at have kopieret en side eller et spil.', calibrate: - 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hexfeltcentre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', journal: 'Genopbyg uddelingsarkene Help og Command Deck.', @@ -2957,18 +2959,18 @@ const HexplorationMod = (() => { revealDesc: 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: - 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + 'Vælg tokens for at skjule dem som placeringer under hexfelter. Vælg hexfelter eller tokens for at navngive et hexfelt.', toolsDesc: 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-udforskning for Roll20', + subtitle: 'Udforskning hexfelt for hexfelt i Roll20', footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', overview: { heading: 'Oversigt', - body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + body: 'Hexploration dækker et hexkort med uigennemsigtige hexfelter. Efterhånden som gruppen bevæger sig, fjernes de hexfelter, den passerer igennem (og, hvis du vil, hexfelterne omkring den), så kortet afdækkes ét hexfelt ad gangen. Skjulte steder kan placeres under hexfelter og annonceres, når de findes. Det fungerer i Jumpgate- og Legacy-spil, på Hex (V)- og Hex (H)-gitre af enhver størrelse.', demo: 'Se en kort demo (fra version 1)', }, quickStart: { @@ -3001,11 +3003,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Navngivne Hekser og Steder', + heading: 'Navngivne hexfelter og steder', points: [ 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', - 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hexfelt afsløres, vender de tilbage til tokenlaget med deres navn vist, og deres opdagelse annonceres.', 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], @@ -3032,7 +3034,7 @@ const HexplorationMod = (() => { heading: 'Opgradering fra version 1', points: [ 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', - 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Eksisterende hexkort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], @@ -3051,13 +3053,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Sprog', - body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + body: 'Vælg et sprog med !hexploration set language. Tilgængelige sprog:', colLanguage: 'Sprog', colNative: 'Eget navn', colCode: 'Kode', }, credits: { - heading: 'Kreditter', + heading: 'Medvirkende', original: 'Original mod af', maintainer: 'Version 2 vedligeholdes af', marketplace: 'Adas kunstpakker på Roll20 Marketplace', @@ -3160,15 +3162,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Vulkleur', - desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + desc: 'Kleur van nieuwe zeshoeken. Gebruik rgba() voor doorzichtige zeshoeken, bijvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randkleur', - desc: 'Kleur van de omtrek van nieuwe vakjes.', + desc: 'Kleur van de omtrek van nieuwe zeshoeken.', }, labelColor: { label: 'Labelkleur', - desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + desc: 'Kleur van de naamlabels die alleen de GM ziet, op benoemde zeshoeken.', }, glimpseColor: { label: 'Glimpkleur', @@ -3176,7 +3178,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Randbreedte', - desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + desc: 'Breedte van de omtrek van nieuwe zeshoeken, in pixels (0 tot 20).', }, maxDistance: { label: 'Onthullingsafstand van zeshoeken', @@ -3184,7 +3186,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Zichtafstand', - desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + desc: 'Hoeveel zeshoeken rond een bewegend token worden onthuld (0 tot 20). 0 onthult alleen de zeshoeken waar het token doorheen gaat.', }, lineOfSight: { label: 'Zichtlijn', @@ -3192,11 +3194,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Onthullen langs pad', - desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke zeshoek waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { label: 'Tokens die onthullen', - desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + desc: 'Welke tokens op de tokenlaag zeshoeken onthullen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', }, revealMode: { label: 'Onthullingsmodus', @@ -3204,15 +3206,15 @@ const HexplorationMod = (() => { }, announce: { label: 'Ontdekkingen aankondigen', - desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + desc: 'Wie het chatbericht ziet wanneer een benoemde locatie wordt ontdekt.', }, pingDiscoveries: { label: 'Ontdekkingen pingen', - desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een benoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { label: 'Bedekte tokens verbergen', - desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + desc: "Roll20 tekent namen, balken en aura's boven zeshoeken. Wanneer deze optie is ingeschakeld, worden de voor spelers zichtbare naam, balken en aura's van tokens onder een bedekte zeshoek uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { @@ -3230,26 +3232,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', - revealed: 'Hexen onthuld: {count}.', - revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + 'Vullen voltooid. Getekende zeshoeken: {created}. Opnieuw opgemaakt: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Zeshoeken onthuld: {count}.', + revealedPage: 'Alle zeshoeken op de pagina onthuld ({count}).', confirmReset: - 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', - resetPage: 'Hexes verwijderd van de pagina: {count}.', + 'Alle zeshoeken verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Zeshoeken verwijderd van de pagina: {count}.', undone: - 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', - named: 'Hexen met de naam "{name}": {count}.', + 'Laatste vulling ongedaan gemaakt. Zeshoeken verwijderd: {removed}. Opnieuw opgemaakte zeshoeken hersteld: {restored}.', + named: 'Zeshoeken met de naam "{name}": {count}.', unnamed: 'Namen gewist: {count}.', marked: - 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + 'Locaties verborgen in bestaande zeshoeken: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', unmarked: 'Tokens die niet langer locaties zijn: {count}.', settingChanged: '{setting} ingesteld op {value}.', rescanned: - 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + 'Opnieuw scannen voltooid. Behouden: {kept}. Overgenomen: {adopted}. Opnieuw ingedeeld: {moved}. Ontbrekend en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', calibrated: - 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', calibrationReset: - 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', @@ -3260,20 +3262,20 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden de zeshoeken op de tokenlaag getekend.', someFailed: - 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + 'Zeshoeken die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', }, errors: { noPage: 'Kon de pagina niet vinden om aan te werken.', notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', - emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', - tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + emptyArea: 'Het geselecteerde gebied bevat geen middelpunten van zeshoeken.', + tooMany: 'Dat zou te veel zeshoeken in één keer creëren ({count}).', nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', - nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + nothingToReveal: 'Selecteer zeshoeken, getekende vormen of tokens om te onthullen.', noTokens: 'Selecteer eerst een of meer tokens.', - noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + noHexes: 'Selecteer eerst een of meer zeshoeken (of tokens die op zeshoeken staan).', nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', unknownCommand: 'Onbekend commando: {command}', unknownSetting: 'Onbekende instelling: {key}', @@ -3292,27 +3294,28 @@ const HexplorationMod = (() => { emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', noHexes: - 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + 'Zeshoeken bevinden zich op de voorgrondlaag of de tokenlaag; ga naar die laag om ze te selecteren.', unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', calibrateNeedsTokens: - 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + 'Zet een token vast op het midden van een zeshoek en selecteer het. Selecteer een tweede token dat is vastgezet op een aangrenzende zeshoek in dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', calibrateFailed: - 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', - unexpected: 'Details staan ​​in het API-consolelogboek.', + 'Twee tokens moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, minstens één zeshoek uit elkaar.', + unexpected: 'Details staan in het API-consolelogboek.', }, help: { - menu: 'Laat de menukaart zien.', - fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + menu: 'Toon het menu.', + fill: 'Bedek de geselecteerde getekende vormen met zeshoeken.', fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', - undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + undo: 'Maak de laatste vulling, omgekeerde vulling of verberging ongedaan, en herstel de gebruikte vormen.', reveal: - 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', - revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', - conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', - explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', - resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', - name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + 'Onthul de geselecteerde zeshoeken en de zeshoeken onder de geselecteerde vormen en tokens.', + revealPage: 'Onthul alle zeshoeken op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en tokens opnieuw met zeshoeken.', + explore: + 'Onthul de omgeving van de geselecteerde tokens alsof ze er net naartoe zijn verplaatst.', + resetPage: 'Verwijder alle zeshoeken op de pagina (vraagt eerst om bevestiging).', + name: 'Geef de geselecteerde zeshoeken een naam, of de zeshoeken onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', mark: 'Verander de geselecteerde tokens in verborgen locaties.', unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', set: 'Wijzig een instelling of toon alle instellingen.', @@ -3321,7 +3324,7 @@ const HexplorationMod = (() => { rescan: 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een zeshoek zijn vastgezet.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', @@ -3334,18 +3337,18 @@ const HexplorationMod = (() => { revealDesc: 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: - 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + 'Selecteer tokens om ze als locaties onder zeshoeken te verbergen. Selecteer zeshoeken of tokens om een zeshoek een naam te geven.', toolsDesc: "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", footer: 'Zie de hand-out "{help}" voor volledige instructies.', }, handout: { versionLabel: 'Versie', - subtitle: 'Hex-voor-hex verkenning voor Roll20', + subtitle: 'Verkenning zeshoek voor zeshoek in Roll20', footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', overview: { heading: 'Overzicht', - body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + body: 'Hexploration bedekt een hexkaart met ondoorzichtige zeshoeken. Terwijl het gezelschap beweegt, worden de zeshoeken waar het doorheen gaat (en, als je wilt, de zeshoeken eromheen) verwijderd, zodat de kaart zeshoek voor zeshoek wordt blootgelegd. Verborgen locaties kunnen onder zeshoeken worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V)- en Hex (H)-rasters van elke grootte.', demo: 'Bekijk een korte demo (vanaf versie 1)', }, quickStart: { @@ -3378,11 +3381,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Genoemde velden en locaties', + heading: 'Benoemde zeshoeken en locaties', points: [ 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', - 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Verborgen locatietokens worden verplaatst naar de GM-laag. Wanneer hun zeshoek wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], @@ -3397,7 +3400,7 @@ const HexplorationMod = (() => { perPage: '(Kan per pagina worden ingesteld.)', }, jumpgate: { - heading: 'Jumpgate en erfenis', + heading: 'Jumpgate en Legacy', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', @@ -3428,13 +3431,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Talen', - body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + body: 'Kies een taal met !hexploration set language. Beschikbare talen:', colLanguage: 'Taal', colNative: 'Eigen naam', colCode: 'Code', }, credits: { - heading: 'Kredieten', + heading: 'Credits', original: 'Originele mod door', maintainer: 'Versie 2 onderhouden door', marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", @@ -3906,15 +3909,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Täyttöväri', - desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + desc: 'Uusien heksojen väri. Käytä rgba()-funktiota läpikuultaville heksoille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { label: 'Reunan väri', - desc: 'Uusien kuusioiden ääriviivan väri.', + desc: 'Uusien heksojen ääriviivan väri.', }, labelColor: { label: 'Nimilappujen väri', - desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + desc: 'Vain GM:n näkemien nimilappujen väri nimetyissä heksoissa.', }, glimpseColor: { label: 'Vilkaisun väri', @@ -3938,11 +3941,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Paljasta reitin varrelta', - desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + desc: 'Kun se on päällä, jokainen heksa, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { label: 'Paljastavat merkit', - desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + desc: 'Mitkä merkkitason merkit paljastavat heksoja: pelaajan hallitsemat merkit, mitä tahansa hahmoa edustavat merkit tai kaikki merkit.', }, revealMode: { label: 'Paljastustila', @@ -3958,7 +3961,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Piilota peitetyt merkit', - desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + desc: 'Roll20 piirtää nimet, palkit ja aurat heksojen päälle. Kun se on päällä, peitetyn heksan alla olevien merkkien pelaajille näkyvä nimi, palkit ja aurat kytketään pois päältä ja takaisin päälle, kun merkit paljastuvat.', }, }, status: { @@ -3980,22 +3983,22 @@ const HexplorationMod = (() => { revealed: 'Heksat paljastettiin: {count}.', revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', confirmReset: - 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', - resetPage: 'Heksit poistettu sivulta: {count}.', + 'Poistetaanko kaikki heksat sivulta "{page}" ({count})? Sijaintimerkit palaavat merkkitasolle. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Sivulta poistetut heksat: {count}.', undone: - 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', - named: 'Heksaalit nimeltä "{name}": {count}.', + 'Viimeinen täyttö kumottu. Poistetut heksat: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksat nimeltä "{name}": {count}.', unnamed: 'Poistetut nimet: {count}.', marked: - 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', - unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + 'Olemassa oleviin heksoihin piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Merkit, jotka eivät ole enää sijainteja: {count}.', settingChanged: '{setting} asetettu arvoon {value}.', rescanned: - 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Otettu käyttöön: {adopted}. Sijoitettu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt nimilaput: {labels}. Uudelleen linkitetyt sijaintimerkit: {icons}.', calibrated: - 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Ruudukko kalibroitu (sarakeaskel {colStep}px, riviaskel {rowStep}px). Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', calibrationReset: - 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Kalibrointi poistettu. Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', @@ -4006,26 +4009,27 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + 'Tämä peli ei tue piirtämistä etualan tasolle, joten heksat piirrettiin merkkitasolle.', someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', }, errors: { noPage: 'Työstettävää sivua ei löytynyt.', - notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + notHex: 'Tämä sivu ei käytä heksaruudukkoa.', noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', - nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat heksat, piirretyt muodot tai merkit.', noTokens: 'Valitse ensin yksi tai useampi merkki.', - noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova merkki).', nothingToUndo: 'Kumoavaa täyttöä ei ole.', unknownCommand: 'Tuntematon komento: {command}', unknownSetting: 'Tuntematon asetus: {key}', unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', - calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', - calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + calibrateNeedsTokens: + 'Valitse yksi tai kaksi merkkiä, jotka on kiinnitetty heksojen keskipisteisiin.', + calibrateFailed: 'Näitä merkkejä ei voi käyttää kalibrointiin.', unexpected: 'Jotain meni pieleen: {message}', }, hints: { @@ -4036,36 +4040,36 @@ const HexplorationMod = (() => { emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', noHexes: - 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + 'Heksat ovat etualan tasolla tai merkkitasolla; vaihda kyseiselle tasolle valitaksesi ne.', unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: - 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + 'Kahden merkin on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', }, help: { menu: 'Näytä valikko.', - fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fill: 'Peitä valitut piirretyt muodot heksoilla.', fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', - undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', - reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', - revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', - conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai peitto ja palauta sen käyttämät muodot.', + reveal: 'Paljasta valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun kaikki heksat ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen heksoilla.', explore: - 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', - resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + 'Paljasta valittujen merkkien ympäristö ikään kuin ne olisivat juuri siirtyneet sinne.', + resetPage: 'Poista sivulta kaikki heksat (kysyy ensin).', name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', - mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', - unmark: 'Estä valittujen merkkien piilottaminen.', + mark: 'Muuta valitut merkit piilotetuiksi sijainneiksi.', + unmark: 'Lopeta valittujen merkkien käyttö piilotettuina sijainteina.', set: 'Muuta asetusta tai näytä kaikki asetukset.', pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: - 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + 'Kohdista heksaruudukko yhteen tai kahteen valittuun merkkiin, jotka on kiinnitetty heksojen keskipisteisiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', @@ -4085,11 +4089,11 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Versio', - subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + subtitle: 'Tutkimista heksa kerrallaan Roll20:lle', footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', overview: { heading: 'Yleiskatsaus', - body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + body: 'Hexploration peittää heksakartan läpinäkymättömillä heksoilla. Kun seurue liikkuu, heksat, joiden läpi se kulkee (ja halutessasi sen ympärillä olevat heksat), poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V)- ja Hex (H) -ruudukoissa.', demo: 'Katso lyhyt esittely (versiosta 1)', }, quickStart: { @@ -4103,7 +4107,7 @@ const HexplorationMod = (() => { ], }, commands: { - heading: 'komennot', + heading: 'Komennot', intro: 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', colCommand: 'Komento', @@ -4122,11 +4126,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Nimetty Heksit ja sijainnit', + heading: 'Nimetyt heksat ja sijainnit', points: [ 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', - 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', - 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Valkoisen tornin tilamerkillä varustetut merkit käsitellään myös sijainteina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintimerkit siirretään GM-tasolle. Kun niiden heksa paljastetaan, ne palaavat merkkitasolle nimi näkyvissä, ja niiden löytymisestä ilmoitetaan.', 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], @@ -4289,7 +4293,7 @@ const HexplorationMod = (() => { }, labelColor: { label: "Couleur de l'étiquette", - desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + desc: 'Couleur des étiquettes de nom réservées au MJ sur les hexagones nommés.', }, glimpseColor: { label: "Couleur d'aperçu", @@ -4297,7 +4301,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Largeur de la bordure', - desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + desc: 'Largeur du contour des nouveaux hexagones, en pixels (0 à 20).', }, maxDistance: { label: 'Distance de révélation des hexagones', @@ -4313,7 +4317,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Révéler le long du chemin', - desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les points de passage) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { label: 'Jetons révélateurs', @@ -4333,7 +4337,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Masquer les jetons couverts', - desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsque cette option est activée, les jetons situés sous un hexagone couvert ont leur nom visible par les joueurs, leurs barres et leurs auras désactivés, puis réactivés lorsqu'ils sont découverts.", }, }, status: { @@ -4352,21 +4356,21 @@ const HexplorationMod = (() => { messages: { filled: 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', - revealed: 'Hexs révélés : {count}.', + revealed: 'Hexagones révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: - 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', - resetPage: 'Hexs supprimés de la page : {count}.', + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent sur le calque des jetons. Annuler le remplissage ne pourra pas revenir sur cette action.', + resetPage: 'Hexagones supprimés de la page : {count}.', undone: - 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', - named: 'Hexs nommés "{name}" : {count}.', + 'Dernier remplissage annulé. Hexagones supprimés : {removed}. Hexagones restylés restaurés : {restored}.', + named: 'Hexagones nommés "{name}" : {count}.', unnamed: 'Noms effacés : {count}.', marked: - 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + 'Emplacements cachés dans les hexagones existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', settingChanged: '{setting} défini sur {value}.', rescanned: - 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + "Nouvelle analyse terminée. Conservés : {kept}. Adoptés : {adopted}. Reclassés : {moved}. Manquants et oubliés : {dropped}. Libellés réassociés : {labels}. Jetons d'emplacement réassociés : {icons}.", calibrated: 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', calibrationReset: @@ -4375,7 +4379,7 @@ const HexplorationMod = (() => { migrated: "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", pruned: - "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + "Hexagones enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, @@ -4383,11 +4387,11 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', someFailed: - "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + "Hexagones qui n'ont pas pu être dessinés : {count}. Consultez la console API pour plus de détails.", }, errors: { noPage: 'Impossible de trouver la page sur laquelle travailler.', - notHex: "Cette page n'utilise pas de grille hexadécimale.", + notHex: "Cette page n'utilise pas de grille hexagonale.", noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", @@ -4421,21 +4425,21 @@ const HexplorationMod = (() => { calibrateNeedsTokens: "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", calibrateFailed: - "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + "Les deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hexagone l'un de l'autre.", unexpected: 'Les détails se trouvent dans le journal de la console API.', }, help: { menu: 'Afficher le menu.', fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", - undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + undo: "Annulez le dernier remplissage, remplissage inversé ou masquage, et restaurez les formes qu'il a utilisées.", reveal: 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', revealPage: 'Révélez chaque hexagone de la page sans annonce.', conceal: 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", - resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + resetPage: 'Supprimez tous les hexagones de la page (avec confirmation).', name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", mark: 'Transformez les jetons sélectionnés en emplacements cachés.', unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", @@ -4443,7 +4447,7 @@ const HexplorationMod = (() => { pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', pageClear: 'Supprimez les remplacements de la page actuelle.', rescan: - 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + 'Reconstruisez la liste des hexagones de la page, par exemple après avoir copié une page ou un jeu.', calibrate: 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', @@ -4460,16 +4464,16 @@ const HexplorationMod = (() => { locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: - 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + 'Paramètres, remplacements de page, statut, nouvelle analyse des pages copiées et calibrage de la grille.', footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', }, handout: { versionLabel: 'Version', - subtitle: 'Exploration hex par hex pour Roll20', + subtitle: 'Exploration hexagone par hexagone pour Roll20', footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', overview: { - heading: 'Aperçu', - body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + heading: "Vue d'ensemble", + body: "Hexploration recouvre une carte hexagonale d'hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", demo: 'Regardez une courte démo (à partir de la version 1)', }, quickStart: { @@ -4479,7 +4483,7 @@ const HexplorationMod = (() => { 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", - "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + "Déplacez un jeton de joueur. Chaque hexagone qu'il traverse, ainsi que les hexagones situés dans sa Distance de vue, sont révélés.", ], }, commands: { @@ -4493,7 +4497,7 @@ const HexplorationMod = (() => { heading: 'Comment fonctionne la révélation', points: [ 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', - "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + "Un jeton révèle chaque hexagone qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hexagone du trajet le long duquel il a été déplacé, y compris les points de passage.", "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", @@ -4502,11 +4506,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexs et emplacements nommés', + heading: 'Hexagones nommés et emplacements', points: [ "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', - "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Les jetons d'emplacement cachés sont déplacés vers le calque MJ. Lorsque leur hexagone est révélé, ils retournent sur le calque des jetons avec leur nom affiché et leur découverte est annoncée.", "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], @@ -4521,7 +4525,7 @@ const HexplorationMod = (() => { perPage: '(Peut être défini par page.)', }, jumpgate: { - heading: 'Jumpgate et héritage', + heading: 'Jumpgate et Legacy', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", @@ -4544,8 +4548,8 @@ const HexplorationMod = (() => { heading: 'Dépannage', points: [ 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', - 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', - "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + 'Les hexagones sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexagones répartis sur la carte.', + "Les hexagones ne sont plus révélés après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], @@ -4661,7 +4665,7 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Füllfarbe', - desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexfelder, zum Beispiel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randfarbe', @@ -4697,7 +4701,7 @@ const HexplorationMod = (() => { }, revealBy: { label: 'Aufdeckende Token', - desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + desc: 'Welche Token auf der Token-Ebene Hexfelder aufdecken: Token, die von einem Spieler gesteuert werden, Token, die einen beliebigen Charakter darstellen, oder alle Token.', }, revealMode: { label: 'Aufdeckmodus', @@ -4731,26 +4735,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', - revealed: 'Aufgedeckte Verhexungen: {count}.', - revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + 'Füllen abgeschlossen. Gezeichnete Hexfelder: {created}. Neu gestaltet: {restyled}. Versteckte Standorte: {icons}.', + revealed: 'Aufgedeckte Hexfelder: {count}.', + revealedPage: 'Alle Hexfelder auf der Seite aufgedeckt ({count}).', confirmReset: - 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', - resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + 'Alle Hexfelder aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Von der Seite entfernte Hexfelder: {count}.', undone: - 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', - named: 'Hexen mit dem Namen „{name}“: {count}.', + 'Letzte Füllung rückgängig gemacht. Entfernte Hexfelder: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexfelder mit dem Namen „{name}“: {count}.', unnamed: 'Gelöschte Namen: {count}.', marked: 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', unmarked: 'Token, die keine Standorte mehr sind: {count}.', settingChanged: '{setting} wird auf {value} gesetzt.', rescanned: - 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + 'Erneuter Scan abgeschlossen. Behalten: {kept}. Übernommen: {adopted}. Neu zugeordnet: {moved}. Fehlend und vergessen: {dropped}. Neu verknüpfte Beschriftungen: {labels}. Neu verknüpfte Standort-Token: {icons}.', calibrated: - 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Raster kalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', calibrationReset: - 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', @@ -4763,18 +4767,18 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', someFailed: - 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + 'Hexfelder, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', }, errors: { noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', notHex: 'Diese Seite verwendet kein Hex-Raster.', noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', - emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', - tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + emptyArea: 'Der ausgewählte Bereich enthält keine Hexfeld-Mittelpunkte.', + tooMany: 'Das würde zu viele Hexfelder auf einmal erzeugen ({count}).', nothingToConceal: - 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + 'Wählen Sie gezeichnete Formen oder Spielsteine aus, die Sie verbergen möchten.', nothingToReveal: - 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine aus, die Sie aufdecken möchten.', noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', noHexes: 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', @@ -4784,7 +4788,7 @@ const HexplorationMod = (() => { unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', calibrateNeedsTokens: - 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + 'Wählen Sie ein oder zwei Token aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', unexpected: 'Es ist ein Fehler aufgetreten: {message}', }, @@ -4800,38 +4804,38 @@ const HexplorationMod = (() => { tooMany: 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', noHexes: - 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + 'Hexfelder liegen auf der Vordergrund- oder Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', calibrateNeedsTokens: 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', calibrateFailed: - 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + 'Zwei Spielsteine müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hexfeld voneinander entfernt sein.', unexpected: 'Details finden Sie im API-Konsolenprotokoll.', }, help: { menu: 'Zeigen Sie das Menü an.', - fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexfeldern ab.', fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', - undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + undo: 'Machen Sie die letzte Füllung, umgekehrte Füllung oder Verbergung rückgängig und stellen Sie die dabei verwendeten Formen wieder her.', reveal: 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', - revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + revealPage: 'Decken Sie alle Hexfelder auf der Seite ohne Ankündigungen auf.', conceal: - 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexfeldern ab.', explore: - 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', - resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + 'Decken Sie die Umgebung der ausgewählten Spielsteine auf, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entfernen Sie alle Hexfelder auf der Seite (mit Rückfrage).', name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', - mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine in versteckte Orte.', unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', - pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageSet: 'Überschreiben Sie eine Aufdeck-Einstellung nur auf der aktuellen Seite.', pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', rescan: - 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + 'Erstellen Sie die Hexfeldliste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', calibrate: - 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + 'Richten Sie das Hexfeld-Raster an einem oder zwei ausgewählten Spielsteinen aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', @@ -4844,18 +4848,18 @@ const HexplorationMod = (() => { revealDesc: 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: - 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + 'Wählen Sie Spielsteine aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-für-Hex-Erkundung für Roll20', + subtitle: 'Erkundung Hexfeld für Hexfeld in Roll20', footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', overview: { heading: 'Überblick', - body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + body: 'Hexploration deckt eine Hexfeldkarte mit undurchsichtigen Hexfeldern ab. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum), entfernt, sodass die Karte Hexfeld für Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen, auf Hex (V)- und Hex (H)-Rastern jeder Größe.', demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', }, quickStart: { @@ -4876,7 +4880,7 @@ const HexplorationMod = (() => { colDesc: 'Was es bewirkt', }, revealing: { - heading: 'Wie Offenlegung funktioniert', + heading: 'Wie das Aufdecken funktioniert', points: [ 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', @@ -4919,7 +4923,7 @@ const HexplorationMod = (() => { heading: 'Upgrade von Version 1', points: [ 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', - 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Vorhandene Hexkarten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], @@ -5047,11 +5051,11 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Χρώμα πλήρωσης', - desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + desc: 'Χρώμα νέων εξαγώνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', }, strokeColor: { label: 'Χρώμα περιγράμματος', - desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + desc: 'Χρώμα του περιγράμματος των νέων εξαγώνων.', }, labelColor: { label: 'Χρώμα ετικετών', @@ -5063,7 +5067,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Πλάτος περιγράμματος', - desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + desc: 'Πλάτος του περιγράμματος των νέων εξαγώνων, σε pixel (0 έως 20).', }, maxDistance: { label: 'Απόσταση αποκάλυψης εξαγώνων', @@ -5083,7 +5087,7 @@ const HexplorationMod = (() => { }, revealBy: { label: 'Διακριτικά που αποκαλύπτουν', - desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + desc: 'Ποια διακριτικά στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: διακριτικά που ελέγχει ένας παίκτης, διακριτικά που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', @@ -5095,11 +5099,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Ping στις ανακαλύψεις', - desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες λαμβάνουν ping σε μια τοποθεσία με όνομα όταν αυτή ανακαλυφθεί.', }, hideCoveredTokens: { label: 'Απόκρυψη καλυμμένων διακριτικών', - desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από τα εξάγωνα. Όταν είναι ενεργοποιημένο, στα διακριτικά κάτω από καλυμμένο εξάγωνο απενεργοποιούνται το ορατό στους παίκτες όνομα, οι μπάρες και οι αύρες, και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { @@ -5117,26 +5121,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + 'Το γέμισμα ολοκληρώθηκε. Εξάγωνα που σχεδιάστηκαν: {created}. Με νέα μορφοποίηση: {restyled}. Κρυμμένες τοποθεσίες: {icons}.', revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', - revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + revealedPage: 'Αποκαλύφθηκαν όλα τα εξάγωνα της σελίδας ({count}).', confirmReset: 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', undone: - 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', - named: 'Hexes με όνομα "{name}": {count}.', + 'Το τελευταίο γέμισμα αναιρέθηκε. Εξάγωνα που αφαιρέθηκαν: {removed}. Εξάγωνα που επανήλθαν στην αρχική μορφή: {restored}.', + named: 'Εξάγωνα με όνομα "{name}": {count}.', unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', marked: - 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + 'Τοποθεσίες κρυμμένες σε υπάρχοντα εξάγωνα: {attached}. Σε αναμονή για το επόμενο γέμισμα που θα τις καλύψει: {pending}.', unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', settingChanged: 'Το {setting} ορίστηκε σε {value}.', rescanned: - 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + 'Η επανασάρωση ολοκληρώθηκε. Διατηρήθηκαν: {kept}. Υιοθετήθηκαν: {adopted}. Μετακινήθηκαν: {moved}. Λείπουν και ξεχάστηκαν: {dropped}. Επανασυνδεδεμένες ετικέτες: {labels}. Επανασυνδεδεμένα διακριτικά τοποθεσίας: {icons}.', calibrated: - 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Το πλέγμα βαθμονομήθηκε (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', calibrationReset: - 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Η βαθμονόμηση καταργήθηκε. Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', @@ -5147,44 +5151,44 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο επίπεδο πρώτου πλάνου, οπότε τα εξάγωνα σχεδιάστηκαν στο επίπεδο διακριτικών.', someFailed: - 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + 'Εξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', }, errors: { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', - noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για γέμισμα.', emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', - nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', - nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή διακριτικά για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή διακριτικά για αποκάλυψη.', noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', - noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή διακριτικά που στέκονται σε εξάγωνα).', nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', unknownCommand: 'Άγνωστη εντολή: {command}', unknownSetting: 'Άγνωστη ρύθμιση: {key}', unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', - calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', unexpected: 'Κάτι πήγε στραβά: {message}', }, hints: { noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', - notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + notHex: 'Ορίστε το πλέγμα της σελίδας σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', noPolygons: - 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', - emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα με ελεύθερο χέρι γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος της σελίδας.', tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', noHexes: - 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + 'Τα εξάγωνα βρίσκονται στο επίπεδο πρώτου πλάνου ή στο επίπεδο διακριτικών· μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', calibrateNeedsTokens: - 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + 'Κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό κουμπωμένο σε γειτονικό εξάγωνο της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', calibrateFailed: - 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + 'Τα δύο διακριτικά πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), σε απόσταση τουλάχιστον ενός εξαγώνου μεταξύ τους.', unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', }, help: { @@ -5193,21 +5197,21 @@ const HexplorationMod = (() => { fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', reveal: - 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και διακριτικά.', revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', - conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', - explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + conceal: 'Καλύψτε ξανά με εξάγωνα την περιοχή κάτω από τα επιλεγμένα σχήματα και διακριτικά.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', - unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + unmark: 'Τα επιλεγμένα διακριτικά παύουν να είναι κρυφές τοποθεσίες.', set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: - 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', @@ -5220,18 +5224,18 @@ const HexplorationMod = (() => { revealDesc: 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: - 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα εξάγωνα. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', }, handout: { - versionLabel: 'Εκδοχή', - subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + versionLabel: 'Έκδοση', + subtitle: 'Εξερεύνηση εξάγωνο προς εξάγωνο για το Roll20', footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', overview: { heading: 'Επισκόπηση', - body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + body: 'Το Hexploration καλύπτει έναν εξαγωνικό χάρτη με αδιαφανή εξάγωνα. Καθώς η ομάδα κινείται, τα εξάγωνα από τα οποία περνά (και, αν θέλετε, τα εξάγωνα γύρω της) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', }, quickStart: { @@ -5247,7 +5251,7 @@ const HexplorationMod = (() => { commands: { heading: 'Εντολές', intro: - 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότερες ενεργούν στα επιλεγμένα αντικείμενα· οι υπόλοιπες ενεργούν στη σελίδα που βλέπετε.', colCommand: 'Εντολή', colDesc: 'Τι κάνει', }, @@ -5264,11 +5268,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Με όνομα Hexes and Locations', + heading: 'Εξάγωνα με όνομα και τοποθεσίες', points: [ 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', - 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', - 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν κάνετε γέμισμα, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλυφθεί, επιστρέφουν στο επίπεδο διακριτικών με ορατό το όνομά τους και η ανακάλυψή τους ανακοινώνεται.', 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], @@ -5278,14 +5282,14 @@ const HexplorationMod = (() => { intro: 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', - colName: 'Σύνθεση', + colName: 'Ρύθμιση', colDesc: 'Περιγραφή', perPage: '(Μπορεί να οριστεί ανά σελίδα.)', }, jumpgate: { heading: 'Jumpgate και Legacy', points: [ - 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Το Hexploration εντοπίζει ποια μηχανή χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που έχουν σχεδιαστεί σε οποιονδήποτε από τους δύο επεξεργαστές μπορούν να γεμιστούν.', 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', @@ -5317,12 +5321,12 @@ const HexplorationMod = (() => { body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', colNative: 'Όνομα στη γλώσσα της', - colCode: 'Κώδικας', + colCode: 'Κωδικός', }, credits: { - heading: 'Πιστώσεις', + heading: 'Συντελεστές', original: 'Πρωτότυπο mod από', - maintainer: 'Έκδοση 2 που διατηρείται από', + maintainer: 'Η έκδοση 2 συντηρείται από', marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', support: 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', @@ -5419,19 +5423,19 @@ const HexplorationMod = (() => { }, hexLayer: { label: 'שכבת המשושים', - desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים), ואם המשחק אינו תומך בה, משתמש בשכבת האסימונים.', }, fillColor: { label: 'צבע מילוי', - desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + desc: 'צבע המשושים החדשים. השתמש ב-rgba() למשושים שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { label: 'צבע מסגרת', - desc: 'צבע קווי המתאר של משושות חדשות.', + desc: 'צבע קווי המתאר של משושים חדשים.', }, labelColor: { label: 'צבע תווית', - desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + desc: 'צבע תוויות השם, הגלויות ל-GM בלבד, על משושים בעלי שם.', }, glimpseColor: { label: 'צבע הצצה', @@ -5495,45 +5499,47 @@ const HexplorationMod = (() => { filled: 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', revealed: 'נחשפו משושים: {count}.', - revealedPage: 'כל hex בדף נחשף ({count}).', + revealedPage: 'כל המשושים בדף נחשפו ({count}).', confirmReset: - 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', - resetPage: 'הקסים הוסרו מהדף: {count}.', - undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', - named: 'hexes בשם "{name}": {count}.', + 'להסיר את כל המשושים מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימונים. לא ניתן לבטל את זה.', + resetPage: 'משושים שהוסרו מהדף: {count}.', + undone: + 'המילוי האחרון בוטל. משושים שהוסרו: {removed}. משושים ששוחזר עיצובם המקורי: {restored}.', + named: 'משושים בשם "{name}": {count}.', unnamed: 'שמות נוקו: {count}.', - marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + marked: + 'מיקומים שהוסתרו במשושים קיימים: {attached}. ממתינים למילוי הבא שיכסה אותם: {pending}.', unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', settingChanged: '{setting} מוגדר ל-{value}.', rescanned: - 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + 'הסריקה מחדש הושלמה. נשמרו: {kept}. אומצו: {adopted}. שויכו מחדש: {moved}. חסרים ונשכחו: {dropped}. תוויות שקושרו מחדש: {labels}. אסימוני מיקום שקושרו מחדש: {icons}.', calibrated: - 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + 'הרשת כוילה (מרווח עמודות {colStep}px, מרווח שורות {rowStep}px). סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', calibrationReset: - 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + 'הכיול הוסר. סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: - 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי לאתר שוב את המשושים שלו.', readyHint: 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: - 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', - someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + 'משחק זה אינו תומך בציור על שכבת החזית, ולכן המשושים צוירו על שכבת האסימונים.', + someFailed: 'משושים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', }, errors: { noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', - notHex: 'דף זה אינו משתמש ברשת משושה.', + notHex: 'דף זה אינו משתמש ברשת משושים.', noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', - emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', - tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי משושים.', + tooMany: 'זה ייצור יותר מדי משושים בבת אחת ({count}).', nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', noTokens: 'תחילה בחר אסימון אחד או יותר.', - noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + noHexes: 'בחר תחילה משושה אחד או יותר (או אסימונים העומדים על משושים).', nothingToUndo: 'אין מילוי לבטל.', unknownCommand: 'פקודה לא ידועה: {command}', unknownSetting: 'הגדרה לא ידועה: {key}', @@ -5545,38 +5551,38 @@ const HexplorationMod = (() => { }, hints: { noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', - notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + notHex: 'הגדר את רשת הדף ל-Hex (V) או Hex (H) בהגדרות הדף.', noPolygons: 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', - emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות הרשת של הדף.', tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', calibrateNeedsTokens: - 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שהוצמד למשושה סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', calibrateFailed: - 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + 'שני האסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), במרחק של משושה אחד לפחות זה מזה.', unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', }, help: { menu: 'הצג את התפריט.', - fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fill: 'כסה את הצורות המצוירות שנבחרו במשושים.', fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', - undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + undo: 'בטל את המילוי, המילוי ההפוך או ההסתרה האחרונים, ושחזר את הצורות שבהן נעשה שימוש.', reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', - revealPage: 'חשוף כל קסם בדף ללא הודעות.', - conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + revealPage: 'חשוף את כל המשושים בדף ללא הכרזות.', + conceal: 'כסה שוב במשושים את השטח שמתחת לצורות ולאסימונים שנבחרו.', explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', - resetPage: 'הסר כל hex בדף (שואל תחילה).', - name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + resetPage: 'הסר את כל המשושים בדף (מבקש אישור תחילה).', + name: 'תן שם למשושים שנבחרו, או למשושים שמתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', - unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + unmark: 'הפסק להתייחס לאסימונים שנבחרו כמיקומים מוסתרים.', set: 'שנה הגדרה או הצג את כל ההגדרות.', pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', pageClear: 'הסר את העקיפות של הדף הנוכחי.', - rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', - calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + rescan: 'בנה מחדש את רשימת המשושים של הדף, למשל לאחר העתקת דף או משחק.', + calibrate: 'יישר את רשת המשושים לפי אסימון אחד או שניים שנבחרו ומוצמדים למרכזי משושים.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', @@ -5594,7 +5600,7 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'גִרְסָה', - subtitle: 'חקירה משושה אחר קסם עבור Roll20', + subtitle: 'חקירה משושה אחר משושה עבור Roll20', footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', @@ -5619,7 +5625,7 @@ const HexplorationMod = (() => { colDesc: 'מה זה עושה', }, revealing: { - heading: 'איך עובד גילוי', + heading: 'איך החשיפה עובדת', points: [ 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', @@ -5631,11 +5637,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'בשם משושים ומיקומים', + heading: 'משושים בעלי שם ומיקומים', points: [ 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', - 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'אסימוני מיקום מוסתרים מועברים לשכבת ה-GM. כאשר המשושה שלהם נחשף הם חוזרים לשכבת האסימונים כששמם מוצג, והגילוי שלהם מוכרז.', 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], @@ -5645,7 +5651,7 @@ const HexplorationMod = (() => { intro: 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', - colName: 'סְבִיבָה', + colName: 'הגדרה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, @@ -5659,15 +5665,15 @@ const HexplorationMod = (() => { ], }, upgrading: { - heading: 'משדרג מגרסה 1', + heading: 'שדרוג מגרסה 1', points: [ 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', - 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'מפות משושים קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהפעלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], - colV1: 'פקודה גרסה 1', - colV2: 'פקודה גרסה 2', + colV1: 'פקודה בגרסה 1', + colV2: 'פקודה בגרסה 2', }, troubleshooting: { heading: 'פתרון בעיות', @@ -5675,7 +5681,7 @@ const HexplorationMod = (() => { 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', - 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'מילוי אומר שלאזור אין מרכזי משושים: הצורה חייבת להכיל את המרכז של משושה אחד לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], }, @@ -5790,7 +5796,7 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Kitöltés színe', - desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + desc: 'Új hatszögek színe. Áttetsző hatszögekhez használjon rgba()-t, például rgba(0,0,0,0.8).', }, strokeColor: { label: 'Szegély színe', @@ -5798,7 +5804,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Címke színe', - desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + desc: 'A csak GM-nek szánt névcímkék színe az elnevezett hatszögeken.', }, glimpseColor: { label: 'Bepillantás színe', @@ -5814,7 +5820,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Látótávolság', - desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + desc: 'Hány hatszög fedődik fel egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket fedi fel, amelyeken a token áthalad.', }, lineOfSight: { label: 'Látóvonal', @@ -5822,11 +5828,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Felfedés az útvonal mentén', - desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + desc: 'Ha be van kapcsolva, minden hatszög felfedődik, amelyen a token a húzás közben áthalad (az útpontokat is beleértve), nem csak az, ahol megáll.', }, revealBy: { label: 'Felfedő tokenek', - desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + desc: 'Mely tokenek fedik fel a hatszögeket a tokenrétegen: a játékos által irányított tokenek, a bármely karaktert ábrázoló tokenek vagy minden token.', }, revealMode: { label: 'Felfedési mód', @@ -5842,7 +5848,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Lefedett tokenek elrejtése', - desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + desc: 'A Roll20 a neveket, sávokat és aurákat a hatszögek fölé rajzolja. Ha be van kapcsolva, a lefedett hatszög alatti tokenek játékosok által látható neve, sávjai és aurái kikapcsolnak, majd a tokenek felfedésekor újra bekapcsolnak.', }, }, status: { @@ -5862,25 +5868,25 @@ const HexplorationMod = (() => { filled: 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', revealed: 'Felfedezett hatszögek: {count}.', - revealedPage: 'Az oldalon minden hex látható ({count}).', + revealedPage: 'Az oldal minden hatszöge felfedve ({count}).', confirmReset: - 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + 'Eltávolítja az összes hatszöget innen: „{page}” ({count})? A helyszíntokenek visszakerülnek a tokenrétegre. A visszavonás ezt nem tudja visszafordítani.', resetPage: 'Az oldalról eltávolított hatszögek: {count}.', undone: 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', named: '"{name}" nevű hatszögek: {count}.', unnamed: 'Törölt nevek: {count}.', marked: - 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + 'Meglévő hatszögekben rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', unmarked: 'Tokenek, amelyek már nem helyek: {count}.', settingChanged: '{setting} értéke {value}.', rescanned: - 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Áthelyezve: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', calibrated: - 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', calibrationReset: - 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', - journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', + journalRebuilt: 'A(z) „{help}” és „{deck}” tájékoztató újra elkészült.', migrated: 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: @@ -5890,26 +5896,26 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + 'Ez a játék nem támogatja az előtérrétegre való rajzolást, ezért a hatszögek a tokenrétegre kerültek.', someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', }, errors: { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', - notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + notHex: 'Ez az oldal nem használ hatszögrácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', - tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', - nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + tooMany: 'Ez túl sok hatszöget hozna létre egyszerre ({count}).', + nothingToConceal: 'Jelölje ki az elrejtendő rajzolt alakzatokat vagy tokeneket.', nothingToReveal: - 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + 'Válassza ki a hatszögeket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', noTokens: 'Először válasszon ki egy vagy több tokent.', - noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + noHexes: 'Először jelöljön ki egy vagy több hatszöget (vagy hatszögön álló tokent).', nothingToUndo: 'Nincs visszavonható kitöltés.', unknownCommand: 'Ismeretlen parancs: {command}', unknownSetting: 'Ismeretlen beállítás: {key}', unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', - calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateNeedsTokens: 'Jelöljön ki egy vagy két, hatszögközéppontra illesztett tokent.', calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', unexpected: 'Hiba történt: {message}', }, @@ -5932,17 +5938,17 @@ const HexplorationMod = (() => { }, help: { menu: 'Mutasd a menüt.', - fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fill: 'Fedje le a kijelölt rajzolt alakzatokat hatszögekkel.', fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', reveal: 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', - revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + revealPage: 'Fedjen fel minden hatszöget az oldalon bejelentések nélkül.', conceal: - 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögekkel.', explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', - resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', - name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + resetPage: 'Távolítson el minden hatszöget az oldalon (először rákérdez).', + name: 'Nevezze el a kijelölt hatszögeket vagy a kijelölt tokenek alatti hatszögeket. A név törléséhez hagyja üresen.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', @@ -5950,7 +5956,7 @@ const HexplorationMod = (() => { pageClear: 'Távolítsa el az aktuális oldal felülírásait.', rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: - 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + 'Igazítsa a hatszögrácsot egy vagy két kijelölt, hatszögközéppontra illesztett tokenhez.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', @@ -5963,24 +5969,24 @@ const HexplorationMod = (() => { revealDesc: 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: - 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + 'Jelöljön ki tokeneket, hogy helyszínként elrejtse őket a hatszögek alatt. Jelöljön ki hatszögeket vagy tokeneket egy hatszög elnevezéséhez.', toolsDesc: 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', }, handout: { versionLabel: 'Változat', - subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + subtitle: 'Hatszögről hatszögre haladó felfedezés a Roll20-hoz', footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', - demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verzióból)', }, quickStart: { heading: 'Gyors kezdés', steps: [ - 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Nyisson meg egy oldalt, amelynek rácsa Hex (V) vagy Hex (H) beállítású.', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', @@ -6007,20 +6013,20 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexák és helyek neve', + heading: 'Elnevezett hatszögek és helyszínek', points: [ 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', - 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük felfedődik, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { - heading: 'Beállítások elemre', + heading: 'Beállítások', intro: 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', - colKey: 'Kulcsfontosságú', + colKey: 'Kulcs', colName: 'Beállítás', colDesc: 'Leírás', perPage: '(Oldalonként beállítható.)', @@ -6028,7 +6034,7 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate és Legacy', points: [ - 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'A Hexploration megállapítja, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', @@ -6037,8 +6043,8 @@ const HexplorationMod = (() => { upgrading: { heading: 'Frissítés az 1-es verzióról', points: [ - 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', - 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML Builderre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hatszögtérképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], @@ -6052,7 +6058,7 @@ const HexplorationMod = (() => { 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', - 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + 'Minden más esetben ellenőrizze az API-konzol naplóját, és segítségkéréskor mellékelje az üzeneteit.', ], }, languages: { @@ -6063,12 +6069,12 @@ const HexplorationMod = (() => { colCode: 'Kód', }, credits: { - heading: 'Kredit', + heading: 'Készítők', original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: - 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + 'Ha hibát talál, vagy ötlete van, írjon a Roll20 Mod fórumba, vagy nyisson hibajegyet a GitHubon, és mellékelje az API-konzol naplójának üzeneteit.', }, }, }; @@ -6198,11 +6204,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Rivela lungo il percorso', - desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un segnalino mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', }, revealBy: { label: 'Segnalini che rivelano', - desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + desc: 'Quali segnalini sul livello dei segnalini rivelano esagoni: segnalini controllati da un giocatore, segnalini che rappresentano qualsiasi personaggio o tutti i segnalini.', }, revealMode: { label: 'Modalità di rivelazione', @@ -6214,11 +6220,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Ping sulle scoperte', - desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + desc: 'Quando è attivo, i giocatori ricevono un ping su una posizione con nome quando viene scoperta.', }, hideCoveredTokens: { label: 'Nascondi i segnalini coperti', - desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando è attivo, i segnalini sotto un esagono coperto hanno il nome visibile ai giocatori, le barre e le aure disattivati, e riattivati quando vengono scoperti.', }, }, status: { @@ -6236,11 +6242,11 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + 'Riempimento completato. Esagoni tracciati: {created}. Con stile aggiornato: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: - 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + 'Rimuovere ogni esagono da "{page}" ({count})? I segnalini di posizione tornano al livello dei segnalini. Annulla riempimento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', undone: 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', @@ -6248,14 +6254,14 @@ const HexplorationMod = (() => { unnamed: 'Nomi cancellati: {count}.', marked: 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', - unmarked: 'Token che non rappresentano più posizioni: {count}.', + unmarked: 'Segnalini che non rappresentano più posizioni: {count}.', settingChanged: '{setting} impostato su {value}.', rescanned: - 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + 'Nuova scansione completata. Conservati: {kept}. Adottati: {adopted}. Ricollocati: {moved}. Mancanti e dimenticati: {dropped}. Etichette ricollegate: {labels}. Segnalini di posizione ricollegati: {icons}.', calibrated: - 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', calibrationReset: - 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Calibrazione rimossa. Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', @@ -6266,7 +6272,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei segnalini.', someFailed: 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', }, @@ -6276,17 +6282,17 @@ const HexplorationMod = (() => { noPolygons: 'Seleziona una o più forme disegnate da riempire.', emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', - nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', - nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', - noTokens: 'Seleziona prima uno o più token.', - noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToConceal: 'Seleziona forme disegnate o segnalini da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o segnalini da rivelare.', + noTokens: 'Seleziona prima uno o più segnalini.', + noHexes: 'Seleziona prima uno o più esagoni (o segnalini che si trovano sugli esagoni).', nothingToUndo: "Non c'è nessun riempimento da annullare.", unknownCommand: 'Comando sconosciuto: {command}', unknownSetting: 'Impostazione sconosciuta: {key}', unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', invalidValue: '"{value}" non è un valore valido per {key}.', - calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', - calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + calibrateNeedsTokens: 'Seleziona uno o due segnalini agganciati ai centri degli esagoni.', + calibrateFailed: 'Questi segnalini non possono essere utilizzati per calibrare.', unexpected: 'Qualcosa è andato storto: {message}', }, hints: { @@ -6298,41 +6304,41 @@ const HexplorationMod = (() => { 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", noHexes: - 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + 'Gli esagoni si trovano sul livello in primo piano o sul livello dei segnalini; passa a quel livello per selezionarli.', unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: - 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + 'I due segnalini devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', }, help: { menu: 'Mostra il menù.', fill: 'Copri le forme disegnate selezionate con esagoni.', fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", - undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + undo: "Annulla l'ultimo riempimento, riempimento inverso o occultamento e ripristina le forme che ha usato.", reveal: - 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i segnalini selezionati.', revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', - conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", - explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + conceal: "Copri nuovamente con esagoni l'area sotto le forme e i segnalini selezionati.", + explore: 'Rivela attorno ai segnalini selezionati come se si fossero appena spostati lì.', resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', - name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', - mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', - unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i segnalini selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i segnalini selezionati in posizioni nascoste.', + unmark: 'Fai in modo che i segnalini selezionati non siano più posizioni nascoste.', set: "Modifica un'impostazione o mostra tutte le impostazioni.", - pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageSet: "Sostituisci un'impostazione di rivelazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: - 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + 'Allinea la griglia esagonale con uno o due segnalini selezionati agganciati ai centri degli esagoni.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', - handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + handout: 'Le istruzioni complete si trovano nella dispensa "{name}".', }, deck: { drawDesc: @@ -6340,18 +6346,18 @@ const HexplorationMod = (() => { revealDesc: 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: - 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + 'Seleziona i segnalini per nasconderli come posizioni sotto gli esagoni. Seleziona esagoni o segnalini per nominare un esagono.', toolsDesc: 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', - footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + footer: 'Consulta la dispensa "{help}" per le istruzioni complete.', }, handout: { versionLabel: 'Versione', subtitle: 'Esplorazione esagono per esagono per Roll20', - footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + footer: 'Usa la dispensa "{deck}" per i controlli con un clic.', overview: { heading: 'Panoramica', - body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + body: 'Hexploration copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.', demo: 'Guarda una breve demo (dalla versione 1)', }, quickStart: { @@ -6367,7 +6373,7 @@ const HexplorationMod = (() => { commands: { heading: 'Comandi', intro: - 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisce sulla pagina che stai visualizzando.', colCommand: 'Comando', colDesc: 'Cosa fa', }, @@ -6375,7 +6381,7 @@ const HexplorationMod = (() => { heading: 'Come funziona la rivelazione', points: [ 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', - 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i punti di passaggio.', 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', @@ -6387,8 +6393,8 @@ const HexplorationMod = (() => { heading: 'Esagoni e posizioni con nome', points: [ 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', - "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", - 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Anche i segnalini con l'indicatore di stato della torre bianca vengono trattati come posizioni quando riempi, come nella versione 1.", + 'I segnalini di posizione nascosti vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei segnalini con il loro nome mostrato e la loro scoperta viene annunciata.', "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], @@ -6398,14 +6404,14 @@ const HexplorationMod = (() => { intro: 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', - colName: 'Collocamento', + colName: 'Impostazione', colDesc: 'Descrizione', perPage: '(Può essere impostato per pagina.)', }, jumpgate: { heading: 'Jumpgate e Legacy', points: [ - "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + 'Hexploration determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.', "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', @@ -6567,7 +6573,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '視界距離', - desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + desc: '移動するトークンの周囲で何ヘクス先まで公開するか (0 ～ 20)。0 の場合は、トークンが通過するヘクスのみを公開します。', }, lineOfSight: { label: '視線', @@ -6579,7 +6585,7 @@ const HexplorationMod = (() => { }, revealBy: { label: '公開するトークン', - desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + desc: 'トークンレイヤー上のどのトークンがヘクスを公開するか: プレイヤーが操作するトークン、いずれかのキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { label: '公開モード', @@ -6591,7 +6597,7 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: '発見地点をピン', - desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + desc: 'オンにすると、名前付きの場所が発見されたときに、プレイヤーにその場所が ping されます。', }, hideCoveredTokens: { label: '覆われたトークンを隠す', @@ -6613,29 +6619,29 @@ const HexplorationMod = (() => { }, messages: { filled: - '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + '塗りつぶし完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」からすべてのヘクス ({count}) を削除しますか? 場所トークンはトークンレイヤーに戻ります。「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', named: '「{name}」という名前のヘクス: {count}。', unnamed: '削除された名前: {count}。', marked: - '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + '既存のヘクスに隠された場所: {attached}。それらを覆う次の塗りつぶしを待っている場所: {pending}。', unmarked: '場所ではなくなったトークン: {count}。', settingChanged: '{setting} を {value} に設定します。', rescanned: - '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + '再スキャンが完了しました。保持: {kept}。採用: {adopted}。再配置: {moved}。見つからず破棄: {dropped}。再リンクされたラベル: {labels}。再リンクされた場所トークン: {icons}。', calibrated: - 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', calibrationReset: - 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + '調整が削除されました。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x のヘクスマップがアップグレードされました。このゲームが Legacy ゲームからコピーされた場合は、各ヘクスマップページで再スキャンを実行してください。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: @@ -6651,7 +6657,7 @@ const HexplorationMod = (() => { noPage: '作業するページが見つかりませんでした。', notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', - emptyArea: '選択した領域には六角中心が含まれていません。', + emptyArea: '選択した領域にはヘクスの中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', @@ -6662,7 +6668,7 @@ const HexplorationMod = (() => { unknownSetting: '不明な設定: {key}', unknownPageSetting: 'ページごとに設定できる設定: {keys}', invalidValue: '「{value}」は、{key} の有効な値ではありません。', - calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateNeedsTokens: 'ヘクスの中心にスナップされた 1 つまたは 2 つのトークンを選択します。', calibrateFailed: 'これらのトークンは調整には使用できません。', unexpected: '問題が発生しました: {message}', }, @@ -6684,12 +6690,12 @@ const HexplorationMod = (() => { }, help: { menu: 'メニューを表示します。', - fill: '選択した描画形状を六角形で覆います。', + fill: '選択した描画形状をヘクスで覆います。', fillInverse: '選択した図形の内側を除いてページ全体を覆います。', - undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + undo: '最後の塗りつぶし、反転塗りつぶし、または「隠す」を元に戻し、使用した図形を復元します。', reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', - conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + conceal: '選択した図形とトークンの下の領域を再びヘクスで覆います。', explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', @@ -6700,7 +6706,7 @@ const HexplorationMod = (() => { pageClear: '現在のページのオーバーライドを削除します。', rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: - '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + 'ヘクスの中心にスナップした 1 つまたは 2 つの選択トークンに、ヘクスグリッドを合わせます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', journal: 'ヘルプと Command Deck の配布資料を再構築します。', @@ -6713,7 +6719,7 @@ const HexplorationMod = (() => { revealDesc: 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: - 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + 'トークンを選択すると、ヘクスの下に場所として隠せます。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', footer: '完全な手順については、配布資料「{help}」を参照してください。', @@ -6741,11 +6747,11 @@ const HexplorationMod = (() => { heading: 'コマンド', intro: 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', - colCommand: '指示', + colCommand: 'コマンド', colDesc: '何をするのか', }, revealing: { - heading: '暴露の仕組み', + heading: '公開の仕組み', points: [ 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', @@ -6760,8 +6766,8 @@ const HexplorationMod = (() => { heading: '名前付きヘクスと場所', points: [ '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', - 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', - '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'バージョン 1 と同様に、白い塔のステータスマーカーが付いたトークンも、塗りつぶすときに場所として扱われます。', + '非表示の場所トークンは GM レイヤーに移動されます。そのヘクスが公開されると、名前が表示された状態でトークンレイヤーに戻り、発見がアナウンスされます。', '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], @@ -6770,7 +6776,7 @@ const HexplorationMod = (() => { heading: '設定', intro: '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', - colKey: '鍵', + colKey: 'キー', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', @@ -6788,7 +6794,7 @@ const HexplorationMod = (() => { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクスマップ、名前、場所トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], @@ -6920,11 +6926,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: '테두리 색상', - desc: '새로운 육각형의 윤곽선 색상입니다.', + desc: '새 헥스의 윤곽선 색상입니다.', }, labelColor: { label: '라벨 색상', - desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + desc: '이름이 지정된 헥스에 표시되는 GM 전용 이름 라벨의 색상입니다.', }, glimpseColor: { label: '반투명 색상', @@ -6940,7 +6946,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '시야 거리', - desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + desc: '움직이는 토큰 주변에서 공개되는 헥스 수입니다(0~20). 0이면 토큰이 통과하는 헥스만 공개합니다.', }, lineOfSight: { label: '시선', @@ -7001,11 +7007,11 @@ const HexplorationMod = (() => { unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: - '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + '다시 스캔이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 재배치됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', calibrated: - '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '그리드가 보정되었습니다(열 간격 {colStep}px, 행 간격 {rowStep}px). 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', calibrationReset: - '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '보정이 제거되었습니다. 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', @@ -7016,17 +7022,17 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', - someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 헥스를 그렸습니다.', + someFailed: '그릴 수 없는 헥스: {count}. 자세한 내용은 API 콘솔을 확인하세요.', }, errors: { noPage: '작업할 페이지를 찾을 수 없습니다.', - notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + notHex: '이 페이지는 헥스 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', - nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + nothingToReveal: '공개할 헥스, 그려진 도형 또는 토큰을 선택하세요.', noTokens: '먼저 하나 이상의 토큰을 선택하세요.', noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', nothingToUndo: '실행 취소할 채우기가 없습니다.', @@ -7034,7 +7040,7 @@ const HexplorationMod = (() => { unknownSetting: '알 수 없는 설정: {key}', unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', - calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateNeedsTokens: '헥스 중심에 스냅된 토큰을 하나 또는 두 개 선택하세요.', calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', unexpected: '문제가 발생했습니다: {message}', }, @@ -7045,7 +7051,7 @@ const HexplorationMod = (() => { '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', - noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + noHexes: '헥스는 전경 레이어나 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: @@ -7056,10 +7062,10 @@ const HexplorationMod = (() => { }, help: { menu: '메뉴를 보여주세요.', - fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fill: '선택한 그려진 도형을 헥스로 덮습니다.', fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', - undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', - reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + undo: '마지막 채우기, 반전 채우기 또는 숨기기를 취소하고, 사용한 도형을 복원합니다.', + reveal: '선택한 헥스와, 선택한 도형 및 토큰 아래의 헥스를 공개합니다.', revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', @@ -7124,11 +7130,11 @@ const HexplorationMod = (() => { '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 감지됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { - heading: '명명된 육각형 및 위치', + heading: '이름 붙은 헥스와 위치', points: [ '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', @@ -7141,8 +7147,8 @@ const HexplorationMod = (() => { heading: '설정', intro: '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', - colKey: '열쇠', - colName: '환경', + colKey: '키', + colName: '설정', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, @@ -7181,7 +7187,7 @@ const HexplorationMod = (() => { body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', colNative: '현지어 이름', - colCode: '암호', + colCode: '코드', }, credits: { heading: '크레딧', @@ -7282,7 +7288,7 @@ const HexplorationMod = (() => { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa heksagonów', + label: 'Warstwa heksów', desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { @@ -7295,7 +7301,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Kolor etykiety', - desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + desc: 'Kolor etykiet z nazwami tylko dla MG na nazwanych heksach.', }, glimpseColor: { label: 'Kolor przebłysku', @@ -7306,7 +7312,7 @@ const HexplorationMod = (() => { desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość odkrywania heksagonów', + label: 'Odległość odkrywania heksów', desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', }, revealDistance: { @@ -7315,11 +7321,11 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linia wzroku', - desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', }, revealPath: { label: 'Odkrywaj wzdłuż ścieżki', - desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + desc: 'Kiedy jest włączone, odkrywany jest każdy heks, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { label: 'Żetony odkrywające', @@ -7345,7 +7351,7 @@ const HexplorationMod = (() => { status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa heksagonów', + layer: 'Warstwa heksów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', @@ -7357,14 +7363,14 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + 'Wypełnienie zakończone. Narysowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', revealed: 'Ujawnione heksy: {count}.', - revealedPage: 'Każdy odkryty heks na stronie ({count}).', + revealedPage: 'Odkryto wszystkie heksy na stronie ({count}).', confirmReset: 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', resetPage: 'Heksy usunięte ze strony: {count}.', undone: - 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + 'Cofnięto ostatnie wypełnienie. Usunięte heksy: {removed}. Przywrócone heksy ze zmienionym stylem: {restored}.', named: 'Heksy o nazwie „{name}”: {count}.', unnamed: 'Nazwy zostały usunięte: {count}.', marked: @@ -7372,11 +7378,11 @@ const HexplorationMod = (() => { unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', settingChanged: '{setting} ustawiony na {value}.', rescanned: - 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Przeniesione: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', calibrated: - 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', calibrationReset: - 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', @@ -7431,7 +7437,7 @@ const HexplorationMod = (() => { menu: 'Pokaż menu.', fill: 'Zakryj wybrane narysowane kształty heksami.', fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', - undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + undo: 'Cofnij ostatnie wypełnienie, odwrotne wypełnienie lub zakrycie i przywróć użyte kształty.', reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', @@ -7466,12 +7472,11 @@ const HexplorationMod = (() => { handout: { versionLabel: 'Wersja', subtitle: 'Eksploracja heks po heksie dla Roll20', - footer: - 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + footer: 'Używaj materiału informacyjnego „{deck}”, aby sterować jednym kliknięciem.', overview: { heading: 'Przegląd', - body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', - demo: 'Obejrzyj krótkie demo (od wersji 1)', + body: 'Hexploration zakrywa mapę heksową nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (z wersji 1)', }, quickStart: { heading: 'Szybki start', @@ -7495,8 +7500,8 @@ const HexplorationMod = (() => { points: [ 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', - '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', - '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksów”.', + '„Odległość odkrywania heksów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', @@ -7505,27 +7510,27 @@ const HexplorationMod = (() => { locations: { heading: 'Nazwane heksy i lokalizacje', points: [ - 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które go zakryje.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', - 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę MG. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z widoczną nazwą, a ich odkrycie zostaje ogłoszone.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksów” jest ustawiona na warstwę żetonów.', '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', }, jumpgate: { - heading: 'Jumpgate i Dziedzictwo', + heading: 'Jumpgate i Legacy', points: [ - 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Hexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy „Warstwa heksów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], @@ -7559,7 +7564,7 @@ const HexplorationMod = (() => { colCode: 'Kod', }, credits: { - heading: 'Kredyty', + heading: 'Autorzy', original: 'Oryginalny mod autorstwa', maintainer: 'Wersja 2 obsługiwana przez', marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', @@ -7686,7 +7691,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos por onde a ficha passa.', }, lineOfSight: { label: 'Linha de visão', @@ -7694,7 +7699,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revelar ao longo do percurso', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + desc: 'Quando ativado, cada hexágono por onde uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde para.', }, revealBy: { label: 'Fichas que revelam', @@ -7714,7 +7719,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Ocultar fichas cobertas', - desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + desc: 'O Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, as fichas sob um hexágono coberto têm o seu nome, barras e auras visíveis para os jogadores desligados, que voltam a ser ligados quando as fichas são descobertas.', }, }, status: { @@ -7733,7 +7738,7 @@ const HexplorationMod = (() => { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', @@ -7743,15 +7748,15 @@ const HexplorationMod = (() => { named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', - unmarked: 'Tokens que já não são locais: {count}.', + 'Locais escondidos em hexágonos existentes: {attached}. A aguardar o próximo preenchimento que os cubra: {pending}.', + unmarked: 'Fichas que já não são locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + 'Reanálise concluída. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos novamente ligados: {labels}. Fichas de local novamente ligadas: {icons}.', calibrated: - 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grelha calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', @@ -7762,7 +7767,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que os hexágonos foram desenhados na camada de fichas.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', }, @@ -7774,15 +7779,15 @@ const HexplorationMod = (() => { tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', - noTokens: 'Selecione primeiro um ou mais tokens.', + noTokens: 'Selecione primeiro uma ou mais fichas.', noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', - nothingToUndo: 'Não há enchimento para desfazer.', + nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', - calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + calibrateFailed: 'Estas fichas não podem ser utilizadas para calibrar.', unexpected: 'Algo correu mal: {message}', }, hints: { @@ -7793,7 +7798,7 @@ const HexplorationMod = (() => { emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de fichas; mude para essa camada para os selecionar.', unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: @@ -7806,7 +7811,7 @@ const HexplorationMod = (() => { menu: 'Mostre o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que este utilizou.', reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', @@ -7814,9 +7819,9 @@ const HexplorationMod = (() => { explore: 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', - name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', - mark: 'Transforme os tokens selecionados em locais ocultos.', - unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob as fichas selecionadas. Deixe o nome vazio para o limpar.', + mark: 'Transforme as fichas selecionadas em locais ocultos.', + unmark: 'Faça com que as fichas selecionadas deixem de ser locais ocultos.', set: 'Altere uma definição ou mostre todas as definições.', pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', @@ -7838,7 +7843,7 @@ const HexplorationMod = (() => { locationsDesc: 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: - 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + 'Definições, substituições de páginas, estado, reanálise de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { @@ -7880,11 +7885,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', - 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'As fichas com o marcador de estado da torre branca também são tratadas como locais quando preenche, como na versão 1.', + 'As fichas de local ocultas são movidas para a camada do GM. Quando o seu hexágono é revelado, regressam à camada de fichas com o nome visível e a sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], @@ -7899,7 +7904,7 @@ const HexplorationMod = (() => { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', @@ -7938,7 +7943,7 @@ const HexplorationMod = (() => { credits: { heading: 'Créditos', original: 'Mod original de', - maintainer: 'Versão 2 mantida pela', + maintainer: 'Versão 2 mantida por', marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', support: 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', @@ -8059,11 +8064,11 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos ao redor de um token em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', }, lineOfSight: { label: 'Linha de visão', @@ -8071,11 +8076,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revelar ao longo do caminho', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + desc: 'Quando ativado, cada hexágono pelo qual um token passa enquanto é arrastado (incluindo pontos de passagem) é revelado, não apenas onde ele para.', }, revealBy: { label: 'Tokens que revelam', - desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + desc: 'Quais tokens na camada de tokens revelam hexágonos: tokens controlados por um jogador, tokens que representam qualquer personagem ou todos os tokens.', }, revealMode: { label: 'Modo de revelação', @@ -8110,7 +8115,7 @@ const HexplorationMod = (() => { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', @@ -8120,15 +8125,15 @@ const HexplorationMod = (() => { named: 'Hexágonos chamados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cubra: {pending}.', unmarked: 'Tokens que não são mais locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + 'Reescaneamento concluído. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de local vinculados novamente: {icons}.', calibrated: - 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grade calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', @@ -8139,7 +8144,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + 'Este jogo não suporta desenho na camada de primeiro plano, então os hexágonos foram desenhados na camada de tokens.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', }, @@ -8149,17 +8154,17 @@ const HexplorationMod = (() => { noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', - nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', - nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + nothingToConceal: 'Selecione formas desenhadas ou tokens para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou tokens para revelar.', noTokens: 'Selecione um ou mais tokens primeiro.', - noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou tokens sobre hexágonos) primeiro.', nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', - calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + calibrateFailed: 'Esses tokens não podem ser usados para calibrar.', unexpected: 'Algo deu errado: {message}', }, hints: { @@ -8170,7 +8175,7 @@ const HexplorationMod = (() => { emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', tooMany: 'Preencha uma área menor ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de tokens; mude para essa camada para selecioná-los.', unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: @@ -8183,11 +8188,11 @@ const HexplorationMod = (() => { menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que ele usou.', reveal: - 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + 'Revele os hexágonos selecionados e os hexágonos sob as formas e tokens selecionados.', revealPage: 'Revele cada hexágono da página sem anúncios.', - conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + conceal: 'Cubra novamente com hexágonos a área sob as formas e tokens selecionados.', explore: 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta antes).', @@ -8215,7 +8220,7 @@ const HexplorationMod = (() => { locationsDesc: 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: - 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + 'Configurações, substituições de páginas, status, reescaneamento de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { @@ -8257,11 +8262,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Os tokens de local ocultos são movidos para a camada do GM. Quando seu hexágono é revelado, eles retornam à camada de tokens com seu nome à mostra e sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], @@ -8276,7 +8281,7 @@ const HexplorationMod = (() => { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', @@ -8299,7 +8304,7 @@ const HexplorationMod = (() => { heading: 'Solução de problemas', points: [ 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', - 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos estão deslocados em relação à grade: use Calibrar e depois verifique com um token em alguns hexágonos pelo mapa.', 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', @@ -8308,7 +8313,7 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', - colLanguage: 'Linguagem', + colLanguage: 'Idioma', colNative: 'Nome original', colCode: 'Código', }, @@ -8411,12 +8416,12 @@ const HexplorationMod = (() => { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Слой шестиугольников', + label: 'Слой гексов', desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', - desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных гексов, например rgba(0,0,0,0.8).', }, strokeColor: { label: 'Цвет границы', @@ -8424,7 +8429,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Цвет меток', - desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + desc: 'Цвет меток с именами, предназначенными только для ГМ, на именованных гексах.', }, glimpseColor: { label: 'Цвет проблеска', @@ -8432,10 +8437,10 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Ширина границы', - desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + desc: 'Ширина контура новых гексов в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Дальность раскрытия шестиугольников', + label: 'Дальность раскрытия гексов', desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -8444,7 +8449,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Линия видимости', - desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия гексов», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', }, revealPath: { label: 'Раскрывать вдоль пути', @@ -8464,11 +8469,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Пинговать находки', - desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + desc: 'Если эта функция включена, при обнаружении именованной локации вид игроков переводится на неё.', }, hideCoveredTokens: { label: 'Скрывать токены под гексами', - desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, у токенов под закрытым гексом отключаются видимые игрокам имя, полосы и ауры, а когда токены открываются, они снова включаются.', }, }, status: { @@ -8491,21 +8496,21 @@ const HexplorationMod = (() => { revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', - resetPage: 'Со страницы удалены шестигранники: {count}.', + resetPage: 'Со страницы удалены гексы: {count}.', undone: - 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', - named: 'Шестигранники с именем "{name}": {count}.', + 'Последнее заполнение отменено. Удалены гексы: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Гексы с именем "{name}": {count}.', unnamed: 'Имена удалены: {count}.', marked: 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', unmarked: 'Токены, которые больше не являются локациями: {count}.', settingChanged: 'Для {setting} установлено значение {value}.', rescanned: - 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Перенесено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', calibrated: - 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', calibrationReset: - 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', @@ -8516,19 +8521,18 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому гексы рисовались на слое жетонов.', someFailed: 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', }, errors: { noPage: 'Не удалось найти страницу для работы.', - notHex: 'На этой странице не используется шестигранная сетка.', + notHex: 'На этой странице не используется гексовая сетка.', noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', - emptyArea: 'Выбранная область не содержит шестигранных центров.', - tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + emptyArea: 'Выбранная область не содержит центров гексов.', + tooMany: 'Это создаст слишком много гексов за один раз ({count}).', nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', - nothingToReveal: - 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + nothingToReveal: 'Выберите гексы, нарисованные фигуры или жетоны, чтобы их показать.', noTokens: 'Сначала выберите один или несколько жетонов.', noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', nothingToUndo: 'Нет заливки, которую можно было бы отменить.', @@ -8536,7 +8540,7 @@ const HexplorationMod = (() => { unknownSetting: 'Неизвестная настройка: {key}.', unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', invalidValue: '«{value}» не является допустимым значением для {key}.', - calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к центрам гексов.', calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', unexpected: 'Что-то пошло не так: {message}', }, @@ -8548,7 +8552,7 @@ const HexplorationMod = (() => { emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', noHexes: - 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + 'Гексы находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: @@ -8559,23 +8563,24 @@ const HexplorationMod = (() => { }, help: { menu: 'Покажите меню.', - fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fill: 'Покройте выбранные нарисованные фигуры гексами.', fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', - undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + undo: 'Отмените последнюю заливку, обратную заливку или скрытие и восстановите использованные фигуры.', reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', revealPage: 'Раскройте каждый гекс на странице без объявлений.', - conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', - explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами гексами.', + explore: + 'Раскройте гексы вокруг выбранных жетонов, как будто они только что туда переместились.', resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', - pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageSet: 'Переопределить настройку раскрытия только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: - 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + 'Выровняйте гексовую сетку с помощью одного или двух выбранных жетонов, привязанных к центрам гексов.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', @@ -8615,7 +8620,7 @@ const HexplorationMod = (() => { commands: { heading: 'Команды', intro: - 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + 'Только ГМ могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', colCommand: 'Команда', colDesc: 'Что он делает', }, @@ -8624,8 +8629,8 @@ const HexplorationMod = (() => { points: [ 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', - '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', - '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия гексов».', + '«Дальность раскрытия гексов» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия гексов» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', @@ -8636,25 +8641,25 @@ const HexplorationMod = (() => { points: [ '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', - 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', + 'Жетоны скрытых локаций перемещаются на слой ГМ. Когда их гекс раскрывается, они возвращаются на слой жетонов с показанным именем, и об их обнаружении объявляется.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой гексов» выбран слой токенов.', '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой гексов», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', perPage: '(Можно установить для каждой страницы.)', }, jumpgate: { - heading: 'Джампгейт и Наследие', + heading: 'Jumpgate и Legacy', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Если для «Слоя гексов» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], @@ -8688,7 +8693,7 @@ const HexplorationMod = (() => { colCode: 'Код', }, credits: { - heading: 'Кредиты', + heading: 'Авторы', original: 'Оригинальный мод от', maintainer: 'Версия 2 поддерживается', marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', @@ -8799,7 +8804,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Color de la etiqueta', - desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + desc: 'Color de las etiquetas de nombre, visibles solo para el DJ, en los hexágonos con nombre.', }, glimpseColor: { label: 'Color de vistazo', @@ -8843,7 +8848,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Ocultar fichas cubiertas', - desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + desc: 'Roll20 dibuja nombres, barras y auras sobre los hexágonos. Cuando está activado, las fichas bajo un hexágono cubierto tienen desactivados su nombre, barras y auras visibles para los jugadores, que se vuelven a activar cuando se descubren.', }, }, status: { @@ -8865,22 +8870,22 @@ const HexplorationMod = (() => { revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: - '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', - resetPage: 'Hexes eliminados de la página: {count}.', + '¿Eliminar todos los hexágonos de "{page}" ({count})? Las fichas de ubicación regresan a la capa de fichas. Deshacer no puede revertir esto.', + resetPage: 'Hexágonos eliminados de la página: {count}.', undone: 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nombres borrados: {count}.', marked: 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', - unmarked: 'Tokens que ya no son ubicaciones: {count}.', + unmarked: 'Fichas que ya no son ubicaciones: {count}.', settingChanged: '{setting} establecido en {value}.', rescanned: - 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + 'Nuevo escaneo completado. Conservados: {kept}. Adoptados: {adopted}. Reubicados: {moved}. Desaparecidos y olvidados: {dropped}. Etiquetas vinculadas de nuevo: {labels}. Fichas de ubicación vinculadas de nuevo: {icons}.', calibrated: - 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', calibrationReset: - 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Se eliminó la calibración. Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', @@ -8903,7 +8908,7 @@ const HexplorationMod = (() => { tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', - noTokens: 'Seleccione uno o más tokens primero.', + noTokens: 'Seleccione una o más fichas primero.', noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', nothingToUndo: 'No hay ningún relleno que deshacer.', unknownCommand: 'Comando desconocido: {command}', @@ -8928,33 +8933,33 @@ const HexplorationMod = (() => { unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', calibrateNeedsTokens: - 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', calibrateFailed: - 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + 'Las dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hexágono.', unexpected: 'Los detalles se encuentran en el registro de la consola API.', }, help: { menu: 'Mostrar el menú.', fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', - undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + undo: 'Deshace el último relleno, relleno inverso u ocultación, y restaura las formas que usó.', reveal: 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', revealPage: 'Revela cada hexágono de la página sin anuncios.', conceal: 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', - explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + explore: 'Revela alrededor de las fichas seleccionadas como si acabaran de moverse allí.', resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', - unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + unmark: 'Hace que las fichas seleccionadas dejen de ser ubicaciones ocultas.', set: 'Cambie una configuración o muestre todas las configuraciones.', pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: - 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas ajustadas a los centros de los hexágonos.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', @@ -8978,7 +8983,7 @@ const HexplorationMod = (() => { footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', overview: { heading: 'Descripción general', - body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + body: 'Hexploration cubre un mapa hexagonal con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', demo: 'Vea una breve demostración (de la versión 1)', }, quickStart: { @@ -8987,22 +8992,22 @@ const HexplorationMod = (() => { 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', - 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Opcional: antes de rellenar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Quedan ocultas debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], }, commands: { heading: 'Comandos', intro: - 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', - colCommand: 'Dominio', - colDesc: 'que hace', + 'Solo los DJ pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Comando', + colDesc: 'Qué hace', }, revealing: { heading: 'Cómo funciona la revelación', points: [ 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', - 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrada, incluidos los puntos de ruta.', 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', @@ -9014,8 +9019,8 @@ const HexplorationMod = (() => { heading: 'Hexágonos y ubicaciones con nombre', points: [ 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', - 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', - 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando rellenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa del DJ. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], @@ -9024,13 +9029,13 @@ const HexplorationMod = (() => { heading: 'Ajustes', intro: 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', - colKey: 'Llave', + colKey: 'Clave', colName: 'Configuración', colDesc: 'Descripción', perPage: '(Se puede configurar por página).', }, jumpgate: { - heading: 'Jumpgate y legado', + heading: 'Jumpgate y Legacy', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', @@ -9166,7 +9171,7 @@ const HexplorationMod = (() => { }, hexLayer: { label: 'Lager för hexar', - desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + desc: 'Var nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', @@ -9174,11 +9179,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: 'Kantfärg', - desc: 'Färg på konturerna av nya sexkanter.', + desc: 'Färg på konturerna av nya hexar.', }, labelColor: { label: 'Etikettfärg', - desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + desc: 'Färgen på namnetiketterna endast för GM på namngivna hexar.', }, glimpseColor: { label: 'Glimtfärg', @@ -9186,7 +9191,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Kantbredd', - desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + desc: 'Bredden på konturerna av nya hexar, i pixlar (0 till 20).', }, maxDistance: { label: 'Avslöjandeavstånd för hexar', @@ -9202,11 +9207,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Avslöja längs vägen', - desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive mellanpunkter), inte bara där den stannar.', }, revealBy: { label: 'Tokens som avslöjar', - desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + desc: 'Vilka tokens på tokenlagret som avslöjar hexar: tokens som kontrolleras av en spelare, tokens som representerar vilken rollperson som helst eller alla tokens.', }, revealMode: { label: 'Avslöjandeläge', @@ -9222,7 +9227,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Dölj täckta tokens', - desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexarna. När den är på stängs det namn, de staplar och de auror som spelarna kan se av för tokens under en täckt hex, och slås på igen när de avtäcks.', }, }, status: { @@ -9239,26 +9244,27 @@ const HexplorationMod = (() => { undo: 'Ångra tillgängligt', }, messages: { - filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', - revealed: 'Hexen avslöjade: {count}.', - revealedPage: 'Varje hex på sidan avslöjas ({count}).', + filled: + 'Fyllning klar. Ritade hexar: {created}. Omformaterade: {restyled}. Gömda platser: {icons}.', + revealed: 'Avslöjade hexar: {count}.', + revealedPage: 'Alla hexar på sidan avslöjade ({count}).', confirmReset: - 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', - resetPage: 'Hexen har tagits bort från sidan: {count}.', + 'Ta bort alla hexar från "{page}" ({count})? Platstokens återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexar som tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', - named: 'Hex med namnet "{name}": {count}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omformaterade hexar som återställts: {restored}.', + named: 'Hexar med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: - 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + 'Omsökningen är klar. Behållna: {kept}. Övertagna: {adopted}. Omplacerade: {moved}. Saknade och glömda: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', calibrated: - 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', calibrationReset: - 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', @@ -9269,25 +9275,25 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', - someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + 'Det här spelet stöder inte ritning på förgrundslagret, så hexarna ritades på tokenlagret.', + someFailed: 'Hexar som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', }, errors: { noPage: 'Kunde inte hitta sidan att arbeta på.', notHex: 'Den här sidan använder inte ett hex-rutnät.', noPolygons: 'Välj en eller flera ritade former att fylla.', - emptyArea: 'Det valda området innehåller inga hexa-center.', + emptyArea: 'Det valda området innehåller inga hexmittpunkter.', tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', nothingToConceal: 'Välj ritade former eller tokens att dölja.', - nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + nothingToReveal: 'Välj hexar, ritade former eller tokens att avslöja.', noTokens: 'Välj först en eller flera tokens.', - noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + noHexes: 'Välj en eller flera hexar (eller tokens som står på hexar) först.', nothingToUndo: 'Det finns ingen fyllning att ångra.', unknownCommand: 'Okänt kommando: {command}', unknownSetting: 'Okänd inställning: {key}', unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', invalidValue: '"{value}" är inte ett giltigt värde för {key}.', - calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateNeedsTokens: 'Välj en eller två tokens som är fästa i hexmittpunkter.', calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', unexpected: 'Något gick fel: {message}', }, @@ -9298,7 +9304,8 @@ const HexplorationMod = (() => { 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', tooMany: 'Fyll ett mindre område, eller dela området i flera former.', - noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + noHexes: + 'Hexarna ligger på förgrundslagret eller tokenlagret; växla till det lagret för att välja dem.', unknownCommand: 'Skriv !hexploration help för att lista kommandona.', unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', calibrateNeedsTokens: @@ -9309,15 +9316,15 @@ const HexplorationMod = (() => { }, help: { menu: 'Visa menyn.', - fill: 'Täck de utvalda ritade formerna med hex.', + fill: 'Täck de valda ritade formerna med hexar.', fillInverse: 'Täck hela sidan utom inuti de valda formerna.', - undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', - reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', - revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', - conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + undo: 'Ångra den senaste fyllningen, omvända fyllningen eller döljningen och återställ formerna den använde.', + reveal: 'Avslöja de valda hexarna och hexarna under de valda formerna och tokens.', + revealPage: 'Avslöja alla hexar på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och tokens med hexar igen.', explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', - resetPage: 'Ta bort varje hex på sidan (frågar först).', - name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + resetPage: 'Ta bort alla hexar på sidan (frågar först).', + name: 'Namnge de valda hexarna, eller hexarna under de valda tokens. Lämna namnet tomt för att rensa det.', mark: 'Förvandla de valda tokens till dolda platser.', unmark: 'Stoppa de valda tokens från att vara dolda platser.', set: 'Ändra en inställning eller visa alla inställningar.', @@ -9325,7 +9332,8 @@ const HexplorationMod = (() => { pageClear: 'Ta bort den aktuella sidans åsidosättningar.', rescan: 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', - calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrate: + 'Rikta in hex-rutnätet efter en eller två valda tokens som är fästa i hexmittpunkter.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', journal: 'Bygg om handouterna Help och Command Deck.', @@ -9338,18 +9346,18 @@ const HexplorationMod = (() => { revealDesc: 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: - 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + 'Välj tokens för att dölja dem som platser under hexar. Välj hexar eller tokens för att namnge en hex.', toolsDesc: 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', footer: 'Se "{help}"-handouten för fullständiga instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-utforskning för Roll20', + subtitle: 'Utforskning hex för hex i Roll20', footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', overview: { heading: 'Översikt', - body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + body: 'Hexploration täcker en hexkarta med ogenomskinliga hexar. När sällskapet rör sig tas hexarna det passerar igenom (och, om du vill, hexarna runt det) bort, så att kartan avslöjas en hex i taget. Dolda platser kan placeras under hexar och tillkännages när de hittas. Det fungerar i Jumpgate- och Legacy-spel, på Hex (V)- och Hex (H)-rutnät av alla storlekar.', demo: 'Se en kort demo (från version 1)', }, quickStart: { @@ -9358,7 +9366,7 @@ const HexplorationMod = (() => { 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', - 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De göms under hexarna och tillkännages när de upptäcks.', 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, @@ -9382,11 +9390,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Namngivna Hex och platser', + heading: 'Namngivna hexar och platser', points: [ 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', - 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Dolda platstokens flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med sitt namn visat, och deras upptäckt tillkännages.', 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], @@ -9396,7 +9404,7 @@ const HexplorationMod = (() => { intro: 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', - colName: 'Miljö', + colName: 'Inställning', colDesc: 'Beskrivning', perPage: '(Kan ställas in per sida.)', }, @@ -9424,7 +9432,7 @@ const HexplorationMod = (() => { heading: 'Felsökning', points: [ 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', - 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexarna är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', @@ -9432,13 +9440,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Språk', - body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + body: 'Välj ett språk med !hexploration set language. Tillgängliga språk:', colLanguage: 'Språk', colNative: 'Eget namn', - colCode: 'Koda', + colCode: 'Kod', }, credits: { - heading: 'Krediter', + heading: 'Medverkande', original: 'Originalmod av', maintainer: 'Version 2 underhålls av', marketplace: 'Adas konstpaket på Roll20 Marketplace', @@ -9565,7 +9573,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Görüş Mesafesi', - desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + desc: 'Hareket eden bir jetonun çevresinde kaç altıgenin açığa çıkacağı (0 ila 20). 0 yalnızca jetonun geçtiği altıgenleri açığa çıkarır.', }, lineOfSight: { label: 'Görüş Hattı', @@ -9573,7 +9581,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Yol Boyunca Açığa Çıkar', - desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + desc: 'Açık olduğunda, bir jetonun yalnızca durduğu yer değil, sürüklenirken geçtiği her altıgen (ara noktalar dahil) açığa çıkar.', }, revealBy: { label: 'Açığa Çıkaran Jetonlar', @@ -9589,11 +9597,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Keşifleri Pingle', - desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + desc: 'Açık olduğunda, adlandırılmış bir konum keşfedildiğinde oyunculara o konuma ping atılır.', }, hideCoveredTokens: { label: 'Örtülü Jetonları Gizle', - desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + desc: 'Roll20 adları, çubukları ve auraları altıgenlerin üzerine çizer. Açıkken, örtülü bir altıgenin altındaki jetonların oyunculara görünen adı, çubukları ve auraları kapatılır ve açığa çıktıklarında yeniden açılır.', }, }, status: { @@ -9612,10 +9620,10 @@ const HexplorationMod = (() => { messages: { filled: 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', - revealed: 'Büyüler ortaya çıktı: {count}.', + revealed: 'Açığa çıkan altıgenler: {count}.', revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: - '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + '"{page}" sayfasındaki tüm altıgenler ({count}) kaldırılsın mı? Konum jetonları jeton katmanına geri döner. Geri Al bunu tersine çeviremez.', resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', @@ -9640,7 +9648,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, altıgenler jeton katmanına çizildi.', someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', }, errors: { @@ -9649,7 +9657,7 @@ const HexplorationMod = (() => { noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', - nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya jetonları seçin.', nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', noTokens: 'Önce bir veya daha fazla jeton seçin.', noHexes: @@ -9671,7 +9679,7 @@ const HexplorationMod = (() => { emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', noHexes: - 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + 'Altıgenler ön plan katmanında veya jeton katmanındadır; bunları seçmek için o katmana geçin.', unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: @@ -9684,18 +9692,18 @@ const HexplorationMod = (() => { menu: 'Menüyü göster.', fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', - undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + undo: 'Son doldurmayı, ters doldurmayı veya gizlemeyi geri alın ve kullandığı şekilleri geri yükleyin.', reveal: - 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + 'Seçilen altıgenleri ve seçilen şekillerin ve jetonların altındaki altıgenleri açığa çıkarın.', revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', - name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + name: 'Seçilen altıgenleri veya seçilen jetonların altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', mark: 'Seçilen jetonları gizli konumlara dönüştürün.', - unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + unmark: 'Seçilen jetonların gizli konum olmasını sonlandırın.', set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', - pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageSet: 'Yalnızca geçerli sayfadaki bir açığa çıkarma ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', @@ -9713,14 +9721,14 @@ const HexplorationMod = (() => { revealDesc: 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: - 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + 'Jetonları altıgenlerin altında konum olarak gizlemek için seçin. Bir altıgeni adlandırmak için altıgenleri veya jetonları seçin.', toolsDesc: 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', }, handout: { versionLabel: 'Sürüm', - subtitle: 'Roll20 için hex-hex keşif', + subtitle: 'Roll20 için altıgen altıgen keşif', footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', @@ -9740,8 +9748,8 @@ const HexplorationMod = (() => { commands: { heading: 'Komutlar', intro: - "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", - colCommand: 'Emretmek', + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçili nesneler üzerinde çalışır; geri kalanı görüntülediğiniz sayfada çalışır.", + colCommand: 'Komut', colDesc: 'Ne işe yarar', }, revealing: { @@ -9761,7 +9769,7 @@ const HexplorationMod = (() => { points: [ 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", - 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + 'Gizli konum jetonları GM katmanına taşınır. Altıgenleri açığa çıktığında adları görünür şekilde jeton katmanına geri dönerler ve keşifleri duyurulur.', "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], @@ -9776,7 +9784,7 @@ const HexplorationMod = (() => { perPage: '(Sayfa başına ayarlanabilir.)', }, jumpgate: { - heading: 'Jumpgate ve Eski', + heading: 'Jumpgate ve Legacy', points: [ 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', @@ -9788,7 +9796,7 @@ const HexplorationMod = (() => { heading: "Sürüm 1'den yükseltme", points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", - 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Mevcut altıgen haritalar, adlar, konum jetonları ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], @@ -9813,9 +9821,9 @@ const HexplorationMod = (() => { colCode: 'Kod', }, credits: { - heading: 'Kredi', + heading: 'Emeği Geçenler', original: 'Orijinal modun yapımcısı', - maintainer: 'Versiyon 2 tarafından sürdürülen', + maintainer: "Sürüm 2'nin bakımını yapan", marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", @@ -9911,12 +9919,12 @@ const HexplorationMod = (() => { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шар шестикутників', + label: 'Шар гексів', desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', - desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих гексів, наприклад rgba(0,0,0,0.8).', }, strokeColor: { label: 'Колір контуру', @@ -9935,7 +9943,7 @@ const HexplorationMod = (() => { desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Відстань розкриття шестикутників', + label: 'Відстань розкриття гексів', desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { @@ -9944,7 +9952,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Лінія видимості', - desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття гексів», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', }, revealPath: { label: 'Розкривати вздовж шляху', @@ -9960,21 +9968,21 @@ const HexplorationMod = (() => { }, announce: { label: 'Оголошувати відкриття', - desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + desc: 'Хто бачить повідомлення в чаті, коли виявлено іменовану локацію.', }, pingDiscoveries: { label: 'Пінгувати знахідки', - desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + desc: 'Коли ввімкнено, під час виявлення іменованої локації погляд гравців переміщується до неї.', }, hideCoveredTokens: { label: 'Ховати маркери під гексами', - desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, у маркерів під закритим гексом вимикаються видимі гравцям ім’я, смужки та аури, а коли маркери відкривають, вони знову вмикаються.', }, }, status: { engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шар шестикутників', + layer: 'Шар гексів', hexes: 'Гекси', named: 'Іменовані гекси', icons: 'Маркери локацій', @@ -9991,7 +9999,7 @@ const HexplorationMod = (() => { revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', - resetPage: 'Зі сторінки видалено шестигранники: {count}.', + resetPage: 'Зі сторінки видалено гекси: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', named: 'Гекси з назвою "{name}": {count}.', @@ -10001,11 +10009,11 @@ const HexplorationMod = (() => { unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', settingChanged: '{setting} встановлено на {value}.', rescanned: - 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Переміщено: {moved}. Відсутні й забуті: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', calibrated: - 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', calibrationReset: - 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Калібрування видалено. Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', @@ -10024,10 +10032,10 @@ const HexplorationMod = (() => { noPage: 'Не вдалося знайти сторінку для роботи.', notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', - emptyArea: 'Вибрана область не містить шестигранних центрів.', + emptyArea: 'Вибрана область не містить центрів гексів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', - nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + nothingToReveal: 'Виберіть гекси, намальовані фігури або жетони, щоб розкрити їх.', noTokens: 'Спочатку виберіть один або кілька токенів.', noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', nothingToUndo: 'Немає заповнення, яке можна скасувати.', @@ -10035,7 +10043,7 @@ const HexplorationMod = (() => { unknownSetting: 'Невідоме налаштування: {key}', unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', invalidValue: '"{value}" не є дійсним значенням для {key}.', - calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до центрів гексів.', calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', unexpected: 'Щось пішло не так: {message}', }, @@ -10051,26 +10059,26 @@ const HexplorationMod = (() => { unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', calibrateNeedsTokens: - 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + 'Прив’яжіть жетон до центру гекса та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього гекса в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір гекса.', calibrateFailed: - 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гекс.', unexpected: 'Подробиці в журналі консолі API.', }, help: { menu: 'Показати меню.', - fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fill: 'Покрийте вибрані намальовані форми гексами.', fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', - conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами гексами.', explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', mark: 'Перетворіть вибрані жетони на приховані місця.', - unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + unmark: 'Зробіть так, щоб вибрані маркери більше не були прихованими місцями.', set: 'Змінити налаштування або показати всі налаштування.', - pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageSet: 'Перевизначити налаштування розкриття лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: @@ -10098,7 +10106,7 @@ const HexplorationMod = (() => { footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', - body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + body: 'Hexploration накриває гексову карту непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', demo: 'Перегляньте коротку демонстрацію (з версії 1)', }, quickStart: { @@ -10123,8 +10131,8 @@ const HexplorationMod = (() => { points: [ 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', - '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', - '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття гексів».', + '«Відстань розкриття гексів» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття гексів» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', @@ -10135,25 +10143,25 @@ const HexplorationMod = (() => { points: [ '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', - 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', + 'Маркери прихованих локацій переміщуються на шар GM. Коли їхній гекс розкривається, вони повертаються на шар маркерів із показаним ім’ям, а про їхнє виявлення оголошується.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар гексів» вибрано шар маркерів.', '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', - colKey: 'ключ', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар гексів», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', + colKey: 'Ключ', colName: 'Налаштування', - colDesc: 'опис', + colDesc: 'Опис', perPage: '(Можна встановити на сторінку.)', }, jumpgate: { heading: 'Jumpgate і Legacy', points: [ - 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Hexploration визначає, який рушій використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для «Шару гексів» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], @@ -10187,7 +10195,7 @@ const HexplorationMod = (() => { colCode: 'Код', }, credits: { - heading: 'Кредити', + heading: 'Автори', original: 'Оригінальний мод від', maintainer: 'Версія 2 підтримується', marketplace: 'Художні набори Ади на Roll20 Marketplace', diff --git a/Hexploration/Hexploration.js b/Hexploration/Hexploration.js index c305cb694d..49a011f9ec 100644 --- a/Hexploration/Hexploration.js +++ b/Hexploration/Hexploration.js @@ -5,7 +5,7 @@ * Name: Hexploration * Script: Hexploration.js * Version: 2.0.2 - * Built: 2026-10-30T22:13:47.401Z + * Built: 2026-10-30T23:43:06.779Z */ const HexplorationMod = (() => { 'use strict'; @@ -13,7 +13,7 @@ const HexplorationMod = (() => { // Build-time placeholders replaced by rollup.config.js inject-build-metadata plugin. const SCRIPT_NAME = 'Hexploration'; const SCRIPT_VERSION = '2.0.2'; - const SCRIPT_LAST_UPDATED = '2026-10-30T22:13:47.401Z'; + const SCRIPT_LAST_UPDATED = '2026-10-30T23:43:06.779Z'; const DEFAULT_LOCALE$1 = 'en-US'; @@ -1345,11 +1345,11 @@ const HexplorationMod = (() => { }, announce: { label: 'Kondig ontdekkings aan', - desc: "Wie sien die kletsboodskap wanneer 'n genoemde ligging ontdek word.", + desc: "Wie sien die kletsboodskap wanneer 'n benoemde ligging ontdek word.", }, pingDiscoveries: { label: 'Ping ontdekkings', - desc: "Wanneer aan, word spelers na 'n genoemde plek geping wanneer dit ontdek word.", + desc: "Wanneer aan, word spelers na 'n benoemde ligging geping wanneer dit ontdek word.", }, hideCoveredTokens: { label: 'Versteek bedekte tokens', @@ -1502,7 +1502,7 @@ const HexplorationMod = (() => { heading: 'Opdragte', intro: "Slegs GM'e kan hierdie opdragte gebruik. Die meeste werk op die geselekteerde voorwerpe; die res tree op op die bladsy wat jy bekyk.", - colCommand: 'Bevel', + colCommand: 'Opdrag', colDesc: 'Wat dit doen', }, revealing: { @@ -1514,7 +1514,7 @@ const HexplorationMod = (() => { "Seshoek-onthullingsafstand word op elke seshoek gestoor wanneer dit gevul word, so stel dit in voordat jy vul; om dit later te verander, raak nie seshoeke wat reeds op die kaart is nie. 'n Token moet binne soveel seshoeke wees om hulle te onthul, hoe ver dit ook al kan sien, en met 0 word hulle slegs onthul deur hulle binne te gaan. Vir 'n bergreeks: stel Seshoek-onthullingsafstand op 0, vul die berge, stel dit terug na geen, en vul dan die land daaragter. Met Sigafstand 3 en Siglyn aan sien die groep die oop grond rondom hulle, maar nie die berge of wat agter hulle lê nie. Elke bergseshoek word onthul wanneer 'n token daarin instap.", "In Glimp-modus word seshoeke binne sig deurskynend in plaas daarvan om te verdwyn, en hulle word verwyder wanneer 'n token hulle binnegaan. Deurskynende Glimp-seshoeke blokkeer nie Siglyn nie.", "Roll20 teken tokenname, balke en auras bo seshoeke. Met Versteek bedekte tokens aan, word die naam, balke en auras wat spelers kan sien, afgeskakel vir 'n token onder 'n bedekte seshoek totdat dit ontbloot word, sodat versteekte monsters hulself nie verklap nie. As jy een daarvan aanskakel terwyl die token bedek is, bly dit versteek en word dit aangeskakel wanneer die token ontbloot word.", - 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Explore, of bel Hexploration.revealAround(token) vanaf jou eie mod.', + 'Die API rapporteer nie bewegings wat deur ander mods gemaak is nie. TokenMod-skuiwe word outomaties opgetel; vir ander mods, kies die tokens en klik Verken, of roep Hexploration.revealAround(token) vanaf jou eie mod aan.', ], }, locations: { @@ -1524,7 +1524,7 @@ const HexplorationMod = (() => { 'Tokens met die wittoring-statusmerker word ook as liggings hanteer wanneer jy vul, soos in weergawe 1.', 'Versteekte liggingtokens word na die GM-laag geskuif. Wanneer hul seshoek onthul word, keer hulle terug na die tokenlaag met hul naam sigbaar, en hul ontdekking word aangekondig.', "Benoem seshoek gee 'n seshoek 'n naam sonder 'n token. Die naam word aan die GM gewys as 'n etiket op die GM-laag en aangekondig wanneer die seshoek onthul word. Jumpgate teken die GM-laag onder die voorgrondlaag, dus is die etikette in Jumpgate slegs sigbaar wanneer Seshoeklaag op die tokenlaag gestel is.", - 'Announce Discoveries kies of almal, net die GM, of niemand die aankondiging sien nie. Ping Discoveries skuif ook die spelers se uitsig na die ligging.', + 'Kondig ontdekkings aan kies of almal, net die GM, of niemand die aankondiging sien nie. Ping ontdekkings skuif ook die spelers se uitsig na die ligging.', ], }, settings: { @@ -1568,13 +1568,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Tale', - body: "Kies 'n taal met !hexploration stel taal. Beskikbare tale:", + body: "Kies 'n taal met !hexploration set language. Beskikbare tale:", colLanguage: 'Taal', colNative: 'Naam in eie taal', colCode: 'Kode', }, credits: { - heading: 'Krediete', + heading: 'Erkennings', original: 'Oorspronklike mod deur', maintainer: 'Weergawe 2 onderhou deur', marketplace: 'Ada se kunspakkies op die Roll20 Marketplace', @@ -1681,7 +1681,7 @@ const HexplorationMod = (() => { }, strokeColor: { label: 'Color de la vora', - desc: 'Color del contorn dels nous hexagonals.', + desc: 'Color del contorn dels hexàgons nous.', }, labelColor: { label: "Color de l'etiqueta", @@ -1701,7 +1701,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Distància de visió', - desc: "Quants hexagones es mostren al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexagones pels quals passa la fitxa.", + desc: "Quants hexàgons es revelen al voltant d'una fitxa en moviment (de 0 a 20). 0 només revela els hexàgons per on passa la fitxa.", }, lineOfSight: { label: 'Línia de visió', @@ -1709,11 +1709,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revela al llarg del camí', - desc: "Quan està activat, es revela cada hexàgono per on passa una fitxa mentre és arrossegada (inclosos els waypoints), no només on s'atura.", + desc: "Quan està activat, es revela cada hexàgon per on passa una fitxa mentre és arrossegada (inclosos els punts de pas), no només on s'atura.", }, revealBy: { label: 'Fitxes que revelen', - desc: 'Quines fitxes de la capa de fitxes revelen hexagones: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o cada fitxa.', + desc: 'Quines fitxes de la capa de fitxes revelen hexàgons: fitxes controlades per un jugador, fitxes que representen qualsevol personatge o totes les fitxes.', }, revealMode: { label: 'Mode de revelació', @@ -1729,7 +1729,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Amaga les fitxes cobertes', - desc: 'Roll20 dibuixa noms, barres i aures per sobre dels hexagones. Quan està activat, les fitxes sota un hexagonal cobert tenen el seu nom visible per al jugador, les barres i les aures desactivades, i tornen a activar-se quan es destaquen.', + desc: "Roll20 dibuixa noms, barres i aures per sobre dels hexàgons. Quan està activat, a les fitxes que són sota un hexàgon cobert se'ls desactiven el nom visible per als jugadors, les barres i les aures, que es tornen a activar quan es descobreixen.", }, }, status: { @@ -1748,13 +1748,13 @@ const HexplorationMod = (() => { messages: { filled: 'Emplenament completat. Hexàgons dibuixats: {created}. Amb estil nou: {restyled}. Ubicacions amagades: {icons}.', - revealed: 'Hexagones revelats: {count}.', + revealed: 'Hexàgons revelats: {count}.', revealedPage: "S'han revelat tots els hexàgons de la pàgina ({count}).", confirmReset: 'Voleu eliminar tots els hexàgons de "{page}" ({count})? Les fitxes d\'ubicació tornen a la capa de fitxes. Aquesta acció no es pot revertir amb Desfer.', resetPage: 'Hexàgons eliminats de la pàgina: {count}.', undone: - 'Últim farciment desfet. Hexagones eliminats: {removed}. Hexagones redissenyats restaurats: {restored}.', + "Últim emplenament desfet. Hexàgons eliminats: {removed}. Hexàgons amb l'estil restaurat: {restored}.", named: 'Hexàgons anomenats "{name}": {count}.', unnamed: 'Noms esborrats: {count}.', marked: @@ -1762,11 +1762,11 @@ const HexplorationMod = (() => { unmarked: 'Fitxes que ja no són ubicacions: {count}.', settingChanged: "{setting} s'ha establert en {value}.", rescanned: - "Torna a escanejar completat. Conservat: {kept}. Adoptat: {adopted}. Tornada a arxivar: {moved}. Falta i oblidat: {dropped}. Etiquetes tornades a enllaçar: {labels}. S'han tornat a enllaçar fitxes d'ubicació: {icons}.", + "Reescaneig completat. Conservats: {kept}. Adoptats: {adopted}. Reubicats: {moved}. Desapareguts i oblidats: {dropped}. Etiquetes tornades a enllaçar: {labels}. Fitxes d'ubicació tornades a enllaçar: {icons}.", calibrated: - "Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + 'Quadrícula calibrada (pas de columna {colStep}px, pas de fila {rowStep}px). Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.', calibrationReset: - "S'ha eliminat el calibratge. Torna a escanejar: s'ha mantingut {kept}, s'ha tornat a arxivar {moved}, s'ha adoptat {adopted}.", + "S'ha eliminat el calibratge. Reescaneig: conservats {kept}, reubicats {moved}, adoptats {adopted}.", journalRebuilt: 'Els fullets "{help}" i "{deck}" s\'han reconstruït.', migrated: "Els vostres mapes d'hexàgons d'Hexploration 1.x s'han actualitzat. Si aquest joc s'ha copiat d'un joc Legacy, executeu Torna a escanejar a cada pàgina amb mapa d'hexàgons.", @@ -1777,26 +1777,26 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Aquest joc no admet dibuixar a la capa de primer pla, de manera que es van dibuixar hexagones a la capa de fitxes.', + "Aquest joc no admet dibuixar a la capa de primer pla, de manera que els hexàgons s'han dibuixat a la capa de fitxes.", someFailed: - "Hexagones que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", + "Hexàgons que no s'han pogut dibuixar: {count}. Consulteu la consola de l'API per obtenir més informació.", }, errors: { noPage: "No s'ha pogut trobar la pàgina per treballar.", notHex: 'Aquesta pàgina no utilitza una graella hexagonal.', noPolygons: 'Seleccioneu una o més formes dibuixades per omplir.', - emptyArea: "L'àrea seleccionada no conté cap centre hexagonal.", - tooMany: "Això crearia massa hexagones d'una vegada ({count}).", + emptyArea: "L'àrea seleccionada no conté cap centre d'hexàgon.", + tooMany: "Això crearia massa hexàgons d'una vegada ({count}).", nothingToConceal: 'Seleccioneu formes dibuixades o fitxes per ocultar.', - nothingToReveal: 'Seleccioneu hexagonals, formes dibuixades o fitxes per revelar.', - noTokens: 'Seleccioneu primer un o més fitxes.', - noHexes: 'Seleccioneu primer un o més hexagones (o fitxes situades en hexagones).', + nothingToReveal: 'Seleccioneu hexàgons, formes dibuixades o fitxes per revelar.', + noTokens: 'Seleccioneu primer una o més fitxes.', + noHexes: 'Seleccioneu primer un o més hexàgons (o fitxes situades en hexàgons).', nothingToUndo: 'No hi ha cap emplenament per desfer.', unknownCommand: 'Ordre desconeguda: {command}', unknownSetting: 'Configuració desconeguda: {key}', unknownPageSetting: 'Configuració que es pot establir per pàgina: {keys}', invalidValue: '"{value}" no és un valor vàlid per a {key}.', - calibrateNeedsTokens: 'Seleccioneu una o dues fitxes encaixades als centres hexagonals.', + calibrateNeedsTokens: 'Seleccioneu una o dues fitxes ajustades als centres dels hexàgons.', calibrateFailed: 'Aquestes fitxes no es poden utilitzar per calibrar.', unexpected: "S'ha produït un error: {message}", }, @@ -1821,25 +1821,26 @@ const HexplorationMod = (() => { }, help: { menu: 'Mostra el menú.', - fill: 'Cobriu les formes dibuixades seleccionades amb hexagonals.', + fill: 'Cobriu les formes dibuixades seleccionades amb hexàgons.', fillInverse: 'Cobriu tota la pàgina excepte dins de les formes seleccionades.', - undo: "Desfer l'últim farciment, farciment invers o ocultar i restaurar les formes que utilitzava.", + undo: "Desfà l'últim emplenament, emplenament invers o ocultació, i restaura les formes que va utilitzar.", reveal: - 'Revela els hexagones seleccionats i els hexagonals sota les formes i fitxes seleccionades.', + 'Revela els hexàgons seleccionats i els hexàgons que hi ha sota les formes i fitxes seleccionades.', revealPage: 'Revela tots els hexàgons de la pàgina sense anuncis.', - conceal: "Torneu a cobrir l'àrea sota les formes i fitxes seleccionades amb hexagonals.", - explore: "Revela les fitxes seleccionades com si acabessin de moure's allà.", + conceal: + "Torneu a cobrir amb hexàgons l'àrea que hi ha sota les formes i fitxes seleccionades.", + explore: "Revela el voltant de les fitxes seleccionades com si s'hi acabessin de moure.", resetPage: 'Elimina tots els hexàgons de la pàgina (primer ho pregunta).', - name: 'Anomena els hexagones seleccionats o els hexadegons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', + name: 'Anomena els hexàgons seleccionats o els hexàgons que hi ha a sota de les fitxes seleccionades. Deixeu el nom buit per esborrar-lo.', mark: 'Converteix les fitxes seleccionades en llocs ocults.', - unmark: 'Deixeu que les fitxes seleccionades siguin ubicacions ocultes.', + unmark: 'Fa que les fitxes seleccionades deixin de ser ubicacions ocultes.', set: 'Canvia un paràmetre o mostra tots els paràmetres.', pageSet: 'Substituïu una configuració de revelació només a la pàgina actual.', pageClear: 'Elimina les substitucions de la pàgina actual.', rescan: "Reconstrueix la llista d'hexàgons de la pàgina, per exemple després de copiar una pàgina o un joc.", calibrate: - 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades enganxades als centres hexagonals.', + 'Alineeu la quadrícula hexagonal amb una o dues fitxes seleccionades ajustades als centres dels hexàgons.', calibrateReset: 'Elimineu el calibratge de la pàgina actual.', status: 'Mostra què sap Hexploration sobre la pàgina actual.', journal: "Reconstrueix els fullets d'Ajuda i del Command Deck.", @@ -1863,7 +1864,7 @@ const HexplorationMod = (() => { footer: 'Utilitzeu el fullet "{deck}" per als controls amb un sol clic.', overview: { heading: 'Visió general', - body: "Hexploration cobreix un mapa hexagonal amb hexagonals opacs. A mesura que el grup es mou, els hexàgons pels quals travessen (i, si voleu, els hexagonals que els envolten) s'eliminen, de manera que el mapa es descobreix un hexàgono a la vegada. Les ubicacions ocultes es poden col·locar sota hexagones i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", + body: "Hexploration cobreix un mapa hexagonal amb hexàgons opacs. A mesura que el grup es mou, els hexàgons per on passa (i, si voleu, els hexàgons del voltant) s'eliminen, de manera que el mapa es descobreix hexàgon a hexàgon. Les ubicacions ocultes es poden col·locar sota hexàgons i s'anuncien quan es troben. Funciona en jocs Jumpgate i Legacy, en quadrícules Hex (V) i Hex (H) de qualsevol mida.", demo: 'Mira una petita demostració (de la versió 1)', }, quickStart: { @@ -1880,7 +1881,7 @@ const HexplorationMod = (() => { heading: 'Ordres', intro: 'Només els GM poden utilitzar aquestes ordres. La majoria actuen sobre els objectes seleccionats; la resta actuen a la pàgina que esteu veient.', - colCommand: 'Comandament', + colCommand: 'Ordre', colDesc: 'Què fa', }, revealing: { @@ -1892,15 +1893,15 @@ const HexplorationMod = (() => { "La Distància de revelació dels hexàgons es desa a cada hexàgon quan s'omple, així que configureu-la abans d'omplir; canviar-la després no afecta els hexàgons que ja són al mapa. Una fitxa ha d'estar com a màxim a aquest nombre d'hexàgons per revelar-los, per lluny que pugui veure, i amb 0 només es revelen quan s'hi entra. Per a una serralada: poseu la Distància de revelació dels hexàgons a 0, ompliu les muntanyes, torneu-la a deixar sense límit i després ompliu les terres de més enllà. Amb una Distància de visió de 3 i la Línia de visió activada, el grup veu el terreny obert al seu voltant, però no les muntanyes ni el que hi ha darrere. Cada hexàgon de muntanya es revela quan una fitxa hi entra.", "En el mode Cop d'ull, els hexàgons a la vista es tornen transparents en lloc de desaparèixer, i s'eliminen quan hi entra una fitxa. Els hexàgons transparents del mode Cop d'ull no bloquegen la Línia de visió.", "Roll20 dibuixa els noms, les barres i les aures de les fitxes per sobre dels hexàgons. Amb Amaga les fitxes cobertes activat, una fitxa sota un hexàgon cobert té el nom, les barres i les aures visibles per als jugadors desactivats fins que es descobreix, perquè els monstres amagats no es delatin. Si n'activeu algun mentre la fitxa està coberta, continua amagat i s'activa quan la fitxa es descobreix.", - "L'API no informa dels moviments fets per altres modificacions. Els moviments de TokenMod es recullen automàticament; per a altres modificacions, seleccioneu les fitxes i feu clic a Explora, o truqueu a Hexploration.revealAround(token) des del vostre propi mod.", + "L'API no informa dels moviments fets per altres mods. Els moviments de TokenMod es recullen automàticament; per a altres mods, seleccioneu les fitxes i feu clic a Explora, o crideu Hexploration.revealAround(token) des del vostre propi mod.", ], }, locations: { - heading: 'Hexes i ubicacions anomenades', + heading: 'Hexàgons amb nom i ubicacions', points: [ - "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari queda amagat pel següent farciment que el cobreix.", - "Els fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", - "Les fitxes d'ubicació ocultes es mouen a la capa de GM. Quan es revela el seu hex, tornen a la capa de fitxes amb el seu nom mostrat i s'anuncia el seu descobriment.", + "Marca la ubicació converteix les fitxes seleccionades en ubicacions ocultes. Una fitxa que ja està sota un hexàgon s'amaga immediatament; en cas contrari, l'amaga el següent emplenament que la cobreixi.", + "Les fitxes amb el marcador d'estat de la torre blanca també es tracten com a ubicacions quan ompliu, com a la versió 1.", + "Les fitxes d'ubicació ocultes es mouen a la capa del GM. Quan es revela el seu hexàgon, tornen a la capa de fitxes amb el nom visible i s'anuncia el seu descobriment.", "Anomena l'hexàgon dona nom a un hexàgon sense cap fitxa. El nom es mostra al GM com una etiqueta a la capa del GM i s'anuncia quan es revela l'hexàgon. Jumpgate dibuixa la capa del GM per sota de la capa de primer pla, així que a Jumpgate les etiquetes només es veuen quan Capa dels hexàgons està establerta a la capa de fitxes.", "Anunciar descobriments tria si veuen l'anunci tothom, només el GM o ningú. Fer ping als descobriments també mou la vista dels jugadors a la ubicació.", ], @@ -1909,7 +1910,7 @@ const HexplorationMod = (() => { heading: 'Configuració', intro: 'Canvieu la configuració amb !hexploration set (o amb el botó Configuració). Capa dels hexàgons, Fitxes que revelen i Llengua també es poden configurar a la pàgina de configuració del mod.', - colKey: 'clau', + colKey: 'Clau', colName: 'Configuració', colDesc: 'Descripció', perPage: '(Es pot configurar per pàgina.)', @@ -1931,8 +1932,8 @@ const HexplorationMod = (() => { 'Les ordres de la versió 1, inclosa la macro Hexploration_menu, encara funcionen.', 'La versió 1 permetia que qualsevol fitxa que representés un personatge revelés hexàgons. Establiu Fitxes que revelen a Fitxes de personatges per mantenir aquest comportament.', ], - colV1: 'Comandament de la versió 1', - colV2: 'Comandament de la versió 2', + colV1: 'Ordre de la versió 1', + colV2: 'Ordre de la versió 2', }, troubleshooting: { heading: 'Resolució de problemes', @@ -1946,7 +1947,7 @@ const HexplorationMod = (() => { }, languages: { heading: 'Idiomes', - body: "Trieu un idioma amb l'idioma definit de !hexploration. Idiomes disponibles:", + body: 'Trieu un idioma amb !hexploration set language. Idiomes disponibles:', colLanguage: 'Llengua', colNative: 'Nom original', colCode: 'Codi', @@ -1980,7 +1981,7 @@ const HexplorationMod = (() => { reveal: '揭示與隱藏', locations: '地點', tools: '工具', - layerInUse: '正在 {layer} 上繪製新的六角形。', + layerInUse: '正在 {layer} 上繪製新的六角格。', pageSettingsHelp: '這些設定僅適用於該頁面。標記為★的設定將覆蓋全域設定。', }, buttons: { @@ -2050,7 +2051,7 @@ const HexplorationMod = (() => { }, hexLayer: { label: '六角格圖層', - desc: '繪製新六角形的地方。自動嘗試前景層（令牌上方），如果遊戲不支持，則回退到令牌層。', + desc: '新六角格的繪製位置。「自動」會先嘗試前景層（令牌上方），若遊戲不支援，則改用令牌層。', }, fillColor: { label: '填充顏色', @@ -2058,11 +2059,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: '邊框顏色', - desc: '新六邊形輪廓的顏色。', + desc: '新六角格輪廓的顏色。', }, labelColor: { label: '標籤顏色', - desc: '命名六角形上僅限 GM 的名稱標籤的顏色。', + desc: '已命名六角格上僅限 GM 可見的名稱標籤顏色。', }, glimpseColor: { label: '瞥見顏色', @@ -2070,7 +2071,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: '邊框寬度', - desc: '新六邊形輪廓的寬度，以像素為單位（0 到 20）。', + desc: '新六角格輪廓的寬度，以像素為單位（0 到 20）。', }, maxDistance: { label: '六角格揭示距離', @@ -2078,7 +2079,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '視距', - desc: '顯示移動令牌周圍有多少個六角形（0 到 20）。 0 僅顯示令牌經過的六角形。', + desc: '移動中的令牌周圍會揭示多少格六角格（0 到 20）。設為 0 時只揭示令牌經過的六角格。', }, lineOfSight: { label: '視線', @@ -2086,7 +2087,7 @@ const HexplorationMod = (() => { }, revealPath: { label: '沿路徑顯示', - desc: '啟用後，標記在拖曳時經過的每個六角形（包括路徑點）都會顯示出來，而不僅僅是其停止的位置。', + desc: '啟用後，令牌在拖曳過程中經過的每個六角格（包括路徑點）都會被揭示，而不只是其停下的位置。', }, revealBy: { label: '可揭示的令牌', @@ -2098,15 +2099,15 @@ const HexplorationMod = (() => { }, announce: { label: '公告發現', - desc: '當發現指定位置時誰會看到聊天訊息。', + desc: '發現已命名的地點時，誰會看到聊天訊息。', }, pingDiscoveries: { label: '標示發現位置', - desc: '啟用後，當發現指定位置時，玩家會被 ping 到該位置。', + desc: '啟用後，當已命名的地點被發現時，會對玩家 ping 該地點。', }, hideCoveredTokens: { label: '隱藏被覆蓋的令牌', - desc: 'Roll20 在六角形上方繪製名稱、條形和光環。啟用後，被覆蓋的六角形下的令牌的玩家可見的名稱、條形和光環會關閉，並在未被覆蓋時重新打開。', + desc: 'Roll20 會在六角格上方繪製名稱、條和光環。啟用後，位於被覆蓋六角格下的令牌，其玩家可見的名稱、條和光環會關閉，並在被揭開時重新開啟。', }, }, status: { @@ -2123,50 +2124,50 @@ const HexplorationMod = (() => { undo: '可撤銷', }, messages: { - filled: '填寫完成。繪製的六角形：{created}。重新設計：{restyled}。隱藏位置：{icons}。', - revealed: '六角形顯示：{count}。', + filled: '填充完成。繪製的六角格：{created}。重新套用樣式：{restyled}。隱藏的地點：{icons}。', + revealed: '已揭示的六角格：{count}。', revealedPage: '已揭示頁面上的所有六角格（{count}）。', confirmReset: '要移除「{page}」上的所有六角格（{count}）嗎？地點令牌會回到令牌層。此操作無法以撤銷復原。', resetPage: '已從頁面移除的六角格：{count}。', - undone: '上次填充已撤消。已刪除六角形：{removed}。重新設計的六角形已恢復：{restored}。', - named: '名為「{name}」的六角形：{count}。', + undone: '上次填充已撤銷。已移除的六角格：{removed}。已恢復原樣式的六角格：{restored}。', + named: '名為「{name}」的六角格：{count}。', unnamed: '已清除的名稱：{count}。', - marked: '隱藏在現有六角形中的位置：{attached}。等待下一次填充覆蓋它們：{pending}。', - unmarked: '不再是位置的標記：{count}。', + marked: '隱藏在現有六角格中的地點：{attached}。等待下一次填充覆蓋的地點：{pending}。', + unmarked: '不再是地點的令牌：{count}。', settingChanged: '{setting} 設定為 {value}。', rescanned: - '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。位置標記重新連結：{icons}。', + '重新掃描完成。保留：{kept}。採用：{adopted}。重新歸檔：{moved}。遺失與遺忘：{dropped}。標籤重新連結：{labels}。地點令牌重新連結：{icons}。', calibrated: - '網格校準（列步長 {colStep}px，行步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', + '網格已校準（行步長 {colStep}px，列步長 {rowStep}px）。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', calibrationReset: '校準已刪除。重新掃描：保留{kept}，重新歸檔{moved}，採用{adopted}。', journalRebuilt: '“{help}”和“{deck}”講義已重建。', migrated: - '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從舊版遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', + '您的 Hexploration 1.x 六角格地圖已升級。如果此遊戲是從 Legacy 遊戲複製而來，請在每個六角格地圖頁面上執行「重新掃描」。', pruned: '已不存在而被遺忘的已儲存六角格：{dropped}。如果此遊戲或頁面是複製而來，請在該頁面上執行「重新掃描」，以重新取回其六角格。', readyHint: '輸入 !hexploration 開啟選單，或開啟 "Hexploration - Command Deck" 講義。', }, warnings: { - foregroundUnavailable: '遊戲不支援在前景圖層上繪製，因此在令牌層上繪製了六角形。', - someFailed: '無法繪製的六角形：{count}。檢查 API 控制台以了解詳細資訊。', + foregroundUnavailable: '此遊戲不支援在前景層上繪製，因此六角格改為繪製在令牌層上。', + someFailed: '無法繪製的六角格：{count}。請檢查 API 控制台以了解詳細資訊。', }, errors: { noPage: '找不到要處理的頁面。', notHex: '此頁面不使用六角網格。', noPolygons: '選擇一個或多個要填滿的繪製形狀。', - emptyArea: '所選區域不包含任何六角形中心。', - tooMany: '這會一次建立太多的六角形 ({count})。', - nothingToConceal: '選擇要隱藏的繪製形狀或標記。', - nothingToReveal: '選擇要顯示的六角形、繪製的形狀或標記。', + emptyArea: '所選區域不包含任何六角格中心。', + tooMany: '這會一次建立太多六角格（{count}）。', + nothingToConceal: '選擇要隱藏的繪製形狀或令牌。', + nothingToReveal: '選擇要揭示的六角格、繪製的形狀或令牌。', noTokens: '首先選擇一個或多個令牌。', - noHexes: '首先選擇一個或多個六角形（或站在六角形上的標記）。', + noHexes: '首先選擇一個或多個六角格（或站在六角格上的令牌）。', nothingToUndo: '沒有可撤消的填充。', unknownCommand: '未知指令：{command}', unknownSetting: '未知設定：{key}', unknownPageSetting: '每頁可設定的設定：{keys}', invalidValue: '“{value}”對於 {key} 不是有效值。', - calibrateNeedsTokens: '選擇一或兩個吸附到六角形中心的標記。', + calibrateNeedsTokens: '選擇一或兩個吸附到六角格中心的令牌。', calibrateFailed: '這些令牌不能用於校準。', unexpected: '出了點問題：{message}', }, @@ -2176,32 +2177,32 @@ const HexplorationMod = (() => { noPolygons: '圍繞該區域繪製多邊形、矩形、橢圓形或手繪形狀，選擇它，然後重試。', emptyArea: '繪製更大的形狀，或檢查頁面網格設定。', tooMany: '填滿較小的區域，或將該區域分割成多個形狀。', - noHexes: '六角形位於前景或令牌層；切換到該層以選擇它們。', + noHexes: '六角格位於前景層或令牌層；切換到該層以選取它們。', unknownCommand: '鍵入 !hexploration help 以列出指令。', unknownSetting: '輸入 !hexploration set 查看每個設定。', calibrateNeedsTokens: - '將標記捕捉到六角形的中心並選擇它。選取捕捉到同一行 (Hex V) 或列 (Hex H) 中相鄰六角形的第二個標記，也可以修正六角形大小。', + '將令牌吸附到六角格的中心並選取它。若再選取一個吸附在同一列 (Hex V) 或同一行 (Hex H) 相鄰六角格中的令牌，也可以修正六角格大小。', calibrateFailed: '兩個令牌必須位於同一列 (Hex V) 或同一行 (Hex H)，且至少相隔一個六角格。', unexpected: '詳細資訊位於 API 控制台日誌中。', }, help: { menu: '顯示選單。', - fill: '用六角形覆蓋選定的繪製形狀。', + fill: '用六角格覆蓋選取的繪製形狀。', fillInverse: '覆蓋除所選形狀內部之外的整個頁面。', undo: '撤銷上次填充、反向填充或隱藏，並恢復其使用的形狀。', - reveal: '顯示選定的六角形以及選定形狀和標記下的六角形。', + reveal: '揭示選取的六角格，以及選取的形狀和令牌下方的六角格。', revealPage: '揭示頁面上的所有六角格，不發布公告。', - conceal: '再次用六角形覆蓋所選形狀和標記下方的區域。', - explore: '顯示所選標記的周圍，就好像它們剛剛移動到那裡一樣。', + conceal: '再次用六角格覆蓋所選形狀和令牌下方的區域。', + explore: '揭示所選令牌的周圍，就像它們剛移動到那裡一樣。', resetPage: '移除頁面上的所有六角格（會先確認）。', - name: '命名選定的六角形或選定標記下的六角形。將名稱留空以將其清除。', - mark: '將選取的標記變成隱藏位置。', - unmark: '停止將選定的標記隱藏在位置。', + name: '為選取的六角格或選取令牌下的六角格命名。將名稱留空即可清除。', + mark: '將選取的令牌變成隱藏地點。', + unmark: '讓選取的令牌不再是隱藏地點。', set: '更改設定或顯示所有設定。', pageSet: '僅覆蓋目前頁面上的顯示設定。', pageClear: '刪除目前頁面的覆蓋。', rescan: '重建頁面的六角格清單，例如在複製頁面或遊戲之後。', - calibrate: '將六角形網格與對齊到六角形中心的一兩個選定標記對齊。', + calibrate: '將六角格網格與一或兩個吸附到六角格中心的選取令牌對齊。', calibrateReset: '刪除目前頁面的校準。', status: '顯示 Hexploration 對目前頁面的了解。', journal: '重建說明與 Command Deck 講義。', @@ -2211,7 +2212,7 @@ const HexplorationMod = (() => { deck: { drawDesc: '在區域周圍繪製形狀，選取後填充。「撤銷填充」會還原上一次填充。', revealDesc: - '選擇六角形、形狀或標記以再次顯示或覆蓋它們。探索會顯示所選標記周圍的情況，就好像它們已移動一樣。', + '選取六角格、形狀或令牌以揭示或再次覆蓋它們。「探索」會揭示所選令牌的周圍，就像它們已移動過去一樣。', locationsDesc: '選取令牌，將其作為地點隱藏在六角格下。選取六角格或令牌，為六角格命名。', toolsDesc: '設定、頁面覆蓋、狀態、重新掃描複製的頁面和校準網格。', footer: '有關完整說明，請參閱“{help}”講義。', @@ -2232,7 +2233,7 @@ const HexplorationMod = (() => { '在要隱藏的區域周圍繪製一個或多個形狀（多邊形、矩形、橢圓形或手繪）。', '選取形狀，然後在 Command Deck 中點選「填充」（或輸入 !hexploration fill）。形狀會被六角格取代。', '可選：填充前，選取重要地點的令牌並點選「標記地點」。它們會隱藏在六角格下，被發現時公告。', - '移動玩家令牌。它穿過的每個六角形以及其視距內的六角形都會被顯示出來。', + '移動玩家令牌。它經過的每個六角格以及其視距內的六角格都會被揭示。', ], }, commands: { @@ -2246,7 +2247,7 @@ const HexplorationMod = (() => { heading: '揭示如何運作', points: [ '只有令牌層上的令牌才會揭示六角格。哪些令牌算數由「可揭示的令牌」決定：預設為玩家令牌，因此 GM 可以移動怪物而不揭開地圖。', - '標記會顯示它所覆蓋的每個六角形（大標記會覆蓋幾個），並且在啟用「沿路徑顯示」的情況下，會顯示它所拖曳的路線上的每個六角形，包括航路點。', + '令牌會揭示它覆蓋的每個六角格（大型令牌會覆蓋數個），若啟用「沿路徑顯示」，還會揭示它被拖曳經過的路線上的每個六角格，包括路徑點。', '「視距」會由近而遠揭示這些六角格周圍的六角格。啟用「視線」時，只要六角格與令牌之間有被覆蓋的六角格，該六角格就不會被揭示。較近的六角格通常會先被揭示，因此在開闊地區「視線」不會帶來任何改變：只有在「視距」為 2 或以上，且有持續被覆蓋的六角格（例如以「六角格揭示距離」填充的地形）時才有作用。', '「六角格揭示距離」會在六角格填充時儲存在每個六角格上，因此請在填充前設定；之後再更改不會影響地圖上已有的六角格。無論令牌能看多遠，都必須位於該格數以內才能揭示它們；設為 0 時，只有進入六角格才會揭示。以山脈為例：將「六角格揭示距離」設為 0，填充山脈，再將其設回無，然後填充山脈後方的土地。在「視距」為 3 且啟用「視線」時，隊伍能看到周圍的開闊地，但看不到山脈或山後的事物。每個山脈六角格會在令牌走進時被揭示。', '在「瞥見」模式中，視野內的六角格會變為半透明而非消失，並在令牌進入時被移除。處於瞥見狀態的六角格不會阻擋「視線」。', @@ -2255,10 +2256,10 @@ const HexplorationMod = (() => { ], }, locations: { - heading: '命名六角形和位置', + heading: '命名六角格和地點', points: [ '「標記地點」會將選取的令牌變成隱藏地點。已在六角格下的令牌會立即隱藏；否則會在下一次覆蓋它的填充時隱藏。', - '與版本 1 一樣，帶有白塔狀態標記的標記在您填充時也被視為位置。', + '與版本 1 一樣，帶有白塔狀態標記的令牌在填充時也會被視為地點。', '隱藏的地點令牌會移到 GM 層。當其所在的六角格被揭示時，它們會回到令牌層並顯示名稱，同時公告其發現。', '「命名六角格」可在沒有令牌的情況下為六角格命名。名稱會以標籤形式顯示在 GM 層上供 GM 查看，並在該六角格被揭示時公告。 Jumpgate 會把 GM 層繪製在前景層之下，因此在 Jumpgate 中，只有當「六角格圖層」設為令牌層時才會顯示標籤。', '「公告發現」決定所有人、僅 GM 或沒有人看到公告。「標示發現位置」還會把玩家的視野移到該地點。', @@ -2268,8 +2269,8 @@ const HexplorationMod = (() => { heading: '設定', intro: '使用 !hexploration set（或「設定」按鈕）變更設定。「六角格圖層」、「可揭示的令牌」與「語言」也可以在 Mod 的設定頁面上設定。', - colKey: '鑰匙', - colName: '環境', + colKey: '鍵', + colName: '設定', colDesc: '描述', perPage: '（可按頁設定。）', }, @@ -2278,8 +2279,8 @@ const HexplorationMod = (() => { points: [ 'Hexploration 計算出遊戲使用的引擎並繪製相符的形狀。可以填滿在任一編輯器中繪製的形狀。', '將「六角格圖層」設為「自動」時，六角格會繪製在令牌上方的前景層，因此玩家看不到下方的內容。如果前景層無法使用，則改用令牌層。', - 'Jumpgate 繪製的是數學上規則的六角格，形狀與舊版六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', - '當頁面或遊戲被複製時，其六角形會獲得新的 ID。在頁面上執行重新掃描以再次拾取它們以及它們的名稱標籤和位置標記。', + 'Jumpgate 繪製的是數學上規則的六角格，形狀與 Legacy 六角格略有不同。如果六角格與頁面網格沒有對齊，請將一個令牌吸附到六角格中心，選取它並點選「校準」。若在同一列 (Hex V) 或同一行 (Hex H) 的相鄰六角格中選取兩個令牌，還能一併修正六角格大小。', + '當頁面或遊戲被複製時，其六角格會獲得新的 ID。在頁面上執行「重新掃描」，即可重新取回它們及其名稱標籤和地點令牌。', ], }, upgrading: { @@ -2297,7 +2298,7 @@ const HexplorationMod = (() => { heading: '故障排除', points: [ '令牌移動時沒有任何反應：檢查令牌是否在令牌層上且符合「可揭示的令牌」，以及頁面上是否有六角格（!hexploration status）。', - '六角形偏離網格：使用校準，然後用地圖上幾個六角形上的標記進行檢查。', + '六角格偏離網格：使用「校準」，然後在地圖各處的幾個六角格上放置令牌進行檢查。', '複製頁面或遊戲後六角格不再揭示：請在該頁面上執行「重新掃描」。', '「填充」提示該區域沒有六角格中心：形狀必須包含至少一個六角格的中心。', '對於其他任何事情，請檢查 API 控制台日誌並在尋求協助時包含其訊息。', @@ -2308,7 +2309,7 @@ const HexplorationMod = (() => { body: '使用 !hexploration set language 選擇語言。可用語言：', colLanguage: '語言', colNative: '原文名稱', - colCode: '程式碼', + colCode: '代碼', }, credits: { heading: '製作人員', @@ -2409,12 +2410,12 @@ const HexplorationMod = (() => { desc: 'Jazyk pro nabídky, zprávy a letáky.', }, hexLayer: { - label: 'Vrstva šestiúhelníků', + label: 'Vrstva hexů', desc: 'Kde se kreslí nové hexy. Auto zkouší vrstvu popředí (nad žetony) a pokud ji hra nepodporuje, přejde zpět na vrstvu žetonů.', }, fillColor: { label: 'Barva výplně', - desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0,8).', + desc: 'Barva nových hexů. Použijte rgba() pro průhledné hexy, například rgba(0,0,0,0.8).', }, strokeColor: { label: 'Barva ohraničení', @@ -2433,7 +2434,7 @@ const HexplorationMod = (() => { desc: 'Šířka obrysu nových hexů v pixelech (0 až 20).', }, maxDistance: { - label: 'Vzdálenost odhalení šestiúhelníků', + label: 'Vzdálenost odhalení hexů', desc: 'Ukládá se do hexů při jejich vyplňování, proto ji nastavte před vyplněním: pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tohoto počtu hexů, aby je odhalil, ať vidí jakkoli daleko; při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Použijte ji pro hory nebo lesy. Nechte prázdné bez omezení.', }, revealDistance: { @@ -2442,7 +2443,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Přímá viditelnost', - desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení šestiúhelníků, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', + desc: 'Když je zapnuto, hexy, které zůstávají zakryté, například hory vyplněné s nastavením Vzdálenost odhalení hexů, skrývají hexy za sebou. Projeví se to pouze tehdy, když je Vzdálenost dohledu 2 nebo více.', }, revealPath: { label: 'Odhalovat po cestě', @@ -2466,7 +2467,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Skrýt zakryté žetony', - desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když jsou žetony pod krytým hexem zapnuté, jejich jméno, pruhy a aury viditelné pro hráče jsou vypnuté a znovu zapnuté, když jsou odkryty.', + desc: 'Roll20 kreslí jména, pruhy a aury nad hexy. Když je zapnuto, žetonům pod zakrytým hexem se vypnou jméno, pruhy a aury viditelné pro hráče a znovu se zapnou, až budou odkryty.', }, }, status: { @@ -2484,26 +2485,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vyplnění dokončeno. Vylosované hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', + 'Vyplnění dokončeno. Nakreslené hexy: {created}. Změna stylu: {restyled}. Skrytá místa: {icons}.', revealed: 'Odhalené hexy: {count}.', - revealedPage: 'Každé odhalené hex na stránce ({count}).', + revealedPage: 'Odhaleny všechny hexy na stránce ({count}).', confirmReset: - 'Odebrat každé hex z „{page}“ ({count})? Tokeny umístění se vrátí do vrstvy tokenů. Zpět to nelze vrátit.', + 'Odebrat všechny hexy ze stránky „{page}“ ({count})? Žetony míst se vrátí do vrstvy žetonů. Funkce Vrátit to nevrátí.', resetPage: 'Ze stránky byly odstraněny hexy: {count}.', undone: 'Poslední výplň vrácena. Odstraněné hexy: {removed}. Hexy s obnoveným stylem: {restored}.', - named: 'Hexusy s názvem „{name}“: {count}.', + named: 'Hexy s názvem „{name}“: {count}.', unnamed: 'Jména vymazána: {count}.', marked: 'Místa skrytá na stávajících hexech: {attached}. Čekání na další výplň, která je pokryje: {pending}.', unmarked: 'Tokeny, které již nejsou umístěními: {count}.', settingChanged: '{setting} nastaveno na {value}.', rescanned: - 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Znovu vyplněno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', + 'Opětovné skenování dokončeno. Uchováno: {kept}. Přijato: {adopted}. Přeřazeno: {moved}. Chybějící a zapomenuté: {dropped}. Znovu propojené štítky: {labels}. Tokeny polohy byly znovu propojeny: {icons}.', calibrated: - 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Znovu naskenovat: ponecháno {kept}, znovu zadáno {moved}, přijato {adopted}.', + 'Mřížka zkalibrována (krok sloupce {colStep}px, krok řádku {rowStep}px). Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', calibrationReset: - 'Kalibrace odstraněna. Znovu naskenovat: ponecháno {kept}, znovu uloženo {moved}, přijato {adopted}.', + 'Kalibrace odstraněna. Opětovné skenování: ponecháno {kept}, přeřazeno {moved}, přijato {adopted}.', journalRebuilt: 'Materiály „{help}“ a „{deck}“ byly přepracovány.', migrated: 'Vaše hexové mapy z Hexploration 1.x byly aktualizovány. Pokud byla tato hra zkopírována z hry Legacy, spusťte Znovu skenovat na každé stránce s hexovou mapou.', @@ -2516,13 +2517,13 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Tato hra nepodporuje kreslení na vrstvě popředí, takže hexy byly nakresleny na vrstvu žetonů.', someFailed: - 'Hexametry, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', + 'Hexy, které nebylo možné nakreslit: {count}. Podrobnosti naleznete v konzole API.', }, errors: { noPage: 'Nelze najít stránku, na které by se dalo pracovat.', notHex: 'Tato stránka nepoužívá hexovou mřížku.', noPolygons: 'Vyberte jeden nebo více nakreslených tvarů, které chcete vyplnit.', - emptyArea: 'Vybraná oblast neobsahuje žádné středy šestihran.', + emptyArea: 'Vybraná oblast neobsahuje žádné středy hexů.', tooMany: 'To by vytvořilo příliš mnoho hexů najednou ({count}).', nothingToConceal: 'Vyberte nakreslené tvary nebo žetony, které chcete skrýt.', nothingToReveal: 'Vyberte hexy, nakreslené tvary nebo žetony, které chcete odhalit.', @@ -2559,17 +2560,17 @@ const HexplorationMod = (() => { fillInverse: 'Zakryjte celou stránku kromě vybraných tvarů.', undo: 'Zrušte poslední výplň, inverzní výplň nebo skrytí a obnovte tvary, které použila.', reveal: 'Odhalte vybrané hexy a hexy pod vybranými tvary a žetony.', - revealPage: 'Odhalte každé hex na stránce bez oznámení.', + revealPage: 'Odhalte každý hex na stránce bez oznámení.', conceal: 'Znovu zakryjte oblast pod vybranými tvary a žetony hexy.', explore: 'Odhalte kolem vybraných žetonů, jako by se tam právě přesunuly.', resetPage: 'Odstraňte každý hex na stránce (nejprve se ptá).', name: 'Pojmenujte vybrané hexy nebo hexy pod vybranými žetony. Chcete-li jej vymazat, ponechte název prázdný.', mark: 'Proměňte vybrané žetony na skrytá místa.', - unmark: 'Zabraňte tomu, aby se vybrané tokeny staly skrytými místy.', + unmark: 'Zrušte u vybraných žetonů označení skrytých míst.', set: 'Změňte nastavení nebo zobrazte všechna nastavení.', pageSet: 'Přepsat nastavení odkrytí pouze na aktuální stránce.', pageClear: 'Odstraňte přepsání aktuální stránky.', - rescan: 'Znovu vytvořte seznam hex na stránce, například po zkopírování stránky nebo hry.', + rescan: 'Znovu vytvořte seznam hexů na stránce, například po zkopírování stránky nebo hry.', calibrate: 'Zarovnejte hexovou mřížku jedním nebo dvěma vybranými žetony přichycenými do středů hexů.', calibrateReset: 'Odstraňte kalibraci aktuální stránky.', @@ -2596,7 +2597,7 @@ const HexplorationMod = (() => { overview: { heading: 'Přehled', body: 'Hexploration pokrývá hexovou mapu s neprůhlednými hexy. Jak se skupina pohybuje, hexy, kterými prochází (a chcete-li, hexy kolem nich), jsou odstraněny, takže mapa je odkrývána jeden hex po druhém. Skrytá místa mohou být umístěna pod hexy a jsou oznámena, když jsou nalezena. Funguje ve hrách Jumpgate a Legacy, na mřížkách Hex (V) a Hex (H) jakékoli velikosti.', - demo: 'Podívejte se na krátkou ukázku (od verze 1)', + demo: 'Podívejte se na krátkou ukázku (z verze 1)', }, quickStart: { heading: 'Rychlý start', @@ -2620,8 +2621,8 @@ const HexplorationMod = (() => { points: [ 'Hexy odhalují pouze žetony na vrstvě žetonů. Které žetony se počítají, určuje nastavení Žetony, které odhalují: ve výchozím stavu žetony hráčů, takže GM může pohybovat příšerami, aniž by odkrýval mapu.', 'Žeton odhalí každý hex, který zakrývá (velké žetony zakrývají několik), a se zapnutým nastavením Odhalovat po cestě také každý hex na trase, po které byl tažen, včetně průchozích bodů.', - 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení šestiúhelníků.', - 'Vzdálenost odhalení šestiúhelníků se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení šestiúhelníků na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', + 'Vzdálenost dohledu odhaluje hexy kolem každého z těchto hexů, od nejbližších. Když je zapnutá Přímá viditelnost, hex se neodhalí, dokud mezi ním a žetonem leží zakrytý hex. Bližší hexy se obvykle odhalí jako první, takže v otevřené krajině Přímá viditelnost nic nemění: projeví se jen tehdy, když je Vzdálenost dohledu 2 nebo více a existují hexy, které zůstávají zakryté, například terén vyplněný s nastavením Vzdálenost odhalení hexů.', + 'Vzdálenost odhalení hexů se ukládá do každého hexu při jeho vyplnění, proto ji nastavte před vyplňováním; pozdější změna neovlivní hexy, které už jsou na mapě. Žeton musí být v dosahu tolika hexů, aby je odhalil, ať vidí jakkoli daleko, a při hodnotě 0 se odhalí jen tím, že do nich vstoupí. Pro horské pásmo: nastavte Vzdálenost odhalení hexů na 0, vyplňte hory, pak hodnotu opět vymažte (bez omezení) a nakonec vyplňte krajinu za nimi. Když je Vzdálenost dohledu 3 a Přímá viditelnost zapnutá, družina vidí otevřený terén kolem sebe, ale ne hory ani to, co leží za nimi. Každý horský hex se odhalí, když do něj vstoupí žeton.', 'V režimu Záblesk se hexy v dohledu místo zmizení stanou průhlednými a odstraní se, když do nich vstoupí žeton. Hexy zahlédnuté v režimu Záblesk nezakrývají výhled pro nastavení Přímá viditelnost.', 'Roll20 kreslí jména, ukazatele a aury žetonů nad hexy. Se zapnutým nastavením Skrýt zakryté žetony má žeton pod zakrytým hexem vypnuté jméno, ukazatele a aury viditelné pro hráče, dokud není odkryt, takže se skryté příšery neprozradí. Pokud některý z nich zapnete, zatímco je žeton zakrytý, zůstane skrytý a zapne se, až bude žeton odkryt.', 'API nehlásí pohyby provedené jinými mody. Pohyby z TokenMod se zachytí automaticky; u ostatních modů vyberte žetony a klikněte na Prozkoumat, nebo zavolejte Hexploration.revealAround(token) z vlastního modu.', @@ -2630,17 +2631,17 @@ const HexplorationMod = (() => { locations: { heading: 'Pojmenované hexy a umístění', points: [ - 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak je skryta další výplní, která jej zakrývá.', + 'Označit místo změní vybrané žetony na skrytá místa. Žeton, který je již pod hexem, je okamžitě skryt; jinak jej skryje další výplň, která jej zakryje.', 'Žetony se značkou stavu bílé věže jsou při vyplňování také považovány za místa, jako ve verzi 1.', 'Žetony skrytých umístění se přesunou do vrstvy GM. Když je jejich hex odhalen, vrátí se do vrstvy žetonů se zobrazeným jménem a jejich objev je oznámen.', - 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva šestiúhelníků nastavena na vrstvu žetonů.', + 'Pojmenovat hex dá hexu jméno bez žetonu. Jméno se GM zobrazí jako popisek na vrstvě GM a oznámí se, když je hex odhalen. Jumpgate vykresluje vrstvu GM pod vrstvou popředí, takže v Jumpgate se popisky zobrazí jen tehdy, když je Vrstva hexů nastavena na vrstvu žetonů.', 'Oznamovat objevy určuje, zda oznámení uvidí všichni, pouze GM, nebo nikdo. Pingnout objevy navíc přesune pohled hráčů na dané místo.', ], }, settings: { heading: 'Nastavení', intro: - 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu šestiúhelníků, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', + 'Nastavení změníte příkazem !hexploration set (nebo tlačítkem Nastavení). Vrstvu hexů, Žetony, které odhalují, a Jazyk lze nastavit také na stránce nastavení modu.', colKey: 'Klíč', colName: 'Nastavení', colDesc: 'Popis', @@ -2649,8 +2650,8 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate a Legacy', points: [ - 'Heexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', - 'Když je Vrstva šestiúhelníků nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', + 'Hexploration zjistí, který engine hra používá, a nakreslí odpovídající druh tvaru. Tvary nakreslené v obou editorech lze vyplnit.', + 'Když je Vrstva hexů nastavena na Auto, hexy se kreslí na vrstvu popředí nad žetony, takže hráči nevidí, co je pod nimi. Pokud vrstva popředí není k dispozici, použije se místo ní vrstva žetonů.', 'Jumpgate kreslí matematicky pravidelné hexy, které mají trochu jiný tvar než hexy Legacy. Pokud hexy nejsou zarovnány s mřížkou stránky, přichyťte token ke středu hexu, vyberte jej a klikněte na Kalibrovat. Vyberte dva žetony na sousedních hexech stejného řádku (Hex V) nebo sloupce (Hex H), abyste také opravili velikost hexu.', 'Když se stránka nebo hra zkopíruje, její hexy získají nová ID. Spusťte na stránce Znovu skenovat, aby se znovu načetly spolu se svými popisky jmen a žetony míst.', ], @@ -2684,9 +2685,9 @@ const HexplorationMod = (() => { colCode: 'Kód', }, credits: { - heading: 'Kredity', + heading: 'Autoři', original: 'Původní mod od', - maintainer: 'Verze 2 spravovaná společností', + maintainer: 'Verzi 2 spravuje', marketplace: 'Adiny umělecké balíčky na Roll20 Marketplace', support: 'Pokud najdete chybu nebo máte nápad, zveřejněte příspěvek na fóru Roll20 Mod nebo otevřete problém na GitHubu a zahrňte všechny zprávy z protokolu konzoly API.', @@ -2787,15 +2788,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Fyldfarve', - desc: 'Farve på nye sekskanter. Brug rgba() til gennemsigtige hexes, for eksempel rgba(0,0,0,0.8).', + desc: 'Farve på nye hexfelter. Brug rgba() til gennemsigtige hexfelter, for eksempel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Kantfarve', - desc: 'Farve på omridset af nye sekskanter.', + desc: 'Farve på omridset af nye hexfelter.', }, labelColor: { label: 'Etiketfarve', - desc: 'Farven på GM-only navneetiketter på navngivne sekskanter.', + desc: 'Farven på navneetiketterne, som kun GM kan se, på navngivne hexfelter.', }, glimpseColor: { label: 'Glimtfarve', @@ -2803,7 +2804,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Kantbredde', - desc: 'Bredden af ​​omridset af nye sekskanter, i pixels (0 til 20).', + desc: 'Bredden af omridset af nye hexfelter, i pixels (0 til 20).', }, maxDistance: { label: 'Afsløringsafstand for hexfelter', @@ -2811,7 +2812,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Synsafstand', - desc: 'Hvor mange sekskanter omkring et bevægeligt token afsløres (0 til 20). 0 afslører kun de sekskanter, som tokenet passerer igennem.', + desc: 'Hvor mange hexfelter omkring et token i bevægelse afsløres (0 til 20). 0 afslører kun de hexfelter, som tokenet passerer igennem.', }, lineOfSight: { label: 'Synslinje', @@ -2819,11 +2820,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Afslør langs ruten', - desc: 'Når den er tændt, afsløres hver hex, et token passerer igennem, mens det trækkes (inklusive waypoints), ikke kun hvor det stopper.', + desc: 'Når den er tændt, afsløres hvert hexfelt, et token passerer igennem, mens det trækkes (inklusive mellempunkter), ikke kun hvor det stopper.', }, revealBy: { label: 'Afslørende tokens', - desc: 'Hvilke tokens på tokenlaget afslører hexes: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller hver token.', + desc: 'Hvilke tokens på tokenlaget afslører hexfelter: tokens kontrolleret af en spiller, tokens, der repræsenterer en hvilken som helst karakter, eller alle tokens.', }, revealMode: { label: 'Afsløringstilstand', @@ -2839,7 +2840,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Skjul dækkede tokens', - desc: 'Roll20 tegner navne, streger og auraer over sekskanter. Når den er tændt, har tokens under en dækket sekskant deres spillersynlige navn, bjælker og auraer slået fra og tændt igen, når de afsløres.', + desc: 'Roll20 tegner navne, bjælker og auraer over hexfelter. Når den er tændt, får tokens under et dækket hexfelt deres spillersynlige navn, bjælker og auraer slået fra, og de slås til igen, når tokens afdækkes.', }, }, status: { @@ -2857,26 +2858,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Fyld færdig. Hexer tegnede: {created}. Omstilet: {restyled}. Steder skjult: {icons}.', - revealed: 'Hexer afsløret: {count}.', - revealedPage: 'Hver hex på siden afsløret ({count}).', + 'Udfyldning færdig. Hexfelter tegnet: {created}. Stil ændret: {restyled}. Steder skjult: {icons}.', + revealed: 'Hexfelter afsløret: {count}.', + revealedPage: 'Alle hexfelter på siden afsløret ({count}).', confirmReset: - 'Vil du fjerne hver hex fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', - resetPage: 'Hexer fjernet fra siden: {count}.', + 'Vil du fjerne alle hexfelter fra "{page}" ({count})? Placeringstokens vender tilbage til tokenlaget. Fortryd kan ikke fortryde dette.', + resetPage: 'Hexfelter fjernet fra siden: {count}.', undone: - 'Sidste udfyldning fortrydet. Hekser fjernet: {removed}. Restyled hexes gendannet: {restored}.', - named: 'Hexer med navnet "{name}": {count}.', + 'Sidste udfyldning fortrydet. Hexfelter fjernet: {removed}. Hexfelter med ændret stil gendannet: {restored}.', + named: 'Hexfelter med navnet "{name}": {count}.', unnamed: 'Navne ryddet: {count}.', marked: - 'Placeringer skjult i eksisterende hexes: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', + 'Placeringer skjult i eksisterende hexfelter: {attached}. Venter på den næste fyldning, der dækker dem: {pending}.', unmarked: 'Tokens, der ikke længere er placeringer: {count}.', settingChanged: '{setting} indstillet til {value}.', rescanned: - 'Genscanning fuldført. Gemt: {kept}. Vedtaget: {adopted}. Genindgivet: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', + 'Genscanning fuldført. Beholdt: {kept}. Overtaget: {adopted}. Omplaceret: {moved}. Manglende og glemt: {dropped}. Etiketter genlinket: {labels}. Placeringstokens genlinket: {icons}.', calibrated: - 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, genindsendt {moved}, adopteret {adopted}.', + 'Gitter kalibreret (kolonnetrin {colStep}px, rækketrin {rowStep}px). Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', calibrationReset: - 'Kalibrering fjernet. Genscan: beholdt {kept}, genindleveret {moved}, adopteret {adopted}.', + 'Kalibrering fjernet. Genscan: beholdt {kept}, omplaceret {moved}, overtaget {adopted}.', journalRebuilt: 'Uddelingsarkene "{help}" og "{deck}" er blevet genopbygget.', migrated: 'Dine Hexploration 1.x-hexkort er blevet opgraderet. Hvis dette spil blev kopieret fra et Legacy-spil, skal du køre Scan igen på hver side med et hexkort.', @@ -2887,25 +2888,25 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Dette spil understøtter ikke tegning på forgrundslaget, så der blev tegnet sekskanter på tokenlaget.', - someFailed: 'Hexer, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', + 'Dette spil understøtter ikke tegning på forgrundslaget, så hexfelterne blev tegnet på tokenlaget.', + someFailed: 'Hexfelter, der ikke kunne tegnes: {count}. Tjek API-konsollen for detaljer.', }, errors: { noPage: 'Kunne ikke finde siden at arbejde på.', notHex: 'Denne side bruger ikke et hex-gitter.', noPolygons: 'Vælg en eller flere tegnede figurer, der skal udfyldes.', - emptyArea: 'Det valgte område indeholder ingen hex-centre.', - tooMany: 'Det ville skabe for mange hexes på én gang ({count}).', + emptyArea: 'Det valgte område indeholder ingen hexfeltcentre.', + tooMany: 'Det ville skabe for mange hexfelter på én gang ({count}).', nothingToConceal: 'Vælg tegnede figurer eller tokens til at skjule.', - nothingToReveal: 'Vælg sekskanter, tegnede figurer eller tokens for at afsløre.', + nothingToReveal: 'Vælg hexfelter, tegnede figurer eller tokens, der skal afsløres.', noTokens: 'Vælg først et eller flere tokens.', - noHexes: 'Vælg først en eller flere hexes (eller poletter stående på hexes).', + noHexes: 'Vælg først et eller flere hexfelter (eller tokens, der står på hexfelter).', nothingToUndo: 'Der er ingen udfyldning at fortryde.', unknownCommand: 'Ukendt kommando: {command}', unknownSetting: 'Ukendt indstilling: {key}', unknownPageSetting: 'Indstillinger, der kan indstilles pr. side: {keys}', invalidValue: '"{value}" er ikke en gyldig værdi for {key}.', - calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hex-centre.', + calibrateNeedsTokens: 'Vælg et eller to tokens fastgjort til hexfeltcentre.', calibrateFailed: 'Disse tokens kan ikke bruges til at kalibrere.', unexpected: 'Noget gik galt: {message}', }, @@ -2916,35 +2917,36 @@ const HexplorationMod = (() => { 'Tegn en polygon, et rektangel, en ellipse eller en frihåndsform rundt om området, vælg det, og prøv derefter igen.', emptyArea: 'Tegn en større form, eller kontroller indstillingerne for sidegitteret.', tooMany: 'Udfyld et mindre område, eller opdel området i flere former.', - noHexes: 'Hekser er på forgrunden eller symbollaget; skift til det lag for at vælge dem.', + noHexes: + 'Hexfelterne ligger på forgrundslaget eller tokenlaget; skift til det lag for at vælge dem.', unknownCommand: 'Skriv !hexploration help for at vise kommandoerne.', unknownSetting: 'Skriv !hexploration set for at se alle indstillinger.', calibrateNeedsTokens: - 'Snap et token til midten af ​​en sekskant, og vælg det. Vælg en anden token, der er snappet til en tilstødende hex i samme række (Hex V) eller kolonne (Hex H) for også at rette hex-størrelsen.', + 'Fastgør et token til midten af et hexfelt, og vælg det. Vælg et andet token, der er fastgjort til et tilstødende hexfelt i samme række (Hex V) eller kolonne (Hex H), for også at rette hexfeltstørrelsen.', calibrateFailed: - 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), med mindst én hex fra hinanden.', + 'To tokens skal være i samme række (Hex V) eller den samme kolonne (Hex H), mindst ét hexfelt fra hinanden.', unexpected: 'Detaljer er i API-konsolloggen.', }, help: { menu: 'Vis menuen.', - fill: 'Dæk de valgte tegnede figurer med sekskanter.', + fill: 'Dæk de valgte tegnede figurer med hexfelter.', fillInverse: 'Dæk hele siden undtagen inde i de valgte former.', undo: 'Fortryd den sidste fyldning, omvendt fyld eller skjul, og gendan de former, den brugte.', - reveal: 'Afslør de valgte hexes og hexes under de valgte former og tokens.', - revealPage: 'Afslør hver hex på siden uden meddelelser.', - conceal: 'Dæk området under de valgte former og tokens med sekskanter igen.', + reveal: 'Afslør de valgte hexfelter og hexfelterne under de valgte former og tokens.', + revealPage: 'Afslør alle hexfelter på siden uden meddelelser.', + conceal: 'Dæk området under de valgte former og tokens med hexfelter igen.', explore: 'Afslør omkring de valgte tokens, som om de lige var flyttet dertil.', - resetPage: 'Fjern hver hex på siden (spørg først).', - name: 'Navngiv de valgte hexes, eller hexes under de valgte tokens. Lad navnet stå tomt for at rydde det.', + resetPage: 'Fjern alle hexfelter på siden (spørger først).', + name: 'Navngiv de valgte hexfelter eller hexfelterne under de valgte tokens. Lad navnet stå tomt for at rydde det.', mark: 'Gør de valgte tokens til skjulte placeringer.', unmark: 'Stop de valgte tokens med at være skjulte placeringer.', set: 'Skift en indstilling, eller vis alle indstillinger.', pageSet: 'Tilsidesæt kun en afsløringsindstilling på den aktuelle side.', pageClear: 'Fjern den aktuelle sides tilsidesættelser.', rescan: - 'Genopbyg sidens hex-liste, for eksempel efter at have kopieret en side eller et spil.', + 'Genopbyg sidens liste over hexfelter, for eksempel efter at have kopieret en side eller et spil.', calibrate: - 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hex-centre.', + 'Sæt hex-gitteret på linje med et eller to udvalgte tokens, der er fastgjort til hexfeltcentre.', calibrateReset: 'Fjern den aktuelle sides kalibrering.', status: 'Vis, hvad Hexploration ved om den aktuelle side.', journal: 'Genopbyg uddelingsarkene Help og Command Deck.', @@ -2957,18 +2959,18 @@ const HexplorationMod = (() => { revealDesc: 'Vælg hexfelter, figurer eller tokens for at afsløre dem eller dække dem igen. Udforsk afslører omkring valgte tokens, som om de var flyttet.', locationsDesc: - 'Vælg tokens for at skjule dem som placeringer under hexes. Vælg hexes eller tokens for at navngive en hex.', + 'Vælg tokens for at skjule dem som placeringer under hexfelter. Vælg hexfelter eller tokens for at navngive et hexfelt.', toolsDesc: 'Indstillinger, sidetilsidesættelser, status, genscanning af kopierede sider og kalibrering af gitteret.', footer: 'Se "{help}"-uddelingsark for fuldstændige instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-udforskning for Roll20', + subtitle: 'Udforskning hexfelt for hexfelt i Roll20', footer: 'Brug "{deck}"-uddelingsark til kontrolelementer med et enkelt klik.', overview: { heading: 'Oversigt', - body: 'Hexploration dækker et hex-kort med uigennemsigtige hexes. Efterhånden som partiet bevæger sig, fjernes de hexes, de passerer igennem (og, hvis du vil, hexes omkring dem), så kortet afsløres en hex ad gangen. Skjulte placeringer kan placeres under hexes og annonceres, når de findes. Det fungerer i Jumpgate og Legacy-spil, på Hex (V) og Hex (H) gitter af enhver størrelse.', + body: 'Hexploration dækker et hexkort med uigennemsigtige hexfelter. Efterhånden som gruppen bevæger sig, fjernes de hexfelter, den passerer igennem (og, hvis du vil, hexfelterne omkring den), så kortet afdækkes ét hexfelt ad gangen. Skjulte steder kan placeres under hexfelter og annonceres, når de findes. Det fungerer i Jumpgate- og Legacy-spil, på Hex (V)- og Hex (H)-gitre af enhver størrelse.', demo: 'Se en kort demo (fra version 1)', }, quickStart: { @@ -3001,11 +3003,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Navngivne Hekser og Steder', + heading: 'Navngivne hexfelter og steder', points: [ 'Marker sted forvandler de valgte tokens til skjulte steder. Et token, der allerede ligger under et hexfelt, skjules med det samme; ellers skjules det af den næste fyldning, der dækker det.', 'Tokens med det hvide tårns statusmarkør behandles også som placeringer, når du udfylder, som i version 1.', - 'Skjulte placeringstokens flyttes til GM-laget. Når deres hex afsløres, vender de tilbage til token-laget med deres navn vist, og deres opdagelse annonceres.', + 'Skjulte placeringstokens flyttes til GM-laget. Når deres hexfelt afsløres, vender de tilbage til tokenlaget med deres navn vist, og deres opdagelse annonceres.', 'Navngiv hexfelt giver et hexfelt et navn uden et token. Navnet vises for GM som en etiket på GM-laget og annonceres, når hexfeltet afsløres. Jumpgate tegner GM-laget under forgrundslaget, så i Jumpgate vises etiketterne kun, når Lag for hexfelter er sat til tokenlaget.', 'Annoncer opdagelser bestemmer, om alle, kun GM eller ingen ser meddelelsen. Ping opdagelser flytter desuden spillernes visning hen til stedet.', ], @@ -3032,7 +3034,7 @@ const HexplorationMod = (() => { heading: 'Opgradering fra version 1', points: [ 'Version 2 behøver ikke længere PathMath, MatrixMath, Vector Math eller HTML Builder. Du kan fjerne dem, medmindre en anden mod bruger dem.', - 'Eksisterende hex-kort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', + 'Eksisterende hexkort, navne, placeringstokens og indstillinger opgraderes automatisk ved første start.', 'Version 1-kommandoerne, inklusive makroen Hexploration_menu, virker stadig.', 'I version 1 kunne ethvert token, der repræsenterede en karakter, afsløre hexfelter. Sæt Afslørende tokens til Karaktertokens for at bevare den adfærd.', ], @@ -3051,13 +3053,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Sprog', - body: 'Vælg et sprog med !hexploration set sprog. Tilgængelige sprog:', + body: 'Vælg et sprog med !hexploration set language. Tilgængelige sprog:', colLanguage: 'Sprog', colNative: 'Eget navn', colCode: 'Kode', }, credits: { - heading: 'Kreditter', + heading: 'Medvirkende', original: 'Original mod af', maintainer: 'Version 2 vedligeholdes af', marketplace: 'Adas kunstpakker på Roll20 Marketplace', @@ -3160,15 +3162,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Vulkleur', - desc: 'Kleur van nieuwe vakjes. Gebruik rgba() voor doorzichtige hexen, bijvoorbeeld rgba(0,0,0,0.8).', + desc: 'Kleur van nieuwe zeshoeken. Gebruik rgba() voor doorzichtige zeshoeken, bijvoorbeeld rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randkleur', - desc: 'Kleur van de omtrek van nieuwe vakjes.', + desc: 'Kleur van de omtrek van nieuwe zeshoeken.', }, labelColor: { label: 'Labelkleur', - desc: 'Kleur van de GM-only naamlabels op benoemde vakjes.', + desc: 'Kleur van de naamlabels die alleen de GM ziet, op benoemde zeshoeken.', }, glimpseColor: { label: 'Glimpkleur', @@ -3176,7 +3178,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Randbreedte', - desc: 'Breedte van de omtrek van nieuwe vakken, in pixels (0 tot 20).', + desc: 'Breedte van de omtrek van nieuwe zeshoeken, in pixels (0 tot 20).', }, maxDistance: { label: 'Onthullingsafstand van zeshoeken', @@ -3184,7 +3186,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Zichtafstand', - desc: 'Hoeveel vakjes rond een bewegend pion worden onthuld (0 tot 20). 0 onthult alleen de vakjes waar het fiche doorheen gaat.', + desc: 'Hoeveel zeshoeken rond een bewegend token worden onthuld (0 tot 20). 0 onthult alleen de zeshoeken waar het token doorheen gaat.', }, lineOfSight: { label: 'Zichtlijn', @@ -3192,11 +3194,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Onthullen langs pad', - desc: 'Wanneer deze optie is ingeschakeld, wordt elke vakje waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', + desc: 'Wanneer deze optie is ingeschakeld, wordt elke zeshoek waar een token doorheen gaat tijdens het slepen (inclusief tussenpunten) onthuld, niet alleen waar het stopt.', }, revealBy: { label: 'Tokens die onthullen', - desc: 'Welke tokens op de tokenlaag onthullen hexen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', + desc: 'Welke tokens op de tokenlaag zeshoeken onthullen: tokens die door een speler worden beheerd, tokens die een willekeurig personage vertegenwoordigen, of elk token.', }, revealMode: { label: 'Onthullingsmodus', @@ -3204,15 +3206,15 @@ const HexplorationMod = (() => { }, announce: { label: 'Ontdekkingen aankondigen', - desc: 'Wie ziet het chatbericht wanneer een genoemde locatie wordt ontdekt?', + desc: 'Wie het chatbericht ziet wanneer een benoemde locatie wordt ontdekt.', }, pingDiscoveries: { label: 'Ontdekkingen pingen', - desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een genoemde locatie gepingd wanneer deze wordt ontdekt.', + desc: 'Wanneer deze optie is ingeschakeld, worden spelers naar een benoemde locatie gepingd wanneer deze wordt ontdekt.', }, hideCoveredTokens: { label: 'Bedekte tokens verbergen', - desc: "Roll20 tekent namen, balken en aura's boven velden. Wanneer deze zijn ingeschakeld, zijn de voor de speler zichtbare naam, balken en aura's van tokens onder een afgedekt vakje uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", + desc: "Roll20 tekent namen, balken en aura's boven zeshoeken. Wanneer deze optie is ingeschakeld, worden de voor spelers zichtbare naam, balken en aura's van tokens onder een bedekte zeshoek uitgeschakeld, en weer ingeschakeld wanneer ze worden blootgelegd.", }, }, status: { @@ -3230,26 +3232,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vul compleet. Getekende vakjes: {created}. Gerestyled: {restyled}. Locaties verborgen: {icons}.', - revealed: 'Hexen onthuld: {count}.', - revealedPage: 'Elke zeshoek op de pagina wordt onthuld ({count}).', + 'Vullen voltooid. Getekende zeshoeken: {created}. Opnieuw opgemaakt: {restyled}. Locaties verborgen: {icons}.', + revealed: 'Zeshoeken onthuld: {count}.', + revealedPage: 'Alle zeshoeken op de pagina onthuld ({count}).', confirmReset: - 'Elke hex verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', - resetPage: 'Hexes verwijderd van de pagina: {count}.', + 'Alle zeshoeken verwijderen uit "{page}" ({count})? Locatietokens keren terug naar de tokenlaag. Ongedaan maken kan dit niet ongedaan maken.', + resetPage: 'Zeshoeken verwijderd van de pagina: {count}.', undone: - 'Laatste vulling ongedaan gemaakt. Hexen verwijderd: {removed}. Gerestylede velden hersteld: {restored}.', - named: 'Hexen met de naam "{name}": {count}.', + 'Laatste vulling ongedaan gemaakt. Zeshoeken verwijderd: {removed}. Opnieuw opgemaakte zeshoeken hersteld: {restored}.', + named: 'Zeshoeken met de naam "{name}": {count}.', unnamed: 'Namen gewist: {count}.', marked: - 'Locaties verborgen in bestaande vakjes: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', + 'Locaties verborgen in bestaande zeshoeken: {attached}. Wachten op de volgende vulling die ze bedekt: {pending}.', unmarked: 'Tokens die niet langer locaties zijn: {count}.', settingChanged: '{setting} ingesteld op {value}.', rescanned: - 'Opnieuw scannen voltooid. Bewaarde: {kept}. Aangenomen: {adopted}. Opnieuw ingediend: {moved}. Vermist en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', + 'Opnieuw scannen voltooid. Behouden: {kept}. Overgenomen: {adopted}. Opnieuw ingedeeld: {moved}. Ontbrekend en vergeten: {dropped}. Labels opnieuw gekoppeld: {labels}. Locatietokens opnieuw gekoppeld: {icons}.', calibrated: - 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Raster gekalibreerd (kolomstap {colStep}px, rijstap {rowStep}px). Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', calibrationReset: - 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, opnieuw gearchiveerd {moved}, {adopted} overgenomen.', + 'Kalibratie verwijderd. Opnieuw scannen: {kept} behouden, {moved} opnieuw ingedeeld, {adopted} overgenomen.', journalRebuilt: 'De hand-outs "{help}" en "{deck}" zijn opnieuw opgebouwd.', migrated: 'Uw Hexploration 1.x-zeshoekkaarten zijn bijgewerkt. Als dit spel is gekopieerd uit een Legacy-spel, voer dan Opnieuw scannen uit op elke pagina met een zeshoekkaart.', @@ -3260,20 +3262,20 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden er vakjes op de tokenlaag getekend.', + 'Dit spel biedt geen ondersteuning voor tekenen op de voorgrondlaag, dus werden de zeshoeken op de tokenlaag getekend.', someFailed: - 'Velden die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', + 'Zeshoeken die niet konden worden getekend: {count}. Controleer de API-console voor meer informatie.', }, errors: { noPage: 'Kon de pagina niet vinden om aan te werken.', notHex: 'Deze pagina maakt geen gebruik van een hex-raster.', noPolygons: 'Selecteer een of meer getekende vormen om te vullen.', - emptyArea: 'Het geselecteerde gebied bevat geen hex-centra.', - tooMany: 'Dat zou te veel velden in één keer creëren ({count}).', + emptyArea: 'Het geselecteerde gebied bevat geen middelpunten van zeshoeken.', + tooMany: 'Dat zou te veel zeshoeken in één keer creëren ({count}).', nothingToConceal: 'Selecteer getekende vormen of tokens om te verbergen.', - nothingToReveal: 'Selecteer vakjes, getekende vormen of tokens om te onthullen.', + nothingToReveal: 'Selecteer zeshoeken, getekende vormen of tokens om te onthullen.', noTokens: 'Selecteer eerst een of meer tokens.', - noHexes: 'Selecteer eerst een of meer vakjes (of fiches die op vakjes staan).', + noHexes: 'Selecteer eerst een of meer zeshoeken (of tokens die op zeshoeken staan).', nothingToUndo: 'Er is geen vulling die ongedaan kan worden gemaakt.', unknownCommand: 'Onbekend commando: {command}', unknownSetting: 'Onbekende instelling: {key}', @@ -3292,27 +3294,28 @@ const HexplorationMod = (() => { emptyArea: 'Teken een grotere vorm of controleer de paginarasterinstellingen.', tooMany: 'Vul een kleiner gebied, of splits het gebied in verschillende vormen.', noHexes: - 'Hexes bevinden zich op de voorgrond of tokenlaag; ga naar die laag om ze te selecteren.', + 'Zeshoeken bevinden zich op de voorgrondlaag of de tokenlaag; ga naar die laag om ze te selecteren.', unknownCommand: 'Typ !hexploration help om de opdrachten weer te geven.', unknownSetting: 'Typ !hexploration set om elke instelling te bekijken.', calibrateNeedsTokens: - 'Plaats een token in het midden van een vakje en selecteer het. Selecteer een tweede token dat is vastgemaakt aan een aangrenzende hex in dezelfde rij (Hex V) of kolom (Hex H) om ook de hex-grootte te corrigeren.', + 'Zet een token vast op het midden van een zeshoek en selecteer het. Selecteer een tweede token dat is vastgezet op een aangrenzende zeshoek in dezelfde rij (Hex V) of kolom (Hex H) om ook de grootte van de zeshoeken te corrigeren.', calibrateFailed: - 'Twee fiches moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, met minstens één vakje uit elkaar.', - unexpected: 'Details staan ​​in het API-consolelogboek.', + 'Twee tokens moeten zich in dezelfde rij (Hex V) of dezelfde kolom (Hex H) bevinden, minstens één zeshoek uit elkaar.', + unexpected: 'Details staan in het API-consolelogboek.', }, help: { - menu: 'Laat de menukaart zien.', - fill: 'Bedek de geselecteerde getekende vormen met vakjes.', + menu: 'Toon het menu.', + fill: 'Bedek de geselecteerde getekende vormen met zeshoeken.', fillInverse: 'Bedek de hele pagina, behalve binnen de geselecteerde vormen.', - undo: 'Maak de laatste vulling ongedaan, keer de vulling om of verberg deze, en herstel de gebruikte vormen.', + undo: 'Maak de laatste vulling, omgekeerde vulling of verberging ongedaan, en herstel de gebruikte vormen.', reveal: - 'Onthul de geselecteerde velden en de velden onder de geselecteerde vormen en fiches.', - revealPage: 'Onthul elke hex op de pagina zonder aankondigingen.', - conceal: 'Bedek het gebied onder de geselecteerde vormen en fiches opnieuw met vakjes.', - explore: 'Onthul de geselecteerde tokens alsof ze er net naartoe zijn verhuisd.', - resetPage: 'Verwijder elk vakje op de pagina (eerst gevraagd).', - name: 'Geef de geselecteerde velden een naam, of de velden onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', + 'Onthul de geselecteerde zeshoeken en de zeshoeken onder de geselecteerde vormen en tokens.', + revealPage: 'Onthul alle zeshoeken op de pagina zonder aankondigingen.', + conceal: 'Bedek het gebied onder de geselecteerde vormen en tokens opnieuw met zeshoeken.', + explore: + 'Onthul de omgeving van de geselecteerde tokens alsof ze er net naartoe zijn verplaatst.', + resetPage: 'Verwijder alle zeshoeken op de pagina (vraagt eerst om bevestiging).', + name: 'Geef de geselecteerde zeshoeken een naam, of de zeshoeken onder de geselecteerde tokens. Laat de naam leeg om deze te wissen.', mark: 'Verander de geselecteerde tokens in verborgen locaties.', unmark: 'Voorkom dat de geselecteerde tokens verborgen locaties zijn.', set: 'Wijzig een instelling of toon alle instellingen.', @@ -3321,7 +3324,7 @@ const HexplorationMod = (() => { rescan: 'Bouw de hexlijst van de pagina opnieuw op, bijvoorbeeld na het kopiëren van een pagina of spel.', calibrate: - 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een hex zijn vastgeklikt.', + 'Lijn het hexraster uit met een of twee geselecteerde tokens die op het midden van een zeshoek zijn vastgezet.', calibrateReset: 'Verwijder de kalibratie van de huidige pagina.', status: 'Laat zien wat Hexploration weet over de huidige pagina.', journal: 'Bouw de hand-outs Help en Command Deck opnieuw op.', @@ -3334,18 +3337,18 @@ const HexplorationMod = (() => { revealDesc: 'Selecteer zeshoeken, vormen of tokens om ze te onthullen of weer te bedekken. Verkennen onthult de omgeving van geselecteerde tokens alsof ze daarheen zijn verplaatst.', locationsDesc: - 'Selecteer tokens om ze te verbergen als locaties onder vakjes. Selecteer vakken of tokens om een ​​vak een naam te geven.', + 'Selecteer tokens om ze als locaties onder zeshoeken te verbergen. Selecteer zeshoeken of tokens om een zeshoek een naam te geven.', toolsDesc: "Instellingen, paginaoverschrijvingen, status, gekopieerde pagina's opnieuw scannen en het raster kalibreren.", footer: 'Zie de hand-out "{help}" voor volledige instructies.', }, handout: { versionLabel: 'Versie', - subtitle: 'Hex-voor-hex verkenning voor Roll20', + subtitle: 'Verkenning zeshoek voor zeshoek in Roll20', footer: 'Gebruik de hand-out "{deck}" voor bediening met één klik.', overview: { heading: 'Overzicht', - body: 'Hexploration beslaat een hex-kaart met ondoorzichtige vakjes. Terwijl het gezelschap beweegt, worden de vakken waar ze doorheen gaan (en, als je wilt, de vakken eromheen) verwijderd, zodat de kaart vakje voor vakje wordt blootgelegd. Verborgen locaties kunnen onder vakjes worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V) en Hex (H) rasters van elke grootte.', + body: 'Hexploration bedekt een hexkaart met ondoorzichtige zeshoeken. Terwijl het gezelschap beweegt, worden de zeshoeken waar het doorheen gaat (en, als je wilt, de zeshoeken eromheen) verwijderd, zodat de kaart zeshoek voor zeshoek wordt blootgelegd. Verborgen locaties kunnen onder zeshoeken worden geplaatst en worden aangekondigd wanneer ze worden gevonden. Het werkt in Jumpgate- en Legacy-spellen, op Hex (V)- en Hex (H)-rasters van elke grootte.', demo: 'Bekijk een korte demo (vanaf versie 1)', }, quickStart: { @@ -3378,11 +3381,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Genoemde velden en locaties', + heading: 'Benoemde zeshoeken en locaties', points: [ 'Locatie markeren verandert de geselecteerde tokens in verborgen locaties. Een token dat al onder een zeshoek ligt, wordt meteen verborgen; anders wordt het verborgen door de volgende vulling die het bedekt.', 'Tokens met de statusmarkering van de witte toren worden bij het vullen ook behandeld als locaties, zoals in versie 1.', - 'Verborgen locatiefiches worden verplaatst naar de GM-laag. Wanneer hun hex wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', + 'Verborgen locatietokens worden verplaatst naar de GM-laag. Wanneer hun zeshoek wordt onthuld, keren ze terug naar de tokenlaag met hun naam weergegeven, en wordt hun ontdekking aangekondigd.', 'Zeshoek benoemen geeft een zeshoek een naam zonder token. De naam wordt aan de GM getoond als label op de GM-laag en aangekondigd wanneer de zeshoek wordt onthuld. Jumpgate tekent de GM-laag onder de voorgrondlaag, dus in Jumpgate zijn de labels alleen zichtbaar als Laag voor zeshoeken op de tokenlaag staat.', 'Ontdekkingen aankondigen bepaalt of iedereen, alleen de GM of niemand de aankondiging ziet. Ontdekkingen pingen verplaatst bovendien het beeld van de spelers naar de locatie.', ], @@ -3397,7 +3400,7 @@ const HexplorationMod = (() => { perPage: '(Kan per pagina worden ingesteld.)', }, jumpgate: { - heading: 'Jumpgate en erfenis', + heading: 'Jumpgate en Legacy', points: [ 'Hexploration zoekt uit welke engine het spel gebruikt en tekent de bijpassende vorm. Vormen die in beide editors zijn getekend, kunnen worden gevuld.', 'Als Laag voor zeshoeken op Automatisch staat, worden zeshoeken op de voorgrondlaag getekend, boven de tokens, zodat spelers niet kunnen zien wat eronder ligt. Als de voorgrondlaag niet beschikbaar is, wordt in plaats daarvan de tokenlaag gebruikt.', @@ -3428,13 +3431,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Talen', - body: 'Kies een taal met de door !hexploration ingestelde taal. Beschikbare talen:', + body: 'Kies een taal met !hexploration set language. Beschikbare talen:', colLanguage: 'Taal', colNative: 'Eigen naam', colCode: 'Code', }, credits: { - heading: 'Kredieten', + heading: 'Credits', original: 'Originele mod door', maintainer: 'Versie 2 onderhouden door', marketplace: "Ada's kunstpakketten op de Roll20 Marketplace", @@ -3906,15 +3909,15 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Täyttöväri', - desc: 'Uusien kuusioiden väri. Käytä rgba()-funktiota läpinäkyville heksadesille, esimerkiksi rgba(0,0,0,0.8).', + desc: 'Uusien heksojen väri. Käytä rgba()-funktiota läpikuultaville heksoille, esimerkiksi rgba(0,0,0,0.8).', }, strokeColor: { label: 'Reunan väri', - desc: 'Uusien kuusioiden ääriviivan väri.', + desc: 'Uusien heksojen ääriviivan väri.', }, labelColor: { label: 'Nimilappujen väri', - desc: 'Vain GM:n nimitarrojen väri nimetyissä heksadesissä.', + desc: 'Vain GM:n näkemien nimilappujen väri nimetyissä heksoissa.', }, glimpseColor: { label: 'Vilkaisun väri', @@ -3938,11 +3941,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Paljasta reitin varrelta', - desc: 'Kun se on päällä, jokainen hex, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', + desc: 'Kun se on päällä, jokainen heksa, jonka läpi merkki kulkee vedettäessä (mukaan lukien reittipisteet), paljastetaan, ei vain sen pysähtymiskohtaa.', }, revealBy: { label: 'Paljastavat merkit', - desc: 'Token-kerroksen merkit paljastavat heksioita: pelaajan hallitsemia merkkejä, mitä tahansa hahmoa edustavia merkkejä tai jokaista merkkiä.', + desc: 'Mitkä merkkitason merkit paljastavat heksoja: pelaajan hallitsemat merkit, mitä tahansa hahmoa edustavat merkit tai kaikki merkit.', }, revealMode: { label: 'Paljastustila', @@ -3958,7 +3961,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Piilota peitetyt merkit', - desc: 'Roll20 piirtää nimiä, palkkeja ja auloja heksaan yläpuolelle. Kun se on päällä, peitetyn heksan alla olevilla rahakkeilla on pelaajalle näkyvä nimi, palkit ja aurat pois päältä ja takaisin päälle, kun ne paljastuvat.', + desc: 'Roll20 piirtää nimet, palkit ja aurat heksojen päälle. Kun se on päällä, peitetyn heksan alla olevien merkkien pelaajille näkyvä nimi, palkit ja aurat kytketään pois päältä ja takaisin päälle, kun merkit paljastuvat.', }, }, status: { @@ -3980,22 +3983,22 @@ const HexplorationMod = (() => { revealed: 'Heksat paljastettiin: {count}.', revealedPage: 'Jokainen sivun heksa paljastettiin ({count}).', confirmReset: - 'Poistetaanko jokainen heksa kohdasta "{page}" ({count})? Sijaintitunnukset palaavat merkkikerrokseen. Kumoa ei voi peruuttaa tätä.', - resetPage: 'Heksit poistettu sivulta: {count}.', + 'Poistetaanko kaikki heksat sivulta "{page}" ({count})? Sijaintimerkit palaavat merkkitasolle. Kumoa ei voi peruuttaa tätä.', + resetPage: 'Sivulta poistetut heksat: {count}.', undone: - 'Viimeinen täyttö kumottu. Heksit poistettu: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', - named: 'Heksaalit nimeltä "{name}": {count}.', + 'Viimeinen täyttö kumottu. Poistetut heksat: {removed}. Uudelleen muotoillut heksat palautettu: {restored}.', + named: 'Heksat nimeltä "{name}": {count}.', unnamed: 'Poistetut nimet: {count}.', marked: - 'Olemassa oleviin heksaan piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', - unmarked: 'Tunnukset, jotka eivät ole enää sijainteja: {count}.', + 'Olemassa oleviin heksoihin piilotetut sijainnit: {attached}. Odotetaan seuraavaa täyttöä, joka kattaa ne: {pending}.', + unmarked: 'Merkit, jotka eivät ole enää sijainteja: {count}.', settingChanged: '{setting} asetettu arvoon {value}.', rescanned: - 'Uudelleenskannaus valmis. Säilytetty: {kept}. Hyväksytty: {adopted}. Arkistoitu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt tunnisteet: {labels}. Sijaintitunnukset linkitetty uudelleen: {icons}.', + 'Uudelleenskannaus valmis. Säilytetty: {kept}. Otettu käyttöön: {adopted}. Sijoitettu uudelleen: {moved}. Kadonnut ja unohdettu: {dropped}. Uudelleen linkitetyt nimilaput: {labels}. Uudelleen linkitetyt sijaintimerkit: {icons}.', calibrated: - 'Ruudukko kalibroitu (sarakkeen vaihe {colStep}px, rivin vaihe {rowStep}px). Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Ruudukko kalibroitu (sarakeaskel {colStep}px, riviaskel {rowStep}px). Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', calibrationReset: - 'Kalibrointi poistettu. Tarkista uudelleen: säilytetty {kept}, arkistoitu uudelleen {moved}, hyväksytty {adopted}.', + 'Kalibrointi poistettu. Uudelleenskannaus: säilytetty {kept}, sijoitettu uudelleen {moved}, otettu käyttöön {adopted}.', journalRebuilt: 'Monisteet "{help}" ja "{deck}" on rakennettu uudelleen.', migrated: 'Hexploration 1.x -heksakarttasi on päivitetty. Jos tämä peli on kopioitu Legacy-pelistä, suorita Skannaa uudelleen jokaisella heksakarttasivulla.', @@ -4006,26 +4009,27 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Tämä peli ei tue piirtämistä etualan kerrokselle, joten heksaat piirrettiin merkkikerrokseen.', + 'Tämä peli ei tue piirtämistä etualan tasolle, joten heksat piirrettiin merkkitasolle.', someFailed: 'Heksat, joita ei voitu piirtää: {count}. Katso lisätietoja API-konsolista.', }, errors: { noPage: 'Työstettävää sivua ei löytynyt.', - notHex: 'Tämä sivu ei käytä kuusioruudukkoa.', + notHex: 'Tämä sivu ei käytä heksaruudukkoa.', noPolygons: 'Valitse yksi tai useampi piirretty muoto täytettäväksi.', emptyArea: 'Valittu alue ei sisällä heksakeskuksia.', tooMany: 'Tämä loisi liian monta heksaa kerralla ({count}).', nothingToConceal: 'Valitse piilotettavat piirretyt muodot tai merkit.', - nothingToReveal: 'Valitse paljastettavat kuusikat, piirretyt muodot tai merkit.', + nothingToReveal: 'Valitse paljastettavat heksat, piirretyt muodot tai merkit.', noTokens: 'Valitse ensin yksi tai useampi merkki.', - noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova rahake).', + noHexes: 'Valitse ensin yksi tai useampi heksa (tai heksoilla seisova merkki).', nothingToUndo: 'Kumoavaa täyttöä ei ole.', unknownCommand: 'Tuntematon komento: {command}', unknownSetting: 'Tuntematon asetus: {key}', unknownPageSetting: 'Sivukohtaisesti määritettävissä olevat asetukset: {keys}', invalidValue: '"{value}" ei ole kelvollinen arvo kohteelle {key}.', - calibrateNeedsTokens: 'Valitse yksi tai kaksi kuusiokeskuksiin napsautettua rahaketta.', - calibrateFailed: 'Näitä tunnuksia ei voi käyttää kalibrointiin.', + calibrateNeedsTokens: + 'Valitse yksi tai kaksi merkkiä, jotka on kiinnitetty heksojen keskipisteisiin.', + calibrateFailed: 'Näitä merkkejä ei voi käyttää kalibrointiin.', unexpected: 'Jotain meni pieleen: {message}', }, hints: { @@ -4036,36 +4040,36 @@ const HexplorationMod = (() => { emptyArea: 'Piirrä suurempi muoto tai tarkista sivuruudukon asetukset.', tooMany: 'Täytä pienempi alue tai jaa alue useisiin muotoihin.', noHexes: - 'Heksit ovat etualalla tai merkkikerroksessa; vaihda kyseiselle tasolle valitaksesi ne.', + 'Heksat ovat etualan tasolla tai merkkitasolla; vaihda kyseiselle tasolle valitaksesi ne.', unknownCommand: 'Kirjoita !hexploration help listataksesi komennot.', unknownSetting: 'Näet kaikki asetukset kirjoittamalla !hexploration set.', calibrateNeedsTokens: 'Kiinnitä merkki heksan keskelle ja valitse se. Korjaa myös heksan koko valitsemalla toinen merkki, joka on kiinnitetty viereiseen heksaan samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H).', calibrateFailed: - 'Kahden tunnuksen on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', + 'Kahden merkin on oltava samalla rivillä (Hex V) tai samassa sarakkeessa (Hex H), vähintään yhden heksan päässä toisistaan.', unexpected: 'Yksityiskohdat ovat API-konsolin lokissa.', }, help: { menu: 'Näytä valikko.', - fill: 'Peitä valitut piirretyt muodot kuusioilla.', + fill: 'Peitä valitut piirretyt muodot heksoilla.', fillInverse: 'Peitä koko sivu paitsi valittujen muotojen sisällä.', - undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai piilota ja palauta käytetyt muodot.', - reveal: 'Näytä valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', - revealPage: 'Paljasta sivun jokainen hex ilman ilmoituksia.', - conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen kuusioilla.', + undo: 'Kumoa viimeinen täyttö, käänteinen täyttö tai peitto ja palauta sen käyttämät muodot.', + reveal: 'Paljasta valitut heksat ja valittujen muotojen ja merkkien alla olevat heksat.', + revealPage: 'Paljasta sivun kaikki heksat ilman ilmoituksia.', + conceal: 'Peitä alue valittujen muotojen ja merkkien alla uudelleen heksoilla.', explore: - 'Paljasta valittujen rahakkeiden ympärillä ikään kuin ne olisivat juuri muuttaneet sinne.', - resetPage: 'Poista sivulta jokainen hekseli (kysyy ensin).', + 'Paljasta valittujen merkkien ympäristö ikään kuin ne olisivat juuri siirtyneet sinne.', + resetPage: 'Poista sivulta kaikki heksat (kysyy ensin).', name: 'Nimeä valitut heksat tai valittujen merkkien alla olevat heksat. Tyhjennä se jättämällä nimen tyhjäksi.', - mark: 'Muuta valitut merkit piilotettuihin paikkoihin.', - unmark: 'Estä valittujen merkkien piilottaminen.', + mark: 'Muuta valitut merkit piilotetuiksi sijainneiksi.', + unmark: 'Lopeta valittujen merkkien käyttö piilotettuina sijainteina.', set: 'Muuta asetusta tai näytä kaikki asetukset.', pageSet: 'Ohita paljastamisasetus vain nykyisellä sivulla.', pageClear: 'Poista nykyisen sivun ohitukset.', rescan: 'Rakenna sivun heksaluettelo uudelleen, esimerkiksi sivun tai pelin kopioinnin jälkeen.', calibrate: - 'Linjaa kuusioruudukko yhdellä tai kahdella valitulla kentällä, jotka on napsautettu kuusiokeskuksiin.', + 'Kohdista heksaruudukko yhteen tai kahteen valittuun merkkiin, jotka on kiinnitetty heksojen keskipisteisiin.', calibrateReset: 'Poista nykyisen sivun kalibrointi.', status: 'Näytä, mitä Hexploration tietää nykyisestä sivusta.', journal: 'Rakenna monisteet Help ja Command Deck uudelleen.', @@ -4085,11 +4089,11 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'Versio', - subtitle: 'Hex-by-hex tutkiminen Roll20:lle', + subtitle: 'Tutkimista heksa kerrallaan Roll20:lle', footer: 'Käytä "{deck}" -monistetta yhden napsautuksen ohjaimiin.', overview: { heading: 'Yleiskatsaus', - body: 'Hexploration kattaa hex-kartan läpinäkymättömillä heksailla. Kun seurue liikkuu, niiden läpi kulkevat heksat (ja halutessasi niiden ympärillä olevat heksat) poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V) ja Hex (H) -ruudukoissa.', + body: 'Hexploration peittää heksakartan läpinäkymättömillä heksoilla. Kun seurue liikkuu, heksat, joiden läpi se kulkee (ja halutessasi sen ympärillä olevat heksat), poistetaan, joten kartta paljastuu heksa kerrallaan. Piilotetut paikat voidaan sijoittaa heksojen alle ja niistä ilmoitetaan, kun ne löydetään. Se toimii Jumpgate- ja Legacy-peleissä, minkä tahansa kokoisissa Hex (V)- ja Hex (H) -ruudukoissa.', demo: 'Katso lyhyt esittely (versiosta 1)', }, quickStart: { @@ -4103,7 +4107,7 @@ const HexplorationMod = (() => { ], }, commands: { - heading: 'komennot', + heading: 'Komennot', intro: 'Vain GM:t voivat käyttää näitä komentoja. Useimmat toimivat valittuihin objekteihin; loput toimivat katsomallasi sivulla.', colCommand: 'Komento', @@ -4122,11 +4126,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Nimetty Heksit ja sijainnit', + heading: 'Nimetyt heksat ja sijainnit', points: [ 'Merkitse sijainti muuttaa valitut merkit piilotetuiksi sijainneiksi. Jo heksan alla oleva merkki piilotetaan heti; muuten sen piilottaa seuraava täyttö, joka peittää sen.', - 'Valkoisen tornin tilamerkillä varustetut rahakkeet käsitellään myös sijainneina, kun täytät, kuten versiossa 1.', - 'Piilotetut sijaintitunnukset siirretään GM-tasolle. Kun heidän heksansa paljastetaan, he palaavat merkkikerrokseen ja heidän nimensä näytetään, ja heidän löytönsä ilmoitetaan.', + 'Valkoisen tornin tilamerkillä varustetut merkit käsitellään myös sijainteina, kun täytät, kuten versiossa 1.', + 'Piilotetut sijaintimerkit siirretään GM-tasolle. Kun niiden heksa paljastetaan, ne palaavat merkkitasolle nimi näkyvissä, ja niiden löytymisestä ilmoitetaan.', 'Nimeä heksa antaa heksalle nimen ilman merkkiä. Nimi näytetään GM:lle nimilappuna GM-tasolla, ja siitä ilmoitetaan, kun heksa paljastetaan. Jumpgate piirtää GM-tason etualan tason alle, joten Jumpgatessa nimilaput näkyvät vain, kun Heksataso-asetuksena on merkkitaso.', 'Ilmoita löydöt valitsee, näkevätkö ilmoituksen kaikki, vain GM vai ei kukaan. Pingaa löydöt siirtää lisäksi pelaajien näkymän sijaintiin.', ], @@ -4289,7 +4293,7 @@ const HexplorationMod = (() => { }, labelColor: { label: "Couleur de l'étiquette", - desc: 'Couleur des étiquettes de nom réservées aux GM sur les hexs nommés.', + desc: 'Couleur des étiquettes de nom réservées au MJ sur les hexagones nommés.', }, glimpseColor: { label: "Couleur d'aperçu", @@ -4297,7 +4301,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Largeur de la bordure', - desc: 'Largeur du contour des nouveaux hexs, en pixels (0 à 20).', + desc: 'Largeur du contour des nouveaux hexagones, en pixels (0 à 20).', }, maxDistance: { label: 'Distance de révélation des hexagones', @@ -4313,7 +4317,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Révéler le long du chemin', - desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les waypoints) est révélé, pas seulement l'endroit où il s'arrête.", + desc: "Lorsque cette option est activée, chaque hexagone traversé par un jeton lorsqu'il est déplacé (y compris les points de passage) est révélé, pas seulement l'endroit où il s'arrête.", }, revealBy: { label: 'Jetons révélateurs', @@ -4333,7 +4337,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Masquer les jetons couverts', - desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsqu'ils sont activés, les jetons situés sous un hexagone couvert ont leur nom visible par le joueur, leurs barres et leurs auras éteints, et réactivés lorsqu'ils sont découverts.", + desc: "Roll20 dessine des noms, des barres et des auras au-dessus des hexagones. Lorsque cette option est activée, les jetons situés sous un hexagone couvert ont leur nom visible par les joueurs, leurs barres et leurs auras désactivés, puis réactivés lorsqu'ils sont découverts.", }, }, status: { @@ -4352,21 +4356,21 @@ const HexplorationMod = (() => { messages: { filled: 'Remplissage terminé. Hexagones dessinés : {created}. Restylés : {restyled}. Emplacements cachés : {icons}.', - revealed: 'Hexs révélés : {count}.', + revealed: 'Hexagones révélés : {count}.', revealedPage: 'Chaque hexagone de la page révélé ({count}).', confirmReset: - 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent à la couche de jetons. L\'annulation ne peut pas inverser cette situation.', - resetPage: 'Hexs supprimés de la page : {count}.', + 'Supprimer chaque hexagone de "{page}" ({count}) ? Les jetons d\'emplacement reviennent sur le calque des jetons. Annuler le remplissage ne pourra pas revenir sur cette action.', + resetPage: 'Hexagones supprimés de la page : {count}.', undone: - 'Dernier remplissage annulé. Hexs supprimés : {removed}. Hexs relookés restaurés : {restored}.', - named: 'Hexs nommés "{name}" : {count}.', + 'Dernier remplissage annulé. Hexagones supprimés : {removed}. Hexagones restylés restaurés : {restored}.', + named: 'Hexagones nommés "{name}" : {count}.', unnamed: 'Noms effacés : {count}.', marked: - 'Emplacements cachés dans les hexs existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', + 'Emplacements cachés dans les hexagones existants : {attached}. En attente du prochain remplissage qui les couvre : {pending}.', unmarked: 'Jetons qui ne sont plus des emplacements : {count}.', settingChanged: '{setting} défini sur {value}.', rescanned: - 'Nouvelle analyse terminée. Conservé : {kept}. Adopté : {adopted}. Re-déposé : {moved}. Manquant et oublié : {dropped}. Libellés réassociés : {labels}. Jetons de localisation réassociés : {icons}.', + "Nouvelle analyse terminée. Conservés : {kept}. Adoptés : {adopted}. Reclassés : {moved}. Manquants et oubliés : {dropped}. Libellés réassociés : {labels}. Jetons d'emplacement réassociés : {icons}.", calibrated: 'Grille calibrée (pas de colonne {colStep}px, pas de ligne {rowStep}px). Nouvelle analyse : conservé {kept}, reclassé {moved}, adopté {adopted}.', calibrationReset: @@ -4375,7 +4379,7 @@ const HexplorationMod = (() => { migrated: "Vos cartes hexagonales Hexploration 1.x ont été mises à niveau. Si ce jeu a été copié à partir d'un jeu Legacy, lancez une nouvelle analyse sur chaque page de carte hexagonale.", pruned: - "Hexs enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", + "Hexagones enregistrés qui n'existent plus et ont été oubliés : {dropped}. Si ce jeu ou cette page a été copié, lancez une nouvelle analyse sur la page pour récupérer ses hexagones.", readyHint: 'Tapez !hexploration pour afficher le menu, ou ouvrez le document "Hexploration - Command Deck".', }, @@ -4383,11 +4387,11 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Ce jeu ne prend pas en charge le dessin sur la couche de premier plan, les hexagones ont donc été dessinés sur la couche de jetons.', someFailed: - "Hexs qui n'ont pas pu être tirés : {count}. Consultez la console API pour plus de détails.", + "Hexagones qui n'ont pas pu être dessinés : {count}. Consultez la console API pour plus de détails.", }, errors: { noPage: 'Impossible de trouver la page sur laquelle travailler.', - notHex: "Cette page n'utilise pas de grille hexadécimale.", + notHex: "Cette page n'utilise pas de grille hexagonale.", noPolygons: 'Sélectionnez une ou plusieurs formes dessinées à remplir.', emptyArea: "La zone sélectionnée ne contient aucun centre d'hexagone.", tooMany: "Cela créerait trop d'hexagones en une seule fois ({count}).", @@ -4421,21 +4425,21 @@ const HexplorationMod = (() => { calibrateNeedsTokens: "Placez un jeton au centre d'un hexagone et sélectionnez-le. Sélectionnez un deuxième jeton accroché à un hexagone voisin dans la même ligne (Hex V) ou colonne (Hex H) pour corriger également la taille de l'hexagone.", calibrateFailed: - "Deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hex l'un de l'autre.", + "Les deux jetons doivent être dans la même ligne (Hex V) ou dans la même colonne (Hex H), à au moins un hexagone l'un de l'autre.", unexpected: 'Les détails se trouvent dans le journal de la console API.', }, help: { menu: 'Afficher le menu.', fill: 'Couvrez les formes dessinées sélectionnées avec des hexagones.', fillInverse: "Couvrez toute la page sauf à l'intérieur des formes sélectionnées.", - undo: 'Annulez le dernier remplissage, inversez le remplissage ou masquez-le et restaurez les formes utilisées.', + undo: "Annulez le dernier remplissage, remplissage inversé ou masquage, et restaurez les formes qu'il a utilisées.", reveal: 'Révélez les hexagones sélectionnés et les hexagones sous les formes et les jetons sélectionnés.', revealPage: 'Révélez chaque hexagone de la page sans annonce.', conceal: 'Couvrez à nouveau la zone sous les formes et les jetons sélectionnés avec des hexagones.', explore: "Révélez autour des jetons sélectionnés comme s'ils venaient de s'y déplacer.", - resetPage: 'Supprimez tous les hexagones de la page (demande en premier).', + resetPage: 'Supprimez tous les hexagones de la page (avec confirmation).', name: "Nommez les hexagones sélectionnés ou les hexagones sous les jetons sélectionnés. Laissez le nom vide pour l'effacer.", mark: 'Transformez les jetons sélectionnés en emplacements cachés.', unmark: "Empêchez les jetons sélectionnés d'être des emplacements cachés.", @@ -4443,7 +4447,7 @@ const HexplorationMod = (() => { pageSet: 'Remplacer un paramètre de révélation sur la page actuelle uniquement.', pageClear: 'Supprimez les remplacements de la page actuelle.', rescan: - 'Reconstruisez la liste hexadécimale de la page, par exemple après avoir copié une page ou un jeu.', + 'Reconstruisez la liste des hexagones de la page, par exemple après avoir copié une page ou un jeu.', calibrate: 'Alignez la grille hexagonale avec un ou deux jetons sélectionnés accrochés aux centres des hexagones.', calibrateReset: 'Supprimez le calibrage de la page actuelle.', @@ -4460,16 +4464,16 @@ const HexplorationMod = (() => { locationsDesc: "Sélectionnez les jetons pour les cacher en tant qu'emplacements sous les hexagones. Sélectionnez des hexagones ou des jetons pour nommer un hexagone.", toolsDesc: - 'Paramètres, remplacements de pages, statut, nouvelle numérisation des pages copiées et calibrage de la grille.', + 'Paramètres, remplacements de page, statut, nouvelle analyse des pages copiées et calibrage de la grille.', footer: 'Consultez le document « {help} » pour obtenir des instructions complètes.', }, handout: { versionLabel: 'Version', - subtitle: 'Exploration hex par hex pour Roll20', + subtitle: 'Exploration hexagone par hexagone pour Roll20', footer: 'Utilisez le document "{deck}" pour les contrôles en un clic.', overview: { - heading: 'Aperçu', - body: "L'hexploration couvre une carte d'hexagones avec des hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", + heading: "Vue d'ensemble", + body: "Hexploration recouvre une carte hexagonale d'hexagones opaques. Au fur et à mesure que le groupe se déplace, les hexagones qu'il traverse (et, si vous le souhaitez, les hexagones qui l'entourent) sont supprimés, de sorte que la carte est découverte un hexagone à la fois. Les emplacements cachés peuvent être placés sous les hexagones et sont annoncés lorsqu'ils sont trouvés. Il fonctionne dans les jeux Jumpgate et Legacy, sur les grilles Hex (V) et Hex (H) de n'importe quelle taille.", demo: 'Regardez une courte démo (à partir de la version 1)', }, quickStart: { @@ -4479,7 +4483,7 @@ const HexplorationMod = (() => { 'Dessinez une ou plusieurs formes (polygone, rectangle, ellipse ou à main levée) autour de la zone à masquer.', 'Sélectionnez les formes et cliquez sur Remplir dans le Command Deck (ou tapez !hexploration fill). Les formes sont remplacées par des hexagones.', "Facultatif : avant de remplir, sélectionnez les jetons pour les lieux importants et cliquez sur Marquer l'emplacement. Ils sont cachés sous les hexagones et annoncés dès leur découverte.", - "Déplacez un jeton de joueur. Chaque hex qu'il traverse, ainsi que les hexs situés à sa distance de vue, sont révélés.", + "Déplacez un jeton de joueur. Chaque hexagone qu'il traverse, ainsi que les hexagones situés dans sa Distance de vue, sont révélés.", ], }, commands: { @@ -4493,7 +4497,7 @@ const HexplorationMod = (() => { heading: 'Comment fonctionne la révélation', points: [ 'Seuls les jetons sur le calque des jetons révèlent des hexagones. Les jetons concernés sont définis par Jetons révélateurs : les jetons de joueur par défaut, afin que le MJ puisse déplacer des monstres sans découvrir la carte.', - "Un jeton révèle chaque hex qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hex de la route qu'il a parcouru, y compris les waypoints.", + "Un jeton révèle chaque hexagone qu'il couvre (les gros jetons en couvrent plusieurs) et, avec Révéler le long du chemin activé, chaque hexagone du trajet le long duquel il a été déplacé, y compris les points de passage.", "La Distance de vue révèle les hexagones autour de chacun de ces hexagones, en commençant par les plus proches. Avec Ligne de vue activée, un hexagone n'est pas révélé tant qu'un hexagone couvert se trouve entre lui et le jeton. Les hexagones les plus proches sont généralement révélés en premier, donc en terrain dégagé la Ligne de vue ne change rien : elle ne compte qu'avec une Distance de vue de 2 ou plus et des hexagones qui restent couverts, comme un terrain rempli avec une Distance de révélation des hexagones.", "La Distance de révélation des hexagones est enregistrée sur chaque hexagone au moment où il est rempli, donc réglez-la avant de remplir ; la modifier ensuite n'affecte pas les hexagones déjà présents sur la carte. Un jeton doit se trouver à ce nombre d'hexagones au plus pour les révéler, aussi loin qu'il puisse voir, et avec 0 ils ne sont révélés qu'en y entrant. Pour une chaîne de montagnes : réglez la Distance de révélation des hexagones sur 0, remplissez les montagnes, remettez-la sans limite, puis remplissez les terres au-delà. Avec une Distance de vue de 3 et la Ligne de vue activée, le groupe voit le terrain dégagé autour de lui, mais pas les montagnes ni ce qui se trouve derrière. Chaque hexagone de montagne est révélé lorsqu'un jeton y pénètre.", "En mode Aperçu, les hexagones visibles deviennent transparents au lieu de disparaître et sont supprimés lorsqu'un jeton y pénètre. Les hexagones aperçus ne bloquent pas la Ligne de vue.", @@ -4502,11 +4506,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexs et emplacements nommés', + heading: 'Hexagones nommés et emplacements', points: [ "Marquer l'emplacement transforme les jetons sélectionnés en emplacements cachés. Un jeton déjà sous un hexagone est caché immédiatement ; sinon, il est caché par le prochain remplissage qui le recouvre.", 'Les jetons avec le marqueur de statut tour blanche sont également traités comme des emplacements lorsque vous remplissez, comme dans la version 1.', - "Les jetons d'emplacement cachés sont déplacés vers la couche GM. Lorsque leur hexagone est révélé, ils retournent à la couche de jetons avec leur nom affiché et leur découverte est annoncée.", + "Les jetons d'emplacement cachés sont déplacés vers le calque MJ. Lorsque leur hexagone est révélé, ils retournent sur le calque des jetons avec leur nom affiché et leur découverte est annoncée.", "Nommer l'hexagone donne un nom à un hexagone sans jeton. Le nom est montré au MJ sous forme d'étiquette sur le calque MJ et annoncé lorsque l'hexagone est révélé. Jumpgate dessine le calque MJ sous le calque de premier plan, donc dans Jumpgate les étiquettes ne sont visibles que si Calque des hexagones est réglé sur le calque des jetons.", "Annoncer les découvertes détermine si tout le monde, seulement le MJ ou personne ne voit l'annonce. Pinger les découvertes déplace aussi la vue des joueurs vers l'emplacement.", ], @@ -4521,7 +4525,7 @@ const HexplorationMod = (() => { perPage: '(Peut être défini par page.)', }, jumpgate: { - heading: 'Jumpgate et héritage', + heading: 'Jumpgate et Legacy', points: [ "Hexploration détermine quel moteur le jeu utilise et dessine le type de forme correspondant. Les formes dessinées dans l'un ou l'autre éditeur peuvent être remplies.", "Avec Calque des hexagones réglé sur Auto, les hexagones sont dessinés sur le calque de premier plan, au-dessus des jetons, afin que les joueurs ne puissent pas voir ce qu'il y a en dessous. Si le calque de premier plan n'est pas disponible, le calque des jetons est utilisé à la place.", @@ -4544,8 +4548,8 @@ const HexplorationMod = (() => { heading: 'Dépannage', points: [ 'Rien ne se passe quand un jeton se déplace : vérifiez que le jeton est sur le calque des jetons et correspond à Jetons révélateurs, et que la page contient des hexagones (!hexploration status).', - 'Les hexs sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexs de la carte.', - "Les hexagones ont cessé de s'afficher après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", + 'Les hexagones sont décalés par rapport à la grille : utilisez Calibrer, puis vérifiez avec un jeton sur quelques hexagones répartis sur la carte.', + "Les hexagones ne sont plus révélés après la copie d'une page ou d'un jeu : lancez une nouvelle analyse de la page.", "Remplir indique que la zone ne contient aucun centre d'hexagone : la forme doit contenir le centre d'au moins un hexagone.", "Pour toute autre chose, consultez le journal de la console API et incluez ses messages lorsque vous demandez de l'aide.", ], @@ -4661,7 +4665,7 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Füllfarbe', - desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexadezimalwerte, zum Beispiel rgba(0,0,0,0.8).', + desc: 'Farbe neuer Hexfelder. Verwenden Sie rgba() für durchsichtige Hexfelder, zum Beispiel rgba(0,0,0,0.8).', }, strokeColor: { label: 'Randfarbe', @@ -4697,7 +4701,7 @@ const HexplorationMod = (() => { }, revealBy: { label: 'Aufdeckende Token', - desc: 'Welche Spielsteine ​​auf der Spielsteinebene zeigen Hexereien an: Spielsteine, die von einem Spieler kontrolliert werden, Spielsteine, die einen beliebigen Charakter repräsentieren, oder jeder Spielstein.', + desc: 'Welche Token auf der Token-Ebene Hexfelder aufdecken: Token, die von einem Spieler gesteuert werden, Token, die einen beliebigen Charakter darstellen, oder alle Token.', }, revealMode: { label: 'Aufdeckmodus', @@ -4731,26 +4735,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Vollständig ausfüllen. Gezeichnete Hexen: {created}. Neu gestaltet: {restyled}. Ausgeblendete Orte: {icons}.', - revealed: 'Aufgedeckte Verhexungen: {count}.', - revealedPage: 'Jedes Hex auf der Seite wird angezeigt ({count}).', + 'Füllen abgeschlossen. Gezeichnete Hexfelder: {created}. Neu gestaltet: {restyled}. Versteckte Standorte: {icons}.', + revealed: 'Aufgedeckte Hexfelder: {count}.', + revealedPage: 'Alle Hexfelder auf der Seite aufgedeckt ({count}).', confirmReset: - 'Jedes Hex aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', - resetPage: 'Hexes wurden von der Seite entfernt: {count}.', + 'Alle Hexfelder aus „{page}“ ({count}) entfernen? Standort-Tokens kehren zur Token-Ebene zurück. Durch Rückgängigmachen kann dies nicht rückgängig gemacht werden.', + resetPage: 'Von der Seite entfernte Hexfelder: {count}.', undone: - 'Letzte Füllung rückgängig gemacht. Entfernte Verhexungen: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', - named: 'Hexen mit dem Namen „{name}“: {count}.', + 'Letzte Füllung rückgängig gemacht. Entfernte Hexfelder: {removed}. Neu gestaltete Hexfelder wiederhergestellt: {restored}.', + named: 'Hexfelder mit dem Namen „{name}“: {count}.', unnamed: 'Gelöschte Namen: {count}.', marked: 'In vorhandenen Hexfeldern versteckte Orte: {attached}. Warten auf die nächste Füllung, die sie abdeckt: {pending}.', unmarked: 'Token, die keine Standorte mehr sind: {count}.', settingChanged: '{setting} wird auf {value} gesetzt.', rescanned: - 'Neuscan abgeschlossen. Behalten: {kept}. Angenommen: {adopted}. Erneut eingereicht: {moved}. Fehlt und vergessen: {dropped}. Neu verknüpfte Etiketten: {labels}. Standort-Tokens neu verknüpft: {icons}.', + 'Erneuter Scan abgeschlossen. Behalten: {kept}. Übernommen: {adopted}. Neu zugeordnet: {moved}. Fehlend und vergessen: {dropped}. Neu verknüpfte Beschriftungen: {labels}. Neu verknüpfte Standort-Token: {icons}.', calibrated: - 'Rasterkalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Raster kalibriert (Spaltenschritt {colStep}px, Zeilenschritt {rowStep}px). Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', calibrationReset: - 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, erneut eingereicht {moved}, übernommen {adopted}.', + 'Kalibrierung entfernt. Erneut scannen: beibehalten {kept}, neu zugeordnet {moved}, übernommen {adopted}.', journalRebuilt: 'Die Handouts „{help}“ und „{deck}“ wurden neu erstellt.', migrated: 'Ihre Hexploration-1.x-Hexkarten wurden aktualisiert. Wenn dieses Spiel aus einem Legacy-Spiel kopiert wurde, führen Sie auf jeder Hexkartenseite „Erneut scannen“ aus.', @@ -4763,18 +4767,18 @@ const HexplorationMod = (() => { foregroundUnavailable: 'Dieses Spiel unterstützt das Zeichnen auf der Vordergrundebene nicht, daher wurden Hexfelder auf der Tokenebene gezeichnet.', someFailed: - 'Hexen, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', + 'Hexfelder, die nicht gezeichnet werden konnten: {count}. Weitere Informationen finden Sie in der API-Konsole.', }, errors: { noPage: 'Die Seite, an der gearbeitet werden soll, konnte nicht gefunden werden.', notHex: 'Diese Seite verwendet kein Hex-Raster.', noPolygons: 'Wählen Sie eine oder mehrere gezeichnete Formen zum Füllen aus.', - emptyArea: 'Der ausgewählte Bereich enthält keine Hex-Zentren.', - tooMany: 'Das würde zu viele Verhexungen auf einmal erzeugen ({count}).', + emptyArea: 'Der ausgewählte Bereich enthält keine Hexfeld-Mittelpunkte.', + tooMany: 'Das würde zu viele Hexfelder auf einmal erzeugen ({count}).', nothingToConceal: - 'Wählen Sie gezeichnete Formen oder Spielsteine ​​aus, die Sie verbergen möchten.', + 'Wählen Sie gezeichnete Formen oder Spielsteine aus, die Sie verbergen möchten.', nothingToReveal: - 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine ​​aus, die Sie aufdecken möchten.', + 'Wählen Sie Hexfelder, gezeichnete Formen oder Spielsteine aus, die Sie aufdecken möchten.', noTokens: 'Wählen Sie zunächst einen oder mehrere Token aus.', noHexes: 'Wählen Sie zunächst ein oder mehrere Hexfelder (oder darauf stehende Spielsteine) aus.', @@ -4784,7 +4788,7 @@ const HexplorationMod = (() => { unknownPageSetting: 'Einstellungen, die pro Seite festgelegt werden können: {keys}', invalidValue: '„{value}“ ist kein gültiger Wert für {key}.', calibrateNeedsTokens: - 'Wählen Sie ein oder zwei Token aus, die an den Sechseckzentren befestigt werden.', + 'Wählen Sie ein oder zwei Token aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateFailed: 'Diese Token können nicht zur Kalibrierung verwendet werden.', unexpected: 'Es ist ein Fehler aufgetreten: {message}', }, @@ -4800,38 +4804,38 @@ const HexplorationMod = (() => { tooMany: 'Füllen Sie einen kleineren Bereich oder teilen Sie den Bereich in mehrere Formen auf.', noHexes: - 'Verhexungen befinden sich im Vordergrund oder auf der Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', + 'Hexfelder liegen auf der Vordergrund- oder Token-Ebene. Wechseln Sie zu dieser Ebene, um sie auszuwählen.', unknownCommand: 'Geben Sie !hexploration help ein, um die Befehle aufzulisten.', unknownSetting: 'Geben Sie !hexploration set ein, um alle Einstellungen anzuzeigen.', calibrateNeedsTokens: 'Rasten Sie einen Spielstein in der Mitte eines Hexfelds ein und wählen Sie ihn aus. Wählen Sie ein zweites Token aus, das an einem benachbarten Hexfeld in derselben Zeile (Hex V) oder Spalte (Hex H) eingerastet ist, um auch die Hexfeldgröße zu korrigieren.', calibrateFailed: - 'Zwei Spielsteine ​​müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hex voneinander entfernt sein.', + 'Zwei Spielsteine müssen sich in derselben Reihe (Hex V) oder derselben Spalte (Hex H) befinden und mindestens ein Hexfeld voneinander entfernt sein.', unexpected: 'Details finden Sie im API-Konsolenprotokoll.', }, help: { menu: 'Zeigen Sie das Menü an.', - fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexen ab.', + fill: 'Decken Sie die ausgewählten gezeichneten Formen mit Hexfeldern ab.', fillInverse: 'Bedecken Sie die gesamte Seite mit Ausnahme der ausgewählten Formen.', - undo: 'Machen Sie die letzte Füllung rückgängig, kehren Sie die Füllung um oder verbergen Sie sie und stellen Sie die verwendeten Formen wieder her.', + undo: 'Machen Sie die letzte Füllung, umgekehrte Füllung oder Verbergung rückgängig und stellen Sie die dabei verwendeten Formen wieder her.', reveal: 'Zeigt die ausgewählten Hexfelder und die Hexfelder unter den ausgewählten Formen und Spielsteinen an.', - revealPage: 'Enthülle jedes Hex auf der Seite ohne Ankündigungen.', + revealPage: 'Decken Sie alle Hexfelder auf der Seite ohne Ankündigungen auf.', conceal: - 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexen ab.', + 'Decken Sie den Bereich unter den ausgewählten Formen und Spielsteinen erneut mit Hexfeldern ab.', explore: - 'Zeigen Sie die ausgewählten Spielsteine ​​an, als ob sie sich gerade dorthin bewegt hätten.', - resetPage: 'Entferne jedes Hex auf der Seite (fragt zuerst).', + 'Decken Sie die Umgebung der ausgewählten Spielsteine auf, als ob sie sich gerade dorthin bewegt hätten.', + resetPage: 'Entfernen Sie alle Hexfelder auf der Seite (mit Rückfrage).', name: 'Benennen Sie die ausgewählten Hexfelder oder die Hexfelder unter den ausgewählten Spielsteinen. Lassen Sie den Namen leer, um ihn zu löschen.', - mark: 'Verwandeln Sie die ausgewählten Spielsteine ​​in versteckte Orte.', + mark: 'Verwandeln Sie die ausgewählten Spielsteine in versteckte Orte.', unmark: 'Verhindern Sie, dass die ausgewählten Token versteckte Orte sind.', set: 'Ändern Sie eine Einstellung oder zeigen Sie alle Einstellungen an.', - pageSet: 'Überschreiben Sie eine Anzeigeeinstellung nur auf der aktuellen Seite.', + pageSet: 'Überschreiben Sie eine Aufdeck-Einstellung nur auf der aktuellen Seite.', pageClear: 'Entfernen Sie die Überschreibungen der aktuellen Seite.', rescan: - 'Erstellen Sie die Hex-Liste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', + 'Erstellen Sie die Hexfeldliste der Seite neu, beispielsweise nach dem Kopieren einer Seite oder eines Spiels.', calibrate: - 'Richten Sie das Sechseckgitter so aus, dass ein oder zwei ausgewählte Spielsteine ​​in die Sechseckmitten eingerastet werden.', + 'Richten Sie das Hexfeld-Raster an einem oder zwei ausgewählten Spielsteinen aus, die an Hexfeld-Mittelpunkten eingerastet sind.', calibrateReset: 'Entfernen Sie die Kalibrierung der aktuellen Seite.', status: 'Zeigen Sie, was Hexploration über die aktuelle Seite weiß.', journal: 'Erstellen Sie die Handouts Help und Command Deck neu.', @@ -4844,18 +4848,18 @@ const HexplorationMod = (() => { revealDesc: 'Wählen Sie Hexfelder, Formen oder Token aus, um sie aufzudecken oder wieder zu verdecken. „Erkunden“ deckt die Umgebung ausgewählter Token auf, als hätten sie sich bewegt.', locationsDesc: - 'Wählen Sie Spielsteine ​​aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', + 'Wählen Sie Spielsteine aus, um sie als Standorte unter Hexfeldern zu verbergen. Wählen Sie Hexfelder oder Token aus, um einem Hexfeld einen Namen zu geben.', toolsDesc: 'Einstellungen, Seitenüberschreibungen, Status, erneutes Scannen kopierter Seiten und Kalibrieren des Rasters.', footer: 'Vollständige Anweisungen finden Sie im Handout „{help}“.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-für-Hex-Erkundung für Roll20', + subtitle: 'Erkundung Hexfeld für Hexfeld in Roll20', footer: 'Verwenden Sie das Handout „{deck}“ für Ein-Klick-Steuerungen.', overview: { heading: 'Überblick', - body: 'Hexploration umfasst eine Hexfeldkarte mit undurchsichtigen Hexfeldern. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum) entfernt, sodass die Karte jeweils ein Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen auf Hex- (V) und Hex- (H) Gittern jeder Größe.', + body: 'Hexploration deckt eine Hexfeldkarte mit undurchsichtigen Hexfeldern ab. Während sich die Gruppe bewegt, werden die Hexfelder, die sie durchquert (und, wenn Sie möchten, die Hexfelder um sie herum), entfernt, sodass die Karte Hexfeld für Hexfeld freigelegt wird. Versteckte Orte können unter Hexfeldern platziert werden und werden bekannt gegeben, wenn sie gefunden werden. Es funktioniert in Jumpgate- und Legacy-Spielen, auf Hex (V)- und Hex (H)-Rastern jeder Größe.', demo: 'Sehen Sie sich eine kurze Demo an (ab Version 1)', }, quickStart: { @@ -4876,7 +4880,7 @@ const HexplorationMod = (() => { colDesc: 'Was es bewirkt', }, revealing: { - heading: 'Wie Offenlegung funktioniert', + heading: 'Wie das Aufdecken funktioniert', points: [ 'Nur Token auf der Token-Ebene decken Hexfelder auf. Welche Token zählen, legt „Aufdeckende Token“ fest: standardmäßig Spieler-Token, sodass der GM Monster bewegen kann, ohne die Karte aufzudecken.', 'Ein Token deckt jedes Hexfeld auf, das er bedeckt (große Token bedecken mehrere), und bei aktiviertem „Entlang des Wegs aufdecken“ jedes Hexfeld auf der Route, entlang der er gezogen wurde, einschließlich Wegpunkten.', @@ -4919,7 +4923,7 @@ const HexplorationMod = (() => { heading: 'Upgrade von Version 1', points: [ 'Version 2 benötigt PathMath, MatrixMath, Vector Math oder HTML Builder nicht mehr. Sie können sie entfernen, es sei denn, ein anderer Mod verwendet sie.', - 'Vorhandene Hex-Karten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', + 'Vorhandene Hexkarten, Namen, Standort-Tokens und Einstellungen werden beim ersten Start automatisch aktualisiert.', 'Die Befehle der Version 1, einschließlich des Hexploration_menu-Makros, funktionieren weiterhin.', 'In Version 1 konnte jeder Token, der einen Charakter darstellt, Hexfelder aufdecken. Setzen Sie „Aufdeckende Token“ auf „Charaktertoken“, um dieses Verhalten beizubehalten.', ], @@ -5047,11 +5051,11 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Χρώμα πλήρωσης', - desc: 'Χρώμα νέων εξάγωνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', + desc: 'Χρώμα νέων εξαγώνων. Χρησιμοποιήστε rgba() για διαφανή εξάγωνα, για παράδειγμα rgba(0,0,0,0.8).', }, strokeColor: { label: 'Χρώμα περιγράμματος', - desc: 'Χρώμα του περιγράμματος των νέων εξάγωνων.', + desc: 'Χρώμα του περιγράμματος των νέων εξαγώνων.', }, labelColor: { label: 'Χρώμα ετικετών', @@ -5063,7 +5067,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Πλάτος περιγράμματος', - desc: 'Πλάτος του περιγράμματος των νέων εξάγωνων, σε pixel (0 έως 20).', + desc: 'Πλάτος του περιγράμματος των νέων εξαγώνων, σε pixel (0 έως 20).', }, maxDistance: { label: 'Απόσταση αποκάλυψης εξαγώνων', @@ -5083,7 +5087,7 @@ const HexplorationMod = (() => { }, revealBy: { label: 'Διακριτικά που αποκαλύπτουν', - desc: 'Ποια κουπόνια στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: μάρκες που ελέγχονται από έναν παίκτη, μάρκες που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', + desc: 'Ποια διακριτικά στο επίπεδο διακριτικών αποκαλύπτουν εξάγωνα: διακριτικά που ελέγχει ένας παίκτης, διακριτικά που αντιπροσωπεύουν οποιονδήποτε χαρακτήρα ή κάθε διακριτικό.', }, revealMode: { label: 'Λειτουργία αποκάλυψης', @@ -5095,11 +5099,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Ping στις ανακαλύψεις', - desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες αποστέλλονται ping σε μια συγκεκριμένη τοποθεσία όταν ανακαλυφθεί.', + desc: 'Όταν είναι ενεργοποιημένο, οι παίκτες λαμβάνουν ping σε μια τοποθεσία με όνομα όταν αυτή ανακαλυφθεί.', }, hideCoveredTokens: { label: 'Απόκρυψη καλυμμένων διακριτικών', - desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από εξάγωνα. Όταν είναι ενεργοποιημένα, τα κουπόνια κάτω από ένα καλυμμένο εξάγωνο έχουν το όνομα που είναι ορατό από τον παίκτη, τις μπάρες και τις αύρες απενεργοποιημένες και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', + desc: 'Το Roll20 σχεδιάζει ονόματα, μπάρες και αύρες πάνω από τα εξάγωνα. Όταν είναι ενεργοποιημένο, στα διακριτικά κάτω από καλυμμένο εξάγωνο απενεργοποιούνται το ορατό στους παίκτες όνομα, οι μπάρες και οι αύρες, και ενεργοποιούνται ξανά όταν αποκαλυφθούν.', }, }, status: { @@ -5117,26 +5121,26 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Η συμπλήρωση ολοκληρώθηκε. Σχεδιασμένα εξάγωνα: {created}. Επανασχεδιασμένο: {restyled}. Κρυφές τοποθεσίες: {icons}.', + 'Το γέμισμα ολοκληρώθηκε. Εξάγωνα που σχεδιάστηκαν: {created}. Με νέα μορφοποίηση: {restyled}. Κρυμμένες τοποθεσίες: {icons}.', revealed: 'Αποκαλύφθηκαν εξάγωνα: {count}.', - revealedPage: 'Κάθε εξάγωνο στη σελίδα που αποκαλύπτεται ({count}).', + revealedPage: 'Αποκαλύφθηκαν όλα τα εξάγωνα της σελίδας ({count}).', confirmReset: 'Να καταργηθεί κάθε εξάγωνο από το "{page}" ({count}); Τα διακριτικά τοποθεσίας επιστρέφουν στο επίπεδο διακριτικών. Η αναίρεση δεν μπορεί να το αντιστρέψει.', resetPage: 'Τα εξάγωνα καταργήθηκαν από τη σελίδα: {count}.', undone: - 'Η τελευταία πλήρωση αναιρέθηκε. Τα εξάγωνα καταργήθηκαν: {removed}. Αποκαταστάθηκαν τα ανανεωμένα εξάγωνα: {restored}.', - named: 'Hexes με όνομα "{name}": {count}.', + 'Το τελευταίο γέμισμα αναιρέθηκε. Εξάγωνα που αφαιρέθηκαν: {removed}. Εξάγωνα που επανήλθαν στην αρχική μορφή: {restored}.', + named: 'Εξάγωνα με όνομα "{name}": {count}.', unnamed: 'Τα ονόματα διαγράφηκαν: {count}.', marked: - 'Τοποθεσίες που είναι κρυμμένες σε υπάρχοντα hexes: {attached}. Αναμονή για το επόμενο γέμισμα που τα καλύπτει: {pending}.', + 'Τοποθεσίες κρυμμένες σε υπάρχοντα εξάγωνα: {attached}. Σε αναμονή για το επόμενο γέμισμα που θα τις καλύψει: {pending}.', unmarked: 'Διακριτικά που δεν είναι πλέον τοποθεσίες: {count}.', settingChanged: 'Το {setting} ορίστηκε σε {value}.', rescanned: - 'Ολοκληρώθηκε η εκ νέου σάρωση. Διατήρηση: {kept}. Εγκρίθηκε: {adopted}. Κατατέθηκε εκ νέου: {moved}. Λείπει και έχει ξεχαστεί: {dropped}. Οι ετικέτες επανασυνδέθηκαν: {labels}. Τα διακριτικά τοποθεσίας επανασυνδέθηκαν: {icons}.', + 'Η επανασάρωση ολοκληρώθηκε. Διατηρήθηκαν: {kept}. Υιοθετήθηκαν: {adopted}. Μετακινήθηκαν: {moved}. Λείπουν και ξεχάστηκαν: {dropped}. Επανασυνδεδεμένες ετικέτες: {labels}. Επανασυνδεδεμένα διακριτικά τοποθεσίας: {icons}.', calibrated: - 'Βαθμονόμηση πλέγματος (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Το πλέγμα βαθμονομήθηκε (βήμα στήλης {colStep}px, βήμα γραμμής {rowStep}px). Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', calibrationReset: - 'Η βαθμονόμηση καταργήθηκε. Εκ νέου σάρωση: διατηρήθηκε {kept}, κατατέθηκε εκ νέου {moved}, υιοθετήθηκε {adopted}.', + 'Η βαθμονόμηση καταργήθηκε. Επανασάρωση: διατηρήθηκαν {kept}, μετακινήθηκαν {moved}, υιοθετήθηκαν {adopted}.', journalRebuilt: 'Τα φυλλάδια "{help}" και "{deck}" έχουν ανακατασκευαστεί.', migrated: 'Οι εξαγωνικοί χάρτες σας του Hexploration 1.x αναβαθμίστηκαν. Αν αυτό το παιχνίδι αντιγράφηκε από παιχνίδι Legacy, εκτελέστε «Επανασάρωση» σε κάθε σελίδα με εξαγωνικό χάρτη.', @@ -5147,44 +5151,44 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο πρώτο επίπεδο, επομένως σχεδιάστηκαν εξάγωνα στο επίπεδο διακριτικών.', + 'Αυτό το παιχνίδι δεν υποστηρίζει τη σχεδίαση στο επίπεδο πρώτου πλάνου, οπότε τα εξάγωνα σχεδιάστηκαν στο επίπεδο διακριτικών.', someFailed: - 'Δεκαεξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', + 'Εξάγωνα που δεν ήταν δυνατό να σχεδιαστούν: {count}. Ελέγξτε την κονσόλα API για λεπτομέρειες.', }, errors: { noPage: 'Δεν ήταν δυνατή η εύρεση της σελίδας για εργασία.', notHex: 'Αυτή η σελίδα δεν χρησιμοποιεί εξαγωνικό πλέγμα.', - noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για συμπλήρωση.', + noPolygons: 'Επιλέξτε ένα ή περισσότερα σχεδιασμένα σχήματα για γέμισμα.', emptyArea: 'Η επιλεγμένη περιοχή δεν περιέχει κέντρα εξαγώνων.', tooMany: 'Αυτό θα δημιουργούσε πάρα πολλά εξάγωνα με μία κίνηση ({count}).', - nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή μάρκες για απόκρυψη.', - nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή μάρκες για αποκάλυψη.', + nothingToConceal: 'Επιλέξτε σχεδιασμένα σχήματα ή διακριτικά για απόκρυψη.', + nothingToReveal: 'Επιλέξτε εξάγωνα, σχεδιασμένα σχήματα ή διακριτικά για αποκάλυψη.', noTokens: 'Επιλέξτε πρώτα ένα ή περισσότερα διακριτικά.', - noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή μάρκες που στέκονται σε εξάγωνα).', + noHexes: 'Επιλέξτε πρώτα ένα ή περισσότερα εξάγωνα (ή διακριτικά που στέκονται σε εξάγωνα).', nothingToUndo: 'Δεν υπάρχει γέμισμα για αναίρεση.', unknownCommand: 'Άγνωστη εντολή: {command}', unknownSetting: 'Άγνωστη ρύθμιση: {key}', unknownPageSetting: 'Ρυθμίσεις που μπορούν να οριστούν ανά σελίδα: {keys}', invalidValue: 'Το "{value}" δεν είναι έγκυρη τιμή για {key}.', - calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά που έχουν κουμπώσει σε εξάγωνα κέντρα.', + calibrateNeedsTokens: 'Επιλέξτε ένα ή δύο διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateFailed: 'Αυτά τα διακριτικά δεν μπορούν να χρησιμοποιηθούν για βαθμονόμηση.', unexpected: 'Κάτι πήγε στραβά: {message}', }, hints: { noPage: 'Ανοίξτε τη σελίδα στην οποία θέλετε να εργαστείτε ή επιλέξτε κάτι σε αυτήν.', - notHex: 'Ορίστε το πλέγμα σελίδων σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', + notHex: 'Ορίστε το πλέγμα της σελίδας σε Hex (V) ή Hex (H) στις Ρυθμίσεις σελίδας.', noPolygons: - 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα ελεύθερου γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', - emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος σελίδων.', + 'Σχεδιάστε ένα πολύγωνο, ορθογώνιο, έλλειψη ή σχήμα με ελεύθερο χέρι γύρω από την περιοχή, επιλέξτε το και δοκιμάστε ξανά.', + emptyArea: 'Σχεδιάστε ένα μεγαλύτερο σχήμα ή ελέγξτε τις ρυθμίσεις πλέγματος της σελίδας.', tooMany: 'Γεμίστε μια μικρότερη περιοχή ή χωρίστε την περιοχή σε διάφορα σχήματα.', noHexes: - 'Τα εξάγωνα βρίσκονται στο προσκήνιο ή στο στρώμα συμβολικής. μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', + 'Τα εξάγωνα βρίσκονται στο επίπεδο πρώτου πλάνου ή στο επίπεδο διακριτικών· μεταβείτε σε αυτό το επίπεδο για να τα επιλέξετε.', unknownCommand: 'Πληκτρολογήστε !hexploration help για να παραθέσετε τις εντολές.', unknownSetting: 'Πληκτρολογήστε !hexploration set για να δείτε κάθε ρύθμιση.', calibrateNeedsTokens: - 'Τοποθετήστε ένα διακριτικό στο κέντρο ενός εξάγωνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό που έχει κολλήσει σε ένα γειτονικό εξάγωνο στην ίδια σειρά (Hex V) ή στήλη (Hex H) για να διορθώσετε επίσης το μέγεθος του hex.', + 'Κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου και επιλέξτε το. Επιλέξτε ένα δεύτερο διακριτικό κουμπωμένο σε γειτονικό εξάγωνο της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', calibrateFailed: - 'Δύο κουπόνια πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), τουλάχιστον ένα εξάγωνο μεταξύ τους.', + 'Τα δύο διακριτικά πρέπει να βρίσκονται στην ίδια σειρά (Hex V) ή στην ίδια στήλη (Hex H), σε απόσταση τουλάχιστον ενός εξαγώνου μεταξύ τους.', unexpected: 'Οι λεπτομέρειες βρίσκονται στο αρχείο καταγραφής της κονσόλας API.', }, help: { @@ -5193,21 +5197,21 @@ const HexplorationMod = (() => { fillInverse: 'Καλύψτε ολόκληρη τη σελίδα εκτός από το εσωτερικό των επιλεγμένων σχημάτων.', undo: 'Αναιρέστε το τελευταίο γέμισμα, αντίστροφο γέμισμα ή απόκρυψη και επαναφέρετε τα σχήματα που χρησιμοποίησε.', reveal: - 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και μάρκες.', + 'Αποκαλύψτε τα επιλεγμένα εξάγωνα και τα εξάγωνα κάτω από τα επιλεγμένα σχήματα και διακριτικά.', revealPage: 'Αποκαλύψτε κάθε εξάγωνο στη σελίδα χωρίς ανακοινώσεις.', - conceal: 'Καλύψτε ξανά την περιοχή κάτω από τα επιλεγμένα σχήματα και μάρκες με εξάγωνα.', - explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακομίσει εκεί.', + conceal: 'Καλύψτε ξανά με εξάγωνα την περιοχή κάτω από τα επιλεγμένα σχήματα και διακριτικά.', + explore: 'Αποκαλύψτε γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', resetPage: 'Αφαιρέστε κάθε εξάγωνο στη σελίδα (ρωτά πρώτα).', name: 'Ονομάστε τα επιλεγμένα εξάγωνα ή τα εξάγωνα κάτω από τα επιλεγμένα διακριτικά. Αφήστε το όνομα κενό για να το διαγράψετε.', mark: 'Μετατρέψτε τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες.', - unmark: 'Σταματήστε τα επιλεγμένα διακριτικά να είναι κρυφές τοποθεσίες.', + unmark: 'Τα επιλεγμένα διακριτικά παύουν να είναι κρυφές τοποθεσίες.', set: 'Αλλάξτε μια ρύθμιση ή εμφανίστε όλες τις ρυθμίσεις.', pageSet: 'Παράκαμψη μιας ρύθμισης αποκάλυψης μόνο στην τρέχουσα σελίδα.', pageClear: 'Καταργήστε τις παρακάμψεις της τρέχουσας σελίδας.', rescan: 'Δημιουργήστε ξανά τη λίστα εξαγώνων της σελίδας, για παράδειγμα μετά την αντιγραφή μιας σελίδας ή ενός παιχνιδιού.', calibrate: - 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα κουπόνια που έχουν κουμπώσει σε εξάγωνα κέντρα.', + 'Ευθυγραμμίστε το εξαγωνικό πλέγμα με ένα ή δύο επιλεγμένα διακριτικά κουμπωμένα σε κέντρα εξαγώνων.', calibrateReset: 'Καταργήστε τη βαθμονόμηση της τρέχουσας σελίδας.', status: 'Δείξτε τι γνωρίζει η Hexploration για την τρέχουσα σελίδα.', journal: 'Αναδημιουργήστε τα φυλλάδια Βοήθειας και Command Deck.', @@ -5220,18 +5224,18 @@ const HexplorationMod = (() => { revealDesc: 'Επιλέξτε εξάγωνα, σχήματα ή διακριτικά για να τα αποκαλύψετε ή να τα καλύψετε ξανά. Η «Εξερεύνηση» αποκαλύπτει γύρω από τα επιλεγμένα διακριτικά σαν να είχαν μόλις μετακινηθεί εκεί.', locationsDesc: - 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα hexes. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', + 'Επιλέξτε διακριτικά για να τα αποκρύψετε ως τοποθεσίες κάτω από τα εξάγωνα. Επιλέξτε εξάγωνα ή διακριτικά για να ονομάσετε ένα εξάγωνο.', toolsDesc: 'Ρυθμίσεις, παρακάμψεις σελίδων, κατάσταση, εκ νέου σάρωση αντιγραμμένων σελίδων και βαθμονόμηση του πλέγματος.', footer: 'Δείτε το φυλλάδιο "{help}" για πλήρεις οδηγίες.', }, handout: { - versionLabel: 'Εκδοχή', - subtitle: 'Εξερεύνηση Hex-by-hex για το Roll20', + versionLabel: 'Έκδοση', + subtitle: 'Εξερεύνηση εξάγωνο προς εξάγωνο για το Roll20', footer: 'Χρησιμοποιήστε το φυλλάδιο "{deck}" για στοιχεία ελέγχου με ένα κλικ.', overview: { heading: 'Επισκόπηση', - body: 'Το Hexploration καλύπτει έναν εξάγωνο χάρτη με αδιαφανή εξάγωνα. Καθώς το πάρτι κινείται, τα εξάγωνα από τα οποία περνούν (και, αν θέλετε, τα εξάγωνα γύρω τους) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', + body: 'Το Hexploration καλύπτει έναν εξαγωνικό χάρτη με αδιαφανή εξάγωνα. Καθώς η ομάδα κινείται, τα εξάγωνα από τα οποία περνά (και, αν θέλετε, τα εξάγωνα γύρω της) αφαιρούνται, οπότε ο χάρτης αποκαλύπτεται ένα εξάγωνο τη φορά. Οι κρυφές τοποθεσίες μπορούν να τοποθετηθούν κάτω από εξάγωνα και ανακοινώνονται όταν βρεθούν. Λειτουργεί σε παιχνίδια Jumpgate και Legacy, σε πλέγματα Hex (V) και Hex (H) οποιουδήποτε μεγέθους.', demo: 'Παρακολουθήστε ένα σύντομο demo (από την έκδοση 1)', }, quickStart: { @@ -5247,7 +5251,7 @@ const HexplorationMod = (() => { commands: { heading: 'Εντολές', intro: - 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότεροι ενεργούν στα επιλεγμένα αντικείμενα. τα υπόλοιπα ενεργούν στη σελίδα που βλέπετε.', + 'Μόνο οι GM μπορούν να χρησιμοποιήσουν αυτές τις εντολές. Οι περισσότερες ενεργούν στα επιλεγμένα αντικείμενα· οι υπόλοιπες ενεργούν στη σελίδα που βλέπετε.', colCommand: 'Εντολή', colDesc: 'Τι κάνει', }, @@ -5264,11 +5268,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Με όνομα Hexes and Locations', + heading: 'Εξάγωνα με όνομα και τοποθεσίες', points: [ 'Η «Επισήμανση τοποθεσίας» μετατρέπει τα επιλεγμένα διακριτικά σε κρυφές τοποθεσίες. Ένα διακριτικό που βρίσκεται ήδη κάτω από εξάγωνο κρύβεται αμέσως· αλλιώς κρύβεται από το επόμενο γέμισμα που το καλύπτει.', - 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν συμπληρώνετε, όπως στην έκδοση 1.', - 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλύπτεται, επιστρέφουν στο στρώμα συμβολικών με το όνομά τους που φαίνεται και η ανακάλυψή τους ανακοινώνεται.', + 'Τα διακριτικά με τον δείκτη κατάστασης του λευκού πύργου αντιμετωπίζονται επίσης ως τοποθεσίες όταν κάνετε γέμισμα, όπως στην έκδοση 1.', + 'Τα κρυφά διακριτικά τοποθεσίας μετακινούνται στο επίπεδο GM. Όταν το εξάγωνό τους αποκαλυφθεί, επιστρέφουν στο επίπεδο διακριτικών με ορατό το όνομά τους και η ανακάλυψή τους ανακοινώνεται.', 'Η «Ονομασία εξαγώνου» δίνει όνομα σε ένα εξάγωνο χωρίς διακριτικό. Το όνομα εμφανίζεται στον GM ως ετικέτα στο επίπεδο GM και ανακοινώνεται όταν αποκαλυφθεί το εξάγωνο. Το Jumpgate σχεδιάζει το επίπεδο GM κάτω από το επίπεδο πρώτου πλάνου, οπότε στο Jumpgate οι ετικέτες εμφανίζονται μόνο όταν το «Επίπεδο εξαγώνων» έχει οριστεί στο επίπεδο διακριτικών.', 'Η «Ανακοίνωση ανακαλύψεων» ορίζει αν θα βλέπουν την ανακοίνωση όλοι, μόνο ο GM ή κανείς. Το «Ping στις ανακαλύψεις» μετακινεί επίσης την προβολή των παικτών στην τοποθεσία.', ], @@ -5278,14 +5282,14 @@ const HexplorationMod = (() => { intro: 'Αλλάξτε τις ρυθμίσεις με το !hexploration set (ή το κουμπί «Ρυθμίσεις»). Το «Επίπεδο εξαγώνων», τα «Διακριτικά που αποκαλύπτουν» και η «Γλώσσα» ορίζονται επίσης στη σελίδα ρυθμίσεων του Mod.', colKey: 'Κλειδί', - colName: 'Σύνθεση', + colName: 'Ρύθμιση', colDesc: 'Περιγραφή', perPage: '(Μπορεί να οριστεί ανά σελίδα.)', }, jumpgate: { heading: 'Jumpgate και Legacy', points: [ - 'Το Hexploration προσδιορίζει τον κινητήρα που χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που σχεδιάζονται σε οποιοδήποτε πρόγραμμα επεξεργασίας μπορούν να συμπληρωθούν.', + 'Το Hexploration εντοπίζει ποια μηχανή χρησιμοποιεί το παιχνίδι και σχεδιάζει το αντίστοιχο είδος σχήματος. Τα σχήματα που έχουν σχεδιαστεί σε οποιονδήποτε από τους δύο επεξεργαστές μπορούν να γεμιστούν.', 'Με το «Επίπεδο εξαγώνων» σε «Αυτόματο», τα εξάγωνα σχεδιάζονται στο επίπεδο πρώτου πλάνου, πάνω από τα διακριτικά, ώστε οι παίκτες να μη βλέπουν τι υπάρχει από κάτω. Αν το επίπεδο πρώτου πλάνου δεν είναι διαθέσιμο, χρησιμοποιείται το επίπεδο διακριτικών.', 'Το Jumpgate σχεδιάζει μαθηματικά κανονικά εξάγωνα, με ελαφρώς διαφορετικό σχήμα από τα εξάγωνα του Legacy. Αν τα εξάγωνα δεν ευθυγραμμίζονται με το πλέγμα μιας σελίδας, κουμπώστε ένα διακριτικό στο κέντρο ενός εξαγώνου, επιλέξτε το και κάντε κλικ στη «Βαθμονόμηση». Επιλέξτε δύο διακριτικά σε γειτονικά εξάγωνα της ίδιας σειράς (Hex V) ή στήλης (Hex H) για να διορθώσετε και το μέγεθος του εξαγώνου.', 'Όταν αντιγράφεται μια σελίδα ή ένα παιχνίδι, τα εξάγωνά του παίρνουν νέα αναγνωριστικά. Εκτελέστε «Επανασάρωση» στη σελίδα για να εντοπιστούν ξανά, μαζί με τις ετικέτες ονομάτων και τα διακριτικά τοποθεσιών τους.', @@ -5317,12 +5321,12 @@ const HexplorationMod = (() => { body: 'Επιλέξτε μια γλώσσα με !hexploration set language. Διαθέσιμες γλώσσες:', colLanguage: 'Γλώσσα', colNative: 'Όνομα στη γλώσσα της', - colCode: 'Κώδικας', + colCode: 'Κωδικός', }, credits: { - heading: 'Πιστώσεις', + heading: 'Συντελεστές', original: 'Πρωτότυπο mod από', - maintainer: 'Έκδοση 2 που διατηρείται από', + maintainer: 'Η έκδοση 2 συντηρείται από', marketplace: 'Τα πακέτα τέχνης της Ada στο Roll20 Marketplace', support: 'Εάν βρείτε ένα σφάλμα ή έχετε μια ιδέα, δημοσιεύστε στο φόρουμ Roll20 Mod ή ανοίξτε ένα ζήτημα στο GitHub και συμπεριλάβετε τυχόν μηνύματα από το αρχείο καταγραφής της κονσόλας API.', @@ -5419,19 +5423,19 @@ const HexplorationMod = (() => { }, hexLayer: { label: 'שכבת המשושים', - desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים) ונופל בחזרה לשכבת האסימון אם המשחק אינו תומך בה.', + desc: 'היכן מציירים משושים חדשים. אוטומטי מנסה את שכבת החזית (מעל האסימונים), ואם המשחק אינו תומך בה, משתמש בשכבת האסימונים.', }, fillColor: { label: 'צבע מילוי', - desc: 'צבע של משושים חדשים. השתמש ב-rgba() עבור hexes שקופים, למשל rgba(0,0,0,0.8).', + desc: 'צבע המשושים החדשים. השתמש ב-rgba() למשושים שקופים, למשל rgba(0,0,0,0.8).', }, strokeColor: { label: 'צבע מסגרת', - desc: 'צבע קווי המתאר של משושות חדשות.', + desc: 'צבע קווי המתאר של משושים חדשים.', }, labelColor: { label: 'צבע תווית', - desc: 'צבע של תוויות השם GM בלבד על hexes עם שם.', + desc: 'צבע תוויות השם, הגלויות ל-GM בלבד, על משושים בעלי שם.', }, glimpseColor: { label: 'צבע הצצה', @@ -5495,45 +5499,47 @@ const HexplorationMod = (() => { filled: 'מילוי הושלם. משושים מצוירים: {created}. עיצוב מחדש: {restyled}. מיקומים מוסתרים: {icons}.', revealed: 'נחשפו משושים: {count}.', - revealedPage: 'כל hex בדף נחשף ({count}).', + revealedPage: 'כל המשושים בדף נחשפו ({count}).', confirmReset: - 'להסיר כל hex מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימון. לא ניתן לבטל את זה.', - resetPage: 'הקסים הוסרו מהדף: {count}.', - undone: 'המילוי האחרון בוטל. הקסים הוסרו: {removed}. שוחזרו משושי סגנון מחדש: {restored}.', - named: 'hexes בשם "{name}": {count}.', + 'להסיר את כל המשושים מ-"{page}" ({count})? אסימוני מיקום חוזרים לשכבת האסימונים. לא ניתן לבטל את זה.', + resetPage: 'משושים שהוסרו מהדף: {count}.', + undone: + 'המילוי האחרון בוטל. משושים שהוסרו: {removed}. משושים ששוחזר עיצובם המקורי: {restored}.', + named: 'משושים בשם "{name}": {count}.', unnamed: 'שמות נוקו: {count}.', - marked: 'מיקומים מוסתרים בשושים קיימים: {attached}. ממתין למילוי הבא שיכסה אותם: {pending}.', + marked: + 'מיקומים שהוסתרו במשושים קיימים: {attached}. ממתינים למילוי הבא שיכסה אותם: {pending}.', unmarked: 'אסימונים שאינם עוד מיקומים: {count}.', settingChanged: '{setting} מוגדר ל-{value}.', rescanned: - 'הסריקה מחדש הושלמה. נשמר: {kept}. אומץ: {adopted}. הוגש מחדש: {moved}. חסר ונשכח: {dropped}. תוויות מקושרות מחדש: {labels}. אסימוני מיקום מקושרים מחדש: {icons}.', + 'הסריקה מחדש הושלמה. נשמרו: {kept}. אומצו: {adopted}. שויכו מחדש: {moved}. חסרים ונשכחו: {dropped}. תוויות שקושרו מחדש: {labels}. אסימוני מיקום שקושרו מחדש: {icons}.', calibrated: - 'רשת מכוילת (שלב עמודה {colStep}px, שלב שורה {rowStep}px). סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אומץ {adopted}.', + 'הרשת כוילה (מרווח עמודות {colStep}px, מרווח שורות {rowStep}px). סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', calibrationReset: - 'הכיול הוסר. סריקה מחדש: שמר על {kept}, הוגש מחדש {moved}, אימץ את {adopted}.', + 'הכיול הוסר. סריקה מחדש: נשמרו {kept}, שויכו מחדש {moved}, אומצו {adopted}.', journalRebuilt: 'הדפים "{help}" ו-"{deck}" נבנו מחדש.', migrated: 'מפות המשושים שלך מ-Hexploration 1.x שודרגו. אם המשחק הזה הועתק ממשחק Legacy, הפעל סריקה מחדש בכל דף של מפת משושים.', pruned: - 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי להרים שוב את המשושים שלו.', + 'משושים שמורים שכבר לא קיימים ונשכחו: {dropped}. אם המשחק או הדף הזה הועתקו, הפעל סריקה מחדש בדף כדי לאתר שוב את המשושים שלו.', readyHint: 'הקלד !hexploration כדי לפתוח את התפריט, או פתח את דף המידע "Hexploration - Command Deck".', }, warnings: { foregroundUnavailable: - 'משחק זה אינו תומך בציור על שכבת החזית, כך ששושים צוירו על שכבת האסימון.', - someFailed: 'הקסים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', + 'משחק זה אינו תומך בציור על שכבת החזית, ולכן המשושים צוירו על שכבת האסימונים.', + someFailed: 'משושים שלא ניתן היה לצייר: {count}. בדוק את מסוף ה-API לפרטים.', }, errors: { noPage: 'לא הצלחתי למצוא את הדף לעבוד עליו.', - notHex: 'דף זה אינו משתמש ברשת משושה.', + notHex: 'דף זה אינו משתמש ברשת משושים.', noPolygons: 'בחר צורה מצוירת אחת או יותר למילוי.', - emptyArea: 'האזור שנבחר אינו מכיל מרכזי hex.', - tooMany: 'זה ייצור יותר מדי hexes במכה אחת ({count}).', + emptyArea: 'האזור שנבחר אינו מכיל מרכזי משושים.', + tooMany: 'זה ייצור יותר מדי משושים בבת אחת ({count}).', nothingToConceal: 'בחר צורות מצוירות או אסימונים כדי להסתיר.', nothingToReveal: 'בחר משושים, צורות מצוירות או אסימונים לחשיפה.', noTokens: 'תחילה בחר אסימון אחד או יותר.', - noHexes: 'בחר תחילה משושה אחת או יותר (או אסימונים העומדים על משושים).', + noHexes: 'בחר תחילה משושה אחד או יותר (או אסימונים העומדים על משושים).', nothingToUndo: 'אין מילוי לבטל.', unknownCommand: 'פקודה לא ידועה: {command}', unknownSetting: 'הגדרה לא ידועה: {key}', @@ -5545,38 +5551,38 @@ const HexplorationMod = (() => { }, hints: { noPage: 'פתח את הדף שאתה רוצה לעבוד עליו, או בחר משהו בו.', - notHex: 'הגדר את רשת העמודים ל-Hex (V) או Hex (H) בהגדרות עמוד.', + notHex: 'הגדר את רשת הדף ל-Hex (V) או Hex (H) בהגדרות הדף.', noPolygons: 'צייר מצולע, מלבן, אליפסה או צורה ביד חופשית סביב האזור, בחר אותו ולאחר מכן נסה שוב.', - emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות רשת העמודים.', + emptyArea: 'צייר צורה גדולה יותר, או בדוק את הגדרות הרשת של הדף.', tooMany: 'ממלאים שטח קטן יותר, או חלקו את השטח למספר צורות.', noHexes: 'המשושים נמצאים בחזית או בשכבת האסימון; עבור לשכבה זו כדי לבחור אותם.', unknownCommand: 'הקלד !hexploration help כדי לרשום את הפקודות.', unknownSetting: 'הקלד !hexploration set כדי לראות כל הגדרה.', calibrateNeedsTokens: - 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שנצמד ל-hex סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל הhex.', + 'הצמד אסימון למרכז משושה ובחר בו. בחר אסימון שני שהוצמד למשושה סמוך באותה שורה (Hex V) או עמודה (Hex H) כדי לתקן גם את גודל המשושה.', calibrateFailed: - 'שני אסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), לפחות hex אחד בנפרד.', + 'שני האסימונים חייבים להיות באותה שורה (Hex V) או באותה עמודה (Hex H), במרחק של משושה אחד לפחות זה מזה.', unexpected: 'הפרטים נמצאים ביומן מסוף ה-API.', }, help: { menu: 'הצג את התפריט.', - fill: 'כסה את הצורות המצוירות שנבחרו בשושים.', + fill: 'כסה את הצורות המצוירות שנבחרו במשושים.', fillInverse: 'כסה את כל העמוד למעט בתוך הצורות שנבחרו.', - undo: 'בטל את המילוי האחרון, מילוי הפוך או הסתר, ושחזר את הצורות בהן השתמש.', + undo: 'בטל את המילוי, המילוי ההפוך או ההסתרה האחרונים, ושחזר את הצורות שבהן נעשה שימוש.', reveal: 'חשוף את המשושים שנבחרו, ואת המשושים תחת הצורות והאסימונים שנבחרו.', - revealPage: 'חשוף כל קסם בדף ללא הודעות.', - conceal: 'כסה שוב את השטח מתחת לצורות והאסימונים שנבחרו בשושים.', + revealPage: 'חשוף את כל המשושים בדף ללא הכרזות.', + conceal: 'כסה שוב במשושים את השטח שמתחת לצורות ולאסימונים שנבחרו.', explore: 'חשפו סביב האסימונים שנבחרו כאילו הם זה עתה עברו לשם.', - resetPage: 'הסר כל hex בדף (שואל תחילה).', - name: 'תן שם למשושים שנבחרו, או לשושים מתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', + resetPage: 'הסר את כל המשושים בדף (מבקש אישור תחילה).', + name: 'תן שם למשושים שנבחרו, או למשושים שמתחת לאסימונים שנבחרו. השאר את השם ריק כדי לנקות אותו.', mark: 'הפוך את האסימונים שנבחרו למיקומים נסתרים.', - unmark: 'עצור את האסימונים שנבחרו להיות מיקומים מוסתרים.', + unmark: 'הפסק להתייחס לאסימונים שנבחרו כמיקומים מוסתרים.', set: 'שנה הגדרה או הצג את כל ההגדרות.', pageSet: 'עוקף הגדרת חשיפה בדף הנוכחי בלבד.', pageClear: 'הסר את העקיפות של הדף הנוכחי.', - rescan: 'בנה מחדש את רשימת ה-hex של העמוד, למשל לאחר העתקת עמוד או משחק.', - calibrate: 'שורה את הרשת המשושה עם אסימון אחד או שניים נבחרים המוצמדים למרכזי משושה.', + rescan: 'בנה מחדש את רשימת המשושים של הדף, למשל לאחר העתקת דף או משחק.', + calibrate: 'יישר את רשת המשושים לפי אסימון אחד או שניים שנבחרו ומוצמדים למרכזי משושים.', calibrateReset: 'הסר את הכיול של הדף הנוכחי.', status: 'הצג מה Hexploration יודע על הדף הנוכחי.', journal: 'בנה מחדש את דפי המידע של העזרה ושל Command Deck.', @@ -5594,7 +5600,7 @@ const HexplorationMod = (() => { }, handout: { versionLabel: 'גִרְסָה', - subtitle: 'חקירה משושה אחר קסם עבור Roll20', + subtitle: 'חקירה משושה אחר משושה עבור Roll20', footer: 'השתמש בדף "{deck}" עבור פקדים בלחיצה אחת.', overview: { heading: 'סקירה כללית', @@ -5619,7 +5625,7 @@ const HexplorationMod = (() => { colDesc: 'מה זה עושה', }, revealing: { - heading: 'איך עובד גילוי', + heading: 'איך החשיפה עובדת', points: [ 'רק אסימונים בשכבת האסימונים חושפים משושים. אילו אסימונים נחשבים נקבע בהגדרה אסימונים חושפים: כברירת מחדל אסימוני שחקנים, כך שה-GM יכול להזיז מפלצות בלי לחשוף את המפה.', 'אסימון חושף כל משושה שהוא מכסה (אסימונים גדולים מכסים כמה), וכשחשיפה לאורך המסלול מופעלת, גם כל משושה במסלול שלאורכו נגרר, כולל נקודות ציון.', @@ -5631,11 +5637,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'בשם משושים ומיקומים', + heading: 'משושים בעלי שם ומיקומים', points: [ 'סימון מיקום הופך את האסימונים שנבחרו למיקומים מוסתרים. אסימון שכבר נמצא מתחת למשושה מוסתר מיד; אחרת הוא מוסתר במילוי הבא שמכסה אותו.', 'אסימונים עם סמן המצב של המגדל הלבן מטופלים גם כמיקומים בעת מילוי, כמו בגרסה 1.', - 'אסימוני מיקום מוסתרים מועברים לשכבת GM. כאשר הקסם שלהם מתגלה הם חוזרים לשכבת האסימון עם שמם מוצג, והגילוי שלהם מוכרז.', + 'אסימוני מיקום מוסתרים מועברים לשכבת ה-GM. כאשר המשושה שלהם נחשף הם חוזרים לשכבת האסימונים כששמם מוצג, והגילוי שלהם מוכרז.', 'מתן שם למשושה נותן למשושה שם ללא אסימון. השם מוצג ל-GM כתווית בשכבת ה-GM ומוכרז כשהמשושה נחשף. Jumpgate מצייר את שכבת ה-GM מתחת לשכבת החזית, ולכן ב-Jumpgate התוויות מוצגות רק כאשר "שכבת המשושים" מוגדרת לשכבת האסימונים.', 'הכרזה על תגליות קובעת אם כולם, רק ה-GM או אף אחד לא יראו את ההכרזה. פינג לתגליות גם מעביר את תצוגת השחקנים למיקום.', ], @@ -5645,7 +5651,7 @@ const HexplorationMod = (() => { intro: 'שנה הגדרות באמצעות !hexploration set (או כפתור ההגדרות). את שכבת המשושים, אסימונים חושפים ושפה אפשר להגדיר גם בדף ההגדרות של המוד.', colKey: 'מַפְתֵחַ', - colName: 'סְבִיבָה', + colName: 'הגדרה', colDesc: 'תֵאוּר', perPage: '(ניתן להגדיר לכל עמוד.)', }, @@ -5659,15 +5665,15 @@ const HexplorationMod = (() => { ], }, upgrading: { - heading: 'משדרג מגרסה 1', + heading: 'שדרוג מגרסה 1', points: [ 'גרסה 2 כבר לא צריכה PathMath, MatrixMath, Vector Math או HTML Builder. אתה יכול להסיר אותם אלא אם מוד אחר משתמש בהם.', - 'מפות hex קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהתחלה הראשונה.', + 'מפות משושים קיימות, שמות, אסימוני מיקום והגדרות משודרגים אוטומטית בהפעלה הראשונה.', 'הפקודות של גרסה 1, כולל המאקרו Hexploration_menu, עדיין עובדות.', 'בגרסה 1 כל אסימון שייצג דמות יכול היה לחשוף משושים. הגדר את אסימונים חושפים לאסימוני דמויות כדי לשמור על התנהגות זו.', ], - colV1: 'פקודה גרסה 1', - colV2: 'פקודה גרסה 2', + colV1: 'פקודה בגרסה 1', + colV2: 'פקודה בגרסה 2', }, troubleshooting: { heading: 'פתרון בעיות', @@ -5675,7 +5681,7 @@ const HexplorationMod = (() => { 'שום דבר לא קורה כשאסימון זז: בדוק שהאסימון נמצא בשכבת האסימונים ותואם להגדרה אסימונים חושפים, ושבדף יש משושים (!hexploration status).', 'המשושים מוסטים מהרשת: השתמש בכיול, ואז בדוק עם אסימון על כמה משושים ברחבי המפה.', 'משושים הפסיקו להיחשף לאחר העתקת דף או משחק: הפעל סריקה מחדש בדף.', - 'מילוי אומר שלאזור אין מרכזי משושה: הצורה חייבת להכיל את המרכז של משושה אחת לפחות.', + 'מילוי אומר שלאזור אין מרכזי משושים: הצורה חייבת להכיל את המרכז של משושה אחד לפחות.', 'לכל דבר אחר, בדוק את יומן מסוף ה-API וכלול את ההודעות שלו כאשר אתה מבקש עזרה.', ], }, @@ -5790,7 +5796,7 @@ const HexplorationMod = (() => { }, fillColor: { label: 'Kitöltés színe', - desc: 'Új hatszögek színe. Használja az rgba()-t az átlátszó hexákhoz, például rgba(0,0,0,0,8).', + desc: 'Új hatszögek színe. Áttetsző hatszögekhez használjon rgba()-t, például rgba(0,0,0,0.8).', }, strokeColor: { label: 'Szegély színe', @@ -5798,7 +5804,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Címke színe', - desc: 'A csak GM-nek szánt névcímkék színe a megnevezett hexákon.', + desc: 'A csak GM-nek szánt névcímkék színe az elnevezett hatszögeken.', }, glimpseColor: { label: 'Bepillantás színe', @@ -5814,7 +5820,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Látótávolság', - desc: 'Hány hexa jelenik meg egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket mutatja, amelyeken a token áthalad.', + desc: 'Hány hatszög fedődik fel egy mozgó token körül (0-tól 20-ig). A 0 csak azokat a hatszögeket fedi fel, amelyeken a token áthalad.', }, lineOfSight: { label: 'Látóvonal', @@ -5822,11 +5828,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Felfedés az útvonal mentén', - desc: 'Ha be van kapcsolva, minden hexa, amelyen a token áthalad a húzás közben (beleértve az útpontokat is), megjelenik, nem csak az, ahol megáll.', + desc: 'Ha be van kapcsolva, minden hatszög felfedődik, amelyen a token a húzás közben áthalad (az útpontokat is beleértve), nem csak az, ahol megáll.', }, revealBy: { label: 'Felfedő tokenek', - desc: 'A tokenrétegen lévő jelzők hatszögeket mutatnak: a játékos által irányított jelzőket, bármely karaktert vagy minden jelzőt.', + desc: 'Mely tokenek fedik fel a hatszögeket a tokenrétegen: a játékos által irányított tokenek, a bármely karaktert ábrázoló tokenek vagy minden token.', }, revealMode: { label: 'Felfedési mód', @@ -5842,7 +5848,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Lefedett tokenek elrejtése', - desc: 'A Roll20 neveket, sávokat és aurákat rajzol a hatszögek fölé. Ha be van kapcsolva, a fedett hatszög alatti jelzőknek a játékosok által látható nevük, a sávok és az aurák ki vannak kapcsolva, majd újra bekapcsolnak, amikor feltárják őket.', + desc: 'A Roll20 a neveket, sávokat és aurákat a hatszögek fölé rajzolja. Ha be van kapcsolva, a lefedett hatszög alatti tokenek játékosok által látható neve, sávjai és aurái kikapcsolnak, majd a tokenek felfedésekor újra bekapcsolnak.', }, }, status: { @@ -5862,25 +5868,25 @@ const HexplorationMod = (() => { filled: 'Kitöltés kész. Rajzolt hatszögek: {created}. Átformálva: {restyled}. Elrejtett helyek: {icons}.', revealed: 'Felfedezett hatszögek: {count}.', - revealedPage: 'Az oldalon minden hex látható ({count}).', + revealedPage: 'Az oldal minden hatszöge felfedve ({count}).', confirmReset: - 'Eltávolít minden hexát innen: „{page}” ({count})? A helyjelzők visszatérnek a token rétegbe. A visszavonás ezt nem tudja visszafordítani.', + 'Eltávolítja az összes hatszöget innen: „{page}” ({count})? A helyszíntokenek visszakerülnek a tokenrétegre. A visszavonás ezt nem tudja visszafordítani.', resetPage: 'Az oldalról eltávolított hatszögek: {count}.', undone: 'Az utolsó kitöltés visszavonva. Eltávolított hatszögek: {removed}. Újraformázott hatszögek visszaállítva: {restored}.', named: '"{name}" nevű hatszögek: {count}.', unnamed: 'Törölt nevek: {count}.', marked: - 'Meglévő hexákban rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', + 'Meglévő hatszögekben rejtett helyek: {attached}. Várakozás a következő kitöltésre, amely lefedi őket: {pending}.', unmarked: 'Tokenek, amelyek már nem helyek: {count}.', settingChanged: '{setting} értéke {value}.', rescanned: - 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Újra benyújtva: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', + 'Az újraszkennelés befejeződött. Tartva: {kept}. Elfogadva: {adopted}. Áthelyezve: {moved}. Hiányzó és elfelejtett: {dropped}. Újra összekapcsolt címkék: {labels}. A helytokenek újra összekapcsolva: {icons}.', calibrated: - 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvéve {adopted}.', + 'Rács kalibrálva (oszloplépés {colStep}px, sorlépés {rowStep}px). Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', calibrationReset: - 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, újra benyújtva {moved}, átvett {adopted}.', - journalRebuilt: 'A "{help}" és a "{deck}" szórólapok újjáépítésre kerültek.', + 'A kalibráció eltávolítva. Újraellenőrzés: megtartva {kept}, áthelyezve {moved}, átvéve {adopted}.', + journalRebuilt: 'A(z) „{help}” és „{deck}” tájékoztató újra elkészült.', migrated: 'Az Ön Hexploration 1.x hatszögtérképei frissültek. Ha ezt a játékot egy Legacy játékból másolták, futtassa az Újraszkennelést minden hatszögtérkép-oldalon.', pruned: @@ -5890,26 +5896,26 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Ez a játék nem támogatja az előtér rétegre való rajzolást, ezért hatszögletűek rajzoltak a token rétegre.', + 'Ez a játék nem támogatja az előtérrétegre való rajzolást, ezért a hatszögek a tokenrétegre kerültek.', someFailed: 'Nem rajzolható hatszögek: {count}. A részletekért tekintse meg az API-konzolt.', }, errors: { noPage: 'Nem található az oldal, amelyen dolgozni kellene.', - notHex: 'Ez az oldal nem használ hatszögletű rácsot.', + notHex: 'Ez az oldal nem használ hatszögrácsot.', noPolygons: 'Válasszon ki egy vagy több rajzolt alakzatot a kitöltéshez.', emptyArea: 'A kijelölt terület egyetlen hatszögközéppontot sem tartalmaz.', - tooMany: 'Ez túl sok hexát hozna létre egyszerre ({count}).', - nothingToConceal: 'Válassza ki a rajzolt alakzatokat vagy jelzőket az elrejteni.', + tooMany: 'Ez túl sok hatszöget hozna létre egyszerre ({count}).', + nothingToConceal: 'Jelölje ki az elrejtendő rajzolt alakzatokat vagy tokeneket.', nothingToReveal: - 'Válassza ki a hatszögleteket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', + 'Válassza ki a hatszögeket, a rajzolt alakzatokat vagy a tokeneket a felfedéshez.', noTokens: 'Először válasszon ki egy vagy több tokent.', - noHexes: 'Először válasszon ki egy vagy több hexát (vagy hatszögletű tokent).', + noHexes: 'Először jelöljön ki egy vagy több hatszöget (vagy hatszögön álló tokent).', nothingToUndo: 'Nincs visszavonható kitöltés.', unknownCommand: 'Ismeretlen parancs: {command}', unknownSetting: 'Ismeretlen beállítás: {key}', unknownPageSetting: 'Oldalanként beállítható beállítások: {keys}', invalidValue: 'A „{value}” nem érvényes érték a {key} számára.', - calibrateNeedsTokens: 'Válasszon ki egy vagy két hatszögletű középpontra pattintott tokent.', + calibrateNeedsTokens: 'Jelöljön ki egy vagy két, hatszögközéppontra illesztett tokent.', calibrateFailed: 'Ezeket a tokeneket nem lehet kalibrálni.', unexpected: 'Hiba történt: {message}', }, @@ -5932,17 +5938,17 @@ const HexplorationMod = (() => { }, help: { menu: 'Mutasd a menüt.', - fill: 'A kiválasztott rajzolt alakzatokat hatszögletekkel fedjük le.', + fill: 'Fedje le a kijelölt rajzolt alakzatokat hatszögekkel.', fillInverse: 'Fedje le az egész oldalt, kivéve a kiválasztott formák belsejét.', undo: 'Vonja vissza az utolsó kitöltést, inverz kitöltést vagy elrejtést, és állítsa vissza a használt alakzatokat.', reveal: 'Jelenítse meg a kiválasztott hatszögeket, valamint a kiválasztott alakzatok és tokenek alatti hatszögeket.', - revealPage: 'Felfed minden hexát az oldalon bejelentések nélkül.', + revealPage: 'Fedjen fel minden hatszöget az oldalon bejelentések nélkül.', conceal: - 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögletekkel.', + 'A kiválasztott alakzatok és tokenek alatti területet ismét takarja be hatszögekkel.', explore: 'Felfedés a kijelölt tokenek körül, mintha éppen oda mozogtak volna.', - resetPage: 'Távolítson el minden hatszögletet az oldalon (először rákérdez).', - name: 'Nevezze el a kiválasztott hexákat, vagy a kiválasztott tokenek alatti hexákat. Hagyja üresen a nevet a törléshez.', + resetPage: 'Távolítson el minden hatszöget az oldalon (először rákérdez).', + name: 'Nevezze el a kijelölt hatszögeket vagy a kijelölt tokenek alatti hatszögeket. A név törléséhez hagyja üresen.', mark: 'A kiválasztott tokeneket rejtett helyekké alakíthatja.', unmark: 'Állítsa le, hogy a kiválasztott tokenek rejtett helyek legyenek.', set: 'Módosítson egy beállítást, vagy jelenítse meg az összes beállítást.', @@ -5950,7 +5956,7 @@ const HexplorationMod = (() => { pageClear: 'Távolítsa el az aktuális oldal felülírásait.', rescan: 'Építse újra az oldal hatszöglistáját, például egy oldal vagy játék másolása után.', calibrate: - 'Sorolja fel a hatszögletű rácsot egy vagy két kiválasztott tokennel, amelyeket hatszögletű középpontokra pattint.', + 'Igazítsa a hatszögrácsot egy vagy két kijelölt, hatszögközéppontra illesztett tokenhez.', calibrateReset: 'Távolítsa el az aktuális oldal kalibrálását.', status: 'Mutassa meg, mit tud a Hexploration az aktuális oldalról.', journal: 'Építse újra a Segítség és a Command Deck tájékoztatót.', @@ -5963,24 +5969,24 @@ const HexplorationMod = (() => { revealDesc: 'Jelöljön ki hatszögeket, alakzatokat vagy tokeneket a felfedésükhöz vagy újbóli lefedésükhöz. A Felderítés úgy fed fel a kijelölt tokenek körül, mintha odamozogtak volna.', locationsDesc: - 'Jelölje ki a tokeneket, hogy elrejtse őket hexák alatti helyként. Válasszon hexákat vagy tokeneket a hexa elnevezéséhez.', + 'Jelöljön ki tokeneket, hogy helyszínként elrejtse őket a hatszögek alatt. Jelöljön ki hatszögeket vagy tokeneket egy hatszög elnevezéséhez.', toolsDesc: 'Beállítások, oldalfelülírások, állapot, a másolt oldalak újraolvasása és a rács kalibrálása.', footer: 'A teljes útmutatásért lásd a „{help}” tájékoztatót.', }, handout: { versionLabel: 'Változat', - subtitle: 'Hex-by-hex felfedezés a Roll20 számára', + subtitle: 'Hatszögről hatszögre haladó felfedezés a Roll20-hoz', footer: 'Használja a „{deck}” tájékoztatót az egykattintásos vezérlőkhöz.', overview: { heading: 'Áttekintés', body: 'A Hexploration átlátszatlan hatszögekkel fedi le a hatszögtérképet. Ahogy a csapat halad, a hatszögek, amelyeken áthalad (és ha szeretné, a körülöttük lévők is), eltűnnek, így a térkép hatszögről hatszögre tárul fel. A hatszögek alá rejtett helyszínek helyezhetők el, ezeket megtalálásukkor a rendszer bejelenti. Jumpgate és Legacy játékokban is működik, bármekkora Hex (V) és Hex (H) rácson.', - demo: 'Nézzen meg egy rövid bemutatót (az 1-es verziótól)', + demo: 'Nézzen meg egy rövid bemutatót (az 1-es verzióból)', }, quickStart: { heading: 'Gyors kezdés', steps: [ - 'Nyisson meg egy oldalt, amelynek rácsának beállítása Hex (V) vagy Hex (H).', + 'Nyisson meg egy oldalt, amelynek rácsa Hex (V) vagy Hex (H) beállítású.', 'Rajzoljon egy vagy több alakzatot (sokszög, téglalap, ellipszis vagy szabadkézi) az elrejteni kívánt terület köré.', 'Jelölje ki az alakzatokat, és kattintson a Command Deck Kitöltés gombjára (vagy írja be: !hexploration fill). Az alakzatok helyére hatszögek kerülnek.', 'Nem kötelező: a kitöltés előtt jelölje ki a fontos helyek tokenjeit, és kattintson a Helyszín megjelölése gombra. Ezek a hatszögek alá rejtőznek, és felfedezésükkor a rendszer bejelenti őket.', @@ -6007,20 +6013,20 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexák és helyek neve', + heading: 'Elnevezett hatszögek és helyszínek', points: [ 'A Helyszín megjelölése a kijelölt tokeneket rejtett helyszínekké alakítja. A már hatszög alatt lévő token azonnal elrejtődik; különben a következő kitöltés rejti el, amely lefedi.', 'A fehér torony állapotjelzővel ellátott tokeneket a rendszer az 1-es verzióhoz hasonlóan helyként kezeli kitöltésekor.', - 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük kiderül, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', + 'A rejtett helyjelzők a GM rétegre kerülnek. Amikor a hatszögük felfedődik, a nevükkel együtt visszatérnek a token réteghez, és a felfedezésüket bejelentik.', 'A Hatszög elnevezése token nélkül ad nevet egy hatszögnek. A nevet a GM címkeként látja a GM-rétegen, és a rendszer bejelenti, amikor a hatszög felfedődik. A Jumpgate a GM-réteget az előtérréteg alá rajzolja, ezért a Jumpgate-ben a címkék csak akkor látszanak, ha a Hatszögek rétege beállítás értéke tokenréteg.', 'A Felfedezések bejelentése határozza meg, hogy mindenki, csak a GM vagy senki sem látja a bejelentést. A Felfedezések pingelése a játékosok nézetét is a helyszínre mozgatja.', ], }, settings: { - heading: 'Beállítások elemre', + heading: 'Beállítások', intro: 'A beállításokat a !hexploration set paranccsal (vagy a Beállítások gombbal) módosíthatja. A Hatszögek rétege, a Felfedő tokenek és a Nyelv a Mod beállítási oldalán is megadható.', - colKey: 'Kulcsfontosságú', + colKey: 'Kulcs', colName: 'Beállítás', colDesc: 'Leírás', perPage: '(Oldalonként beállítható.)', @@ -6028,7 +6034,7 @@ const HexplorationMod = (() => { jumpgate: { heading: 'Jumpgate és Legacy', points: [ - 'A Hexploration kidolgozza, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', + 'A Hexploration megállapítja, hogy a játék melyik motort használja, és megrajzolja a megfelelő formát. Bármelyik szerkesztőben rajzolt alakzatok kitölthetők.', 'Ha a Hatszögek rétege Automatikus értékre van állítva, a hatszögek az előtérrétegre, a tokenek fölé kerülnek, így a játékosok nem látják, mi van alattuk. Ha az előtérréteg nem érhető el, a rendszer helyette a tokenréteget használja.', 'A Jumpgate matematikailag szabályos hatszögeket rajzol, amelyek alakja kissé eltér a Legacy hatszögekétől. Ha a hatszögek nem illeszkednek az oldal rácsához, illesszen egy tokent egy hatszög középpontjára, jelölje ki, majd kattintson a Kalibrálás gombra. A hatszögméret javításához jelöljön ki két tokent ugyanazon sor (Hex V) vagy oszlop (Hex H) szomszédos hatszögeiben.', 'Amikor egy oldalt vagy játékot másolnak, a hatszögei új azonosítókat kapnak. Futtassa az Újraszkennelést az oldalon, hogy újra felvegye őket a névcímkéikkel és helyszíntokenjeikkel együtt.', @@ -6037,8 +6043,8 @@ const HexplorationMod = (() => { upgrading: { heading: 'Frissítés az 1-es verzióról', points: [ - 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML-készítőre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', - 'A meglévő hexa térképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', + 'A 2-es verziónak már nincs szüksége PathMath-ra, MatrixMath-ra, Vector Math-ra vagy HTML Builderre. Eltávolíthatja őket, hacsak egy másik mod nem használja őket.', + 'A meglévő hatszögtérképek, nevek, helyjelzők és beállítások automatikusan frissülnek az első indításkor.', 'Az 1-es verzió parancsai, beleértve a Hexploration_menu makrót is, továbbra is működnek.', 'Az 1-es verzióban bármely karaktert ábrázoló token felfedhetett hatszögeket. Ennek megtartásához állítsa a Felfedő tokenek beállítást Karakter tokenek értékre.', ], @@ -6052,7 +6058,7 @@ const HexplorationMod = (() => { 'A hatszögek el vannak tolva a rácstól: használja a Kalibrálást, majd ellenőrizze a token segítségével néhány hatszöget a térképen.', 'Egy oldal vagy játék másolása után a hatszögek nem fedődnek fel: futtassa az Újraszkennelést az oldalon.', 'Kitöltés szerint a területnek nincs hatszög középpontja: az alakzatnak tartalmaznia kell legalább egy hatszög középpontját.', - 'Ha bármi mást szeretne, ellenőrizze az API-konzol naplóját, és adja meg az üzeneteit, amikor segítséget kér.', + 'Minden más esetben ellenőrizze az API-konzol naplóját, és segítségkéréskor mellékelje az üzeneteit.', ], }, languages: { @@ -6063,12 +6069,12 @@ const HexplorationMod = (() => { colCode: 'Kód', }, credits: { - heading: 'Kredit', + heading: 'Készítők', original: 'Az eredeti mod szerzője', maintainer: 'A 2-es verziót karbantartja', marketplace: 'Ada művészeti csomagjai a Roll20 Marketplace-en', support: - 'Ha hibát talál, vagy ötlete van, tegye közzé a Roll20 Mod fórumban, vagy nyissa meg a problémát a GitHubon, és adja meg az API-konzol naplójából származó üzeneteket.', + 'Ha hibát talál, vagy ötlete van, írjon a Roll20 Mod fórumba, vagy nyisson hibajegyet a GitHubon, és mellékelje az API-konzol naplójának üzeneteit.', }, }, }; @@ -6198,11 +6204,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Rivela lungo il percorso', - desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un token mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', + desc: 'Quando è attivo, viene rivelato ogni esagono attraversato da un segnalino mentre viene trascinato (inclusi i punti di passaggio), non solo dove si ferma.', }, revealBy: { label: 'Segnalini che rivelano', - desc: 'Quali gettoni sul livello dei gettoni rivelano esagoni: gettoni controllati da un giocatore, gettoni che rappresentano qualsiasi personaggio o ogni gettone.', + desc: 'Quali segnalini sul livello dei segnalini rivelano esagoni: segnalini controllati da un giocatore, segnalini che rappresentano qualsiasi personaggio o tutti i segnalini.', }, revealMode: { label: 'Modalità di rivelazione', @@ -6214,11 +6220,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Ping sulle scoperte', - desc: 'Quando è attivo, i giocatori vengono collegati a una posizione denominata quando viene scoperta.', + desc: 'Quando è attivo, i giocatori ricevono un ping su una posizione con nome quando viene scoperta.', }, hideCoveredTokens: { label: 'Nascondi i segnalini coperti', - desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando sono attivi, i gettoni sotto un esagono coperto hanno il nome, le barre e le aure visibili al giocatore disattivati ​​e riattivati ​​quando vengono scoperti.', + desc: 'Roll20 disegna nomi, barre e aure sopra gli esagoni. Quando è attivo, i segnalini sotto un esagono coperto hanno il nome visibile ai giocatori, le barre e le aure disattivati, e riattivati quando vengono scoperti.', }, }, status: { @@ -6236,11 +6242,11 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Riempimento completato. Esagoni tracciati: {created}. Restyling: {restyled}. Posizioni nascoste: {icons}.', + 'Riempimento completato. Esagoni tracciati: {created}. Con stile aggiornato: {restyled}. Posizioni nascoste: {icons}.', revealed: 'Esagoni rivelati: {count}.', revealedPage: 'Tutti gli esagoni della pagina sono stati rivelati ({count}).', confirmReset: - 'Rimuovere ogni esagono da "{page}" ({count})? I token di posizione ritornano al livello dei token. L\'annullamento non può annullare questa operazione.', + 'Rimuovere ogni esagono da "{page}" ({count})? I segnalini di posizione tornano al livello dei segnalini. Annulla riempimento non può annullare questa operazione.', resetPage: 'Esagoni rimossi dalla pagina: {count}.', undone: 'Ultimo riempimento annullato. Esagoni rimossi: {removed}. Esagoni rinnovati ripristinati: {restored}.', @@ -6248,14 +6254,14 @@ const HexplorationMod = (() => { unnamed: 'Nomi cancellati: {count}.', marked: 'Posizioni nascoste negli esagoni esistenti: {attached}. In attesa del prossimo riempimento che li ricopra: {pending}.', - unmarked: 'Token che non rappresentano più posizioni: {count}.', + unmarked: 'Segnalini che non rappresentano più posizioni: {count}.', settingChanged: '{setting} impostato su {value}.', rescanned: - 'Nuova scansione completata. Conservato: {kept}. Adottato: {adopted}. Archiviato nuovamente: {moved}. Mancante e dimenticato: {dropped}. Etichette ricollegate: {labels}. Token di posizione ricollegati: {icons}.', + 'Nuova scansione completata. Conservati: {kept}. Adottati: {adopted}. Ricollocati: {moved}. Mancanti e dimenticati: {dropped}. Etichette ricollegate: {labels}. Segnalini di posizione ricollegati: {icons}.', calibrated: - 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Griglia calibrata (passo colonna {colStep}px, passo riga {rowStep}px). Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', calibrationReset: - 'Calibrazione rimossa. Nuova scansione: mantenuto {kept}, archiviato nuovamente {moved}, adottato {adopted}.', + 'Calibrazione rimossa. Nuova scansione: conservati {kept}, ricollocati {moved}, adottati {adopted}.', journalRebuilt: 'Le dispense "{help}" e "{deck}" sono state ricostruite.', migrated: 'Le tue mappe a esagoni di Hexploration 1.x sono state aggiornate. Se questo gioco è stato copiato da un gioco Legacy, esegui Nuova scansione su ogni pagina con una mappa a esagoni.', @@ -6266,7 +6272,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei token.', + 'Questo gioco non supporta il disegno sul livello in primo piano, quindi gli esagoni sono stati disegnati sul livello dei segnalini.', someFailed: 'Esagoni che non è stato possibile disegnare: {count}. Controlla la console API per i dettagli.', }, @@ -6276,17 +6282,17 @@ const HexplorationMod = (() => { noPolygons: 'Seleziona una o più forme disegnate da riempire.', emptyArea: "L'area selezionata non contiene alcun centro di esagono.", tooMany: 'Ciò creerebbe troppi esagoni in una volta sola ({count}).', - nothingToConceal: 'Seleziona forme disegnate o gettoni da nascondere.', - nothingToReveal: 'Seleziona esagoni, forme disegnate o gettoni da rivelare.', - noTokens: 'Seleziona prima uno o più token.', - noHexes: 'Seleziona prima uno o più esagoni (o gettoni che si trovano sugli esagoni).', + nothingToConceal: 'Seleziona forme disegnate o segnalini da nascondere.', + nothingToReveal: 'Seleziona esagoni, forme disegnate o segnalini da rivelare.', + noTokens: 'Seleziona prima uno o più segnalini.', + noHexes: 'Seleziona prima uno o più esagoni (o segnalini che si trovano sugli esagoni).', nothingToUndo: "Non c'è nessun riempimento da annullare.", unknownCommand: 'Comando sconosciuto: {command}', unknownSetting: 'Impostazione sconosciuta: {key}', unknownPageSetting: 'Impostazioni che possono essere impostate per pagina: {keys}', invalidValue: '"{value}" non è un valore valido per {key}.', - calibrateNeedsTokens: 'Seleziona uno o due token agganciati ai centri esagonali.', - calibrateFailed: 'Questi token non possono essere utilizzati per calibrare.', + calibrateNeedsTokens: 'Seleziona uno o due segnalini agganciati ai centri degli esagoni.', + calibrateFailed: 'Questi segnalini non possono essere utilizzati per calibrare.', unexpected: 'Qualcosa è andato storto: {message}', }, hints: { @@ -6298,41 +6304,41 @@ const HexplorationMod = (() => { 'Disegna una forma più grande o controlla le impostazioni della griglia della pagina.', tooMany: "Riempi un'area più piccola o dividi l'area in più forme.", noHexes: - 'Gli esagoni si trovano in primo piano o sul livello token; passare a quel livello per selezionarli.', + 'Gli esagoni si trovano sul livello in primo piano o sul livello dei segnalini; passa a quel livello per selezionarli.', unknownCommand: 'Digita !hexploration help per elencare i comandi.', unknownSetting: 'Digita !hexploration set per vedere tutte le impostazioni.', calibrateNeedsTokens: 'Aggancia un segnalino al centro di un esagono e selezionalo. Seleziona un secondo segnalino agganciato a un esagono adiacente nella stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', calibrateFailed: - 'Due gettoni devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', + 'I due segnalini devono trovarsi nella stessa riga (Hex V) o nella stessa colonna (Hex H), ad almeno un esagono di distanza.', unexpected: 'I dettagli si trovano nel registro della console API.', }, help: { menu: 'Mostra il menù.', fill: 'Copri le forme disegnate selezionate con esagoni.', fillInverse: "Copri l'intera pagina tranne l'interno delle forme selezionate.", - undo: "Annulla l'ultimo riempimento, inverti il ​​riempimento o nascondi e ripristina le forme utilizzate.", + undo: "Annulla l'ultimo riempimento, riempimento inverso o occultamento e ripristina le forme che ha usato.", reveal: - 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i gettoni selezionati.', + 'Rivela gli esagoni selezionati e gli esagoni sotto le forme e i segnalini selezionati.', revealPage: 'Rivela ogni esagono sulla pagina senza annunci.', - conceal: "Copri nuovamente l'area sotto le forme e i gettoni selezionati con esagoni.", - explore: 'Rivela i gettoni selezionati come se si fossero appena spostati lì.', + conceal: "Copri nuovamente con esagoni l'area sotto le forme e i segnalini selezionati.", + explore: 'Rivela attorno ai segnalini selezionati come se si fossero appena spostati lì.', resetPage: 'Rimuovi ogni esagono dalla pagina (chiede prima).', - name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i gettoni selezionati. Lascia il nome vuoto per cancellarlo.', - mark: 'Trasforma i gettoni selezionati in luoghi nascosti.', - unmark: 'Impedisci che i token selezionati siano posizioni nascoste.', + name: 'Assegna un nome agli esagoni selezionati o agli esagoni sotto i segnalini selezionati. Lascia il nome vuoto per cancellarlo.', + mark: 'Trasforma i segnalini selezionati in posizioni nascoste.', + unmark: 'Fai in modo che i segnalini selezionati non siano più posizioni nascoste.', set: "Modifica un'impostazione o mostra tutte le impostazioni.", - pageSet: "Sostituisci un'impostazione di visualizzazione solo nella pagina corrente.", + pageSet: "Sostituisci un'impostazione di rivelazione solo nella pagina corrente.", pageClear: 'Rimuovi le sostituzioni della pagina corrente.', rescan: "Ricostruisci l'elenco degli esagoni della pagina, ad esempio dopo aver copiato una pagina o un gioco.", calibrate: - 'Allinea la griglia esagonale con uno o due gettoni selezionati agganciati ai centri esagonali.', + 'Allinea la griglia esagonale con uno o due segnalini selezionati agganciati ai centri degli esagoni.', calibrateReset: 'Rimuovi la calibrazione della pagina corrente.', status: 'Mostra cosa sa Hexploration sulla pagina corrente.', journal: 'Ricostruisci le dispense Help e Command Deck.', help: 'Mostra questo elenco.', - handout: 'Le istruzioni complete si trovano nel volantino "{name}".', + handout: 'Le istruzioni complete si trovano nella dispensa "{name}".', }, deck: { drawDesc: @@ -6340,18 +6346,18 @@ const HexplorationMod = (() => { revealDesc: 'Seleziona esagoni, forme o segnalini per rivelarli o coprirli di nuovo. Esplora rivela attorno ai segnalini selezionati come se si fossero appena spostati.', locationsDesc: - 'Seleziona i token per nasconderli come posizioni sotto esagoni. Seleziona esagoni o gettoni per nominare un esagono.', + 'Seleziona i segnalini per nasconderli come posizioni sotto gli esagoni. Seleziona esagoni o segnalini per nominare un esagono.', toolsDesc: 'Impostazioni, sostituzioni di pagina, stato, nuova scansione delle pagine copiate e calibrazione della griglia.', - footer: 'Consulta il volantino "{help}" per le istruzioni complete.', + footer: 'Consulta la dispensa "{help}" per le istruzioni complete.', }, handout: { versionLabel: 'Versione', subtitle: 'Esplorazione esagono per esagono per Roll20', - footer: 'Utilizza il volantino "{deck}" per i controlli con un clic.', + footer: 'Usa la dispensa "{deck}" per i controlli con un clic.', overview: { heading: 'Panoramica', - body: "L'esplorazione copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.", + body: 'Hexploration copre una mappa esagonale con esagoni opachi. Mentre il gruppo si muove, gli esagoni che attraversa (e, se preferisci, gli esagoni attorno a lui) vengono rimossi, quindi la mappa viene scoperta un esagono alla volta. I luoghi nascosti possono essere posizionati sotto esagoni e vengono annunciati quando vengono trovati. Funziona nei giochi Jumpgate e Legacy, su griglie Hex (V) e Hex (H) di qualsiasi dimensione.', demo: 'Guarda una breve demo (dalla versione 1)', }, quickStart: { @@ -6367,7 +6373,7 @@ const HexplorationMod = (() => { commands: { heading: 'Comandi', intro: - 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisci sulla pagina che stai visualizzando.', + 'Solo i GM possono utilizzare questi comandi. La maggior parte agisce sugli oggetti selezionati; il resto agisce sulla pagina che stai visualizzando.', colCommand: 'Comando', colDesc: 'Cosa fa', }, @@ -6375,7 +6381,7 @@ const HexplorationMod = (() => { heading: 'Come funziona la rivelazione', points: [ 'Solo i segnalini sul livello dei segnalini rivelano gli esagoni. Quali segnalini contano lo stabilisce Segnalini che rivelano: per impostazione predefinita i segnalini dei giocatori, così il GM può spostare i mostri senza scoprire la mappa.', - 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i waypoint.', + 'Un segnalino rivela ogni esagono che copre (i segnalini grandi ne coprono diversi) e, con Rivela lungo il percorso attivo, ogni esagono del percorso lungo il quale è stato trascinato, compresi i punti di passaggio.', 'La Distanza di vista rivela gli esagoni attorno a ciascuno di quegli esagoni, a partire dai più vicini. Con Linea di vista attiva, un esagono non viene rivelato finché tra esso e il segnalino si trova un esagono coperto. Di solito gli esagoni più vicini vengono rivelati per primi, quindi in campo aperto la Linea di vista non cambia nulla: conta solo con una Distanza di vista di 2 o più ed esagoni che restano coperti, come il terreno riempito con una Distanza di rivelazione degli esagoni.', "La Distanza di rivelazione degli esagoni viene memorizzata su ciascun esagono quando viene riempito, quindi impostala prima di riempire; modificarla in seguito non influisce sugli esagoni già presenti sulla mappa. Un segnalino deve trovarsi entro quel numero di esagoni per rivelarli, per quanto lontano possa vedere, e con 0 vengono rivelati solo entrandoci. Per una catena montuosa: imposta la Distanza di rivelazione degli esagoni a 0, riempi le montagne, riportala a nessun limite, poi riempi le terre al di là. Con Distanza di vista 3 e Linea di vista attiva, il gruppo vede il terreno aperto attorno a sé, ma non le montagne né ciò che c'è dietro. Ogni esagono di montagna viene rivelato quando un segnalino vi entra.", 'Nella modalità Intravedi, gli esagoni in vista diventano trasparenti invece di scomparire e vengono rimossi quando un segnalino vi entra. Gli esagoni intravisti non bloccano la Linea di vista.', @@ -6387,8 +6393,8 @@ const HexplorationMod = (() => { heading: 'Esagoni e posizioni con nome', points: [ 'Segna posizione trasforma i segnalini selezionati in posizioni nascoste. Un segnalino già sotto un esagono viene nascosto subito; altrimenti viene nascosto dal riempimento successivo che lo copre.', - "Anche i gettoni con l'indicatore di stato della torre bianca vengono trattati come posizioni quando li riempi, come nella versione 1.", - 'I segnalini posizione nascosta vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei gettoni con il loro nome mostrato e la loro scoperta viene annunciata.', + "Anche i segnalini con l'indicatore di stato della torre bianca vengono trattati come posizioni quando riempi, come nella versione 1.", + 'I segnalini di posizione nascosti vengono spostati nel livello GM. Quando il loro esagono viene rivelato, ritornano al livello dei segnalini con il loro nome mostrato e la loro scoperta viene annunciata.', "Nomina esagono dà un nome a un esagono senza usare un segnalino. Il nome viene mostrato al GM come etichetta sul livello GM e annunciato quando l'esagono viene rivelato. Jumpgate disegna il livello GM sotto il livello in primo piano, quindi in Jumpgate le etichette sono visibili solo quando Livello degli esagoni è impostato sul livello dei segnalini.", "Annuncia le scoperte sceglie se l'annuncio lo vedono tutti, solo il GM o nessuno. Ping sulle scoperte sposta anche la visuale dei giocatori sulla posizione.", ], @@ -6398,14 +6404,14 @@ const HexplorationMod = (() => { intro: 'Modifica le impostazioni con !hexploration set (o con il pulsante Impostazioni). Livello degli esagoni, Segnalini che rivelano e Lingua si possono impostare anche nella pagina delle impostazioni della mod.', colKey: 'Chiave', - colName: 'Collocamento', + colName: 'Impostazione', colDesc: 'Descrizione', perPage: '(Può essere impostato per pagina.)', }, jumpgate: { heading: 'Jumpgate e Legacy', points: [ - "L'esplorazione determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.", + 'Hexploration determina quale motore utilizza il gioco e disegna il tipo di forma corrispondente. È possibile riempire le forme disegnate in entrambi gli editor.', "Con Livello degli esagoni impostato su Automatico, gli esagoni vengono disegnati sul livello in primo piano, sopra i segnalini, così i giocatori non possono vedere cosa c'è sotto. Se il livello in primo piano non è disponibile, viene usato invece il livello dei segnalini.", 'Jumpgate disegna esagoni matematicamente regolari, che hanno una forma leggermente diversa dagli esagoni Legacy. Se gli esagoni non sono allineati alla griglia di una pagina, aggancia un segnalino al centro di un esagono, selezionalo e fai clic su Calibra. Seleziona due segnalini in esagoni adiacenti della stessa riga (Hex V) o colonna (Hex H) per correggere anche la dimensione degli esagoni.', 'Quando una pagina o un gioco viene copiato, i suoi esagoni ottengono nuovi ID. Esegui Nuova scansione sulla pagina per riprenderli, insieme alle etichette dei nomi e ai segnalini di posizione.', @@ -6567,7 +6573,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '視界距離', - desc: '移動するトークンの周りのヘクス数が明らかになります (0 ～ 20)。 0 は、トークンが通過するヘクスのみを表示します。', + desc: '移動するトークンの周囲で何ヘクス先まで公開するか (0 ～ 20)。0 の場合は、トークンが通過するヘクスのみを公開します。', }, lineOfSight: { label: '視線', @@ -6579,7 +6585,7 @@ const HexplorationMod = (() => { }, revealBy: { label: '公開するトークン', - desc: 'トークン レイヤー上のどのトークンがヘクスを明らかにします: プレイヤーが制御するトークン、任意のキャラクターを表すトークン、またはすべてのトークン。', + desc: 'トークンレイヤー上のどのトークンがヘクスを公開するか: プレイヤーが操作するトークン、いずれかのキャラクターを表すトークン、またはすべてのトークン。', }, revealMode: { label: '公開モード', @@ -6591,7 +6597,7 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: '発見地点をピン', - desc: 'オンにすると、プレーヤーは指定された場所が検出されたときに、その場所に ping されます。', + desc: 'オンにすると、名前付きの場所が発見されたときに、プレイヤーにその場所が ping されます。', }, hideCoveredTokens: { label: '覆われたトークンを隠す', @@ -6613,29 +6619,29 @@ const HexplorationMod = (() => { }, messages: { filled: - '充填完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', + '塗りつぶし完了。描画されたヘクス: {created}。スタイル変更: {restyled}。非表示の場所: {icons}。', revealed: '明らかになったヘクス: {count}。', revealedPage: 'ページ上のすべてのヘクスが表示されます ({count})。', confirmReset: - '「{page}」({count}) からすべてのヘクスを削除しますか?位置トークンはトークン層に戻ります。 「元に戻す」ではこれを元に戻すことはできません。', + '「{page}」からすべてのヘクス ({count}) を削除しますか? 場所トークンはトークンレイヤーに戻ります。「元に戻す」ではこれを元に戻すことはできません。', resetPage: 'ページから削除されたヘクス: {count}。', undone: '最後の塗りつぶしが取り消されました。削除されたヘクス: {removed}。スタイル変更されたヘクスが復元されました: {restored}。', named: '「{name}」という名前のヘクス: {count}。', unnamed: '削除された名前: {count}。', marked: - '既存のヘクスに隠されている場所: {attached}。それらをカバーする次のフィルを待っています: {pending}。', + '既存のヘクスに隠された場所: {attached}。それらを覆う次の塗りつぶしを待っている場所: {pending}。', unmarked: '場所ではなくなったトークン: {count}。', settingChanged: '{setting} を {value} に設定します。', rescanned: - '再スキャンが完了しました。保持: {kept}。採用されました: {adopted}。再提出: {moved}。行方不明または忘れられているもの: {dropped}。ラベルが再リンクされました: {labels}。位置トークンが再リンクされました: {icons}。', + '再スキャンが完了しました。保持: {kept}。採用: {adopted}。再配置: {moved}。見つからず破棄: {dropped}。再リンクされたラベル: {labels}。再リンクされた場所トークン: {icons}。', calibrated: - 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + 'グリッドが調整されました (列ステップ {colStep}px、行ステップ {rowStep}px)。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', calibrationReset: - 'キャリブレーションが削除されました。再スキャン: {kept} を保持し、{moved} を再ファイルし、{adopted} を採用しました。', + '調整が削除されました。再スキャン: 保持 {kept}、再配置 {moved}、採用 {adopted}。', journalRebuilt: '「{help}」および「{deck}」の配布資料が再構築されました。', migrated: - 'Hexploration 1.x ヘクス マップがアップグレードされました。このゲームがレガシー ゲームからコピーされた場合は、各ヘクス マップ ページで再スキャンを実行します。', + 'Hexploration 1.x のヘクスマップがアップグレードされました。このゲームが Legacy ゲームからコピーされた場合は、各ヘクスマップページで再スキャンを実行してください。', pruned: '存在せず忘れ去られた保存ヘクス: {dropped}。このゲームまたはページがコピーされている場合は、ページで再スキャンを実行してヘクスを再度取得します。', readyHint: @@ -6651,7 +6657,7 @@ const HexplorationMod = (() => { noPage: '作業するページが見つかりませんでした。', notHex: 'このページはヘクスグリッドを使用していません。', noPolygons: '塗りつぶす描画形状を 1 つまたは複数選択します。', - emptyArea: '選択した領域には六角中心が含まれていません。', + emptyArea: '選択した領域にはヘクスの中心が含まれていません。', tooMany: 'これでは、一度に作成されるヘクスが多すぎます ({count})。', nothingToConceal: '非表示にする描画された図形またはトークンを選択します。', nothingToReveal: '表示するヘクス、描画された形状、またはトークンを選択します。', @@ -6662,7 +6668,7 @@ const HexplorationMod = (() => { unknownSetting: '不明な設定: {key}', unknownPageSetting: 'ページごとに設定できる設定: {keys}', invalidValue: '「{value}」は、{key} の有効な値ではありません。', - calibrateNeedsTokens: '六角中心にスナップされた 1 つまたは 2 つのトークンを選択します。', + calibrateNeedsTokens: 'ヘクスの中心にスナップされた 1 つまたは 2 つのトークンを選択します。', calibrateFailed: 'これらのトークンは調整には使用できません。', unexpected: '問題が発生しました: {message}', }, @@ -6684,12 +6690,12 @@ const HexplorationMod = (() => { }, help: { menu: 'メニューを表示します。', - fill: '選択した描画形状を六角形で覆います。', + fill: '選択した描画形状をヘクスで覆います。', fillInverse: '選択した図形の内側を除いてページ全体を覆います。', - undo: '最後の塗りつぶしを元に戻し、逆塗りつぶしまたは非表示にし、使用した形状を復元します。', + undo: '最後の塗りつぶし、反転塗りつぶし、または「隠す」を元に戻し、使用した図形を復元します。', reveal: '選択したヘクスと、選択した図形とトークンの下のヘクスを表示します。', revealPage: 'ページ上のすべてのヘクスをアナウンスなしで公開します。', - conceal: '選択したシェイプとトークンの下の領域を再度六角形で覆います。', + conceal: '選択した図形とトークンの下の領域を再びヘクスで覆います。', explore: '選択したトークンの周囲を、まるでそこに移動したかのように表示します。', resetPage: 'ページ上のすべてのヘクスを削除します (最初に質問します)。', name: '選択したヘクス、または選択したトークンの下のヘクスに名前を付けます。名前をクリアするには、名前を空のままにしておきます。', @@ -6700,7 +6706,7 @@ const HexplorationMod = (() => { pageClear: '現在のページのオーバーライドを削除します。', rescan: 'ページのヘクス一覧を再構築します。ページやゲームをコピーした後などに使います。', calibrate: - '選択した 1 つまたは 2 つのトークンを六角形の中心にスナップして六角形のグリッドを並べます。', + 'ヘクスの中心にスナップした 1 つまたは 2 つの選択トークンに、ヘクスグリッドを合わせます。', calibrateReset: '現在のページの調整を削除します。', status: '現在のページについて Hexploration が知っていることを表示します。', journal: 'ヘルプと Command Deck の配布資料を再構築します。', @@ -6713,7 +6719,7 @@ const HexplorationMod = (() => { revealDesc: 'ヘクス、図形、またはトークンを選択して、表示するか再び覆います。「探索」は、選択したトークンがそこへ移動したかのように周囲を表示します。', locationsDesc: - 'ヘクスの下の位置としてトークンを非表示にするには、トークンを選択します。ヘクスまたはトークンを選択してヘクスに名前を付けます。', + 'トークンを選択すると、ヘクスの下に場所として隠せます。ヘクスまたはトークンを選択してヘクスに名前を付けます。', toolsDesc: '設定、ページの上書き、ステータス、コピーされたページの再スキャン、グリッドの調整。', footer: '完全な手順については、配布資料「{help}」を参照してください。', @@ -6741,11 +6747,11 @@ const HexplorationMod = (() => { heading: 'コマンド', intro: 'これらのコマンドは GM のみが使用できます。ほとんどは、選択したオブジェクトに作用します。残りの部分は、表示しているページに基づいて動作します。', - colCommand: '指示', + colCommand: 'コマンド', colDesc: '何をするのか', }, revealing: { - heading: '暴露の仕組み', + heading: '公開の仕組み', points: [ 'ヘクスを表示するのは、トークンレイヤー上のトークンだけです。どのトークンが対象かは「公開するトークン」で設定します。既定ではプレイヤートークンなので、GM はマップを表示させずにモンスターを動かせます。', 'トークンは自分が覆うすべてのヘクスを表示し（大きなトークンは複数のヘクスを覆います）、「経路に沿って表示」がオンの場合は、ドラッグされた経路上のすべてのヘクス（ウェイポイントを含む）も表示します。', @@ -6760,8 +6766,8 @@ const HexplorationMod = (() => { heading: '名前付きヘクスと場所', points: [ '「場所としてマーク」は、選択したトークンを隠し場所に変えます。すでにヘクスの下にあるトークンはすぐに隠されます。それ以外の場合は、そのトークンを覆う次の塗りつぶしで隠されます。', - 'バージョン 1 と同様に、白い塔のステータス マーカーが付いたトークンも、埋めるときに場所として扱われます。', - '非表示の位置トークンは GM レイヤーに移動されます。彼らのヘクスが明らかになると、彼らは名前が表示された状態でトークン層に戻り、彼らの発見が発表されます。', + 'バージョン 1 と同様に、白い塔のステータスマーカーが付いたトークンも、塗りつぶすときに場所として扱われます。', + '非表示の場所トークンは GM レイヤーに移動されます。そのヘクスが公開されると、名前が表示された状態でトークンレイヤーに戻り、発見がアナウンスされます。', '「ヘクスに名前を付ける」は、トークンなしでヘクスに名前を付けます。名前は GM レイヤー上のラベルとして GM に表示され、ヘクスが表示されたときにアナウンスされます。 Jumpgate では GM レイヤーが前景レイヤーの下に描画されるため、Jumpgate でラベルが表示されるのは「ヘクスのレイヤー」がトークンレイヤーに設定されている場合のみです。', '「発見を通知」では、アナウンスを全員が見るか、GM のみが見るか、誰も見ないかを選択します。「発見地点をピン」は、さらにプレイヤーの視点をその場所へ移動します。', ], @@ -6770,7 +6776,7 @@ const HexplorationMod = (() => { heading: '設定', intro: '!hexploration set（または「設定」ボタン）で設定を変更します。「ヘクスのレイヤー」、「公開するトークン」、「言語」は Mod の設定ページでも設定できます。', - colKey: '鍵', + colKey: 'キー', colName: '設定', colDesc: '説明', perPage: '（ページごとに設定可能）', @@ -6788,7 +6794,7 @@ const HexplorationMod = (() => { heading: 'バージョン1からのアップグレード', points: [ 'バージョン 2 では、PathMath、MatrixMath、Vector Math、または HTML Builder は必要なくなりました。別の MOD が使用していない限り、削除しても構いません。', - '既存のヘクス マップ、名前、位置トークン、および設定は、初回起動時に自動的にアップグレードされます。', + '既存のヘクスマップ、名前、場所トークン、および設定は、初回起動時に自動的にアップグレードされます。', 'Hexploration_menu マクロを含むバージョン 1 のコマンドは引き続き機能します。', 'バージョン 1 では、キャラクターを表すトークンであればどれでもヘクスを表示できました。この動作を維持するには、「公開するトークン」を「キャラクタートークン」に設定してください。', ], @@ -6920,11 +6926,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: '테두리 색상', - desc: '새로운 육각형의 윤곽선 색상입니다.', + desc: '새 헥스의 윤곽선 색상입니다.', }, labelColor: { label: '라벨 색상', - desc: '명명된 육각형의 GM 전용 이름 라벨 색상입니다.', + desc: '이름이 지정된 헥스에 표시되는 GM 전용 이름 라벨의 색상입니다.', }, glimpseColor: { label: '반투명 색상', @@ -6940,7 +6946,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: '시야 거리', - desc: '움직이는 토큰 주변의 헥스 수는 공개됩니다(0~20). 0은 토큰이 통과하는 헥스만 나타냅니다.', + desc: '움직이는 토큰 주변에서 공개되는 헥스 수입니다(0~20). 0이면 토큰이 통과하는 헥스만 공개합니다.', }, lineOfSight: { label: '시선', @@ -7001,11 +7007,11 @@ const HexplorationMod = (() => { unmarked: '더 이상 위치가 아닌 토큰: {count}.', settingChanged: '{setting}이(가) {value}로 설정되었습니다.', rescanned: - '재검색이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 다시 제출됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', + '다시 스캔이 완료되었습니다. 유지됨: {kept}. 채택됨: {adopted}. 재배치됨: {moved}. 누락 및 잊혀짐: {dropped}. 다시 연결된 라벨: {labels}. 다시 연결된 위치 토큰: {icons}.', calibrated: - '그리드가 보정되었습니다(열 단계 {colStep}px, 행 단계 {rowStep}px). 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '그리드가 보정되었습니다(열 간격 {colStep}px, 행 간격 {rowStep}px). 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', calibrationReset: - '보정이 제거되었습니다. 재스캔: {kept} 유지, {moved} 다시 제출, {adopted} 채택.', + '보정이 제거되었습니다. 다시 스캔: {kept} 유지, {moved} 재배치, {adopted} 채택.', journalRebuilt: '"{help}" 및 "{deck}" 유인물이 다시 작성되었습니다.', migrated: 'Hexploration 1.x 헥스 지도가 업그레이드되었습니다. 이 게임이 Legacy 게임에서 복사된 경우 각 헥스 지도 페이지에서 다시 스캔을 실행하세요.', @@ -7016,17 +7022,17 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 육각형을 그렸습니다.', - someFailed: '그릴 수 없는 육각형: {count}. 자세한 내용은 API 콘솔을 확인하세요.', + '이 게임은 전경 레이어 그리기를 지원하지 않으므로 토큰 레이어에 헥스를 그렸습니다.', + someFailed: '그릴 수 없는 헥스: {count}. 자세한 내용은 API 콘솔을 확인하세요.', }, errors: { noPage: '작업할 페이지를 찾을 수 없습니다.', - notHex: '이 페이지는 육각형 그리드를 사용하지 않습니다.', + notHex: '이 페이지는 헥스 그리드를 사용하지 않습니다.', noPolygons: '채울 하나 이상의 그려진 도형을 선택합니다.', emptyArea: '선택한 영역에 헥스 중심이 하나도 없습니다.', tooMany: '그러면 한 번에 너무 많은 헥스가 생성됩니다({count}).', nothingToConceal: '숨길 그려진 모양이나 토큰을 선택하세요.', - nothingToReveal: '공개할 육각형, 그려진 모양 또는 토큰을 선택하세요.', + nothingToReveal: '공개할 헥스, 그려진 도형 또는 토큰을 선택하세요.', noTokens: '먼저 하나 이상의 토큰을 선택하세요.', noHexes: '먼저 하나 이상의 헥스(또는 헥스 위에 있는 토큰)를 선택하세요.', nothingToUndo: '실행 취소할 채우기가 없습니다.', @@ -7034,7 +7040,7 @@ const HexplorationMod = (() => { unknownSetting: '알 수 없는 설정: {key}', unknownPageSetting: '페이지별로 설정할 수 있는 설정 : {keys}', invalidValue: '"{value}"은(는) {key}에 유효한 값이 아닙니다.', - calibrateNeedsTokens: '육각형 중앙에 고정된 하나 또는 두 개의 토큰을 선택합니다.', + calibrateNeedsTokens: '헥스 중심에 스냅된 토큰을 하나 또는 두 개 선택하세요.', calibrateFailed: '해당 토큰은 보정에 사용할 수 없습니다.', unexpected: '문제가 발생했습니다: {message}', }, @@ -7045,7 +7051,7 @@ const HexplorationMod = (() => { '영역 주위에 다각형, 직사각형, 타원 또는 자유형 모양을 그리고 선택한 다음 다시 시도하십시오.', emptyArea: '더 큰 도형을 그리거나 페이지 그리드 설정을 확인하세요.', tooMany: '더 작은 영역을 채우거나 영역을 여러 모양으로 분할합니다.', - noHexes: '육각형은 전경 또는 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', + noHexes: '헥스는 전경 레이어나 토큰 레이어에 있습니다. 해당 레이어로 전환하여 선택하세요.', unknownCommand: '명령 목록을 보려면 !hexploration help를 입력하세요.', unknownSetting: '모든 설정을 보려면 !hexploration set를 입력하세요.', calibrateNeedsTokens: @@ -7056,10 +7062,10 @@ const HexplorationMod = (() => { }, help: { menu: '메뉴를 보여주세요.', - fill: '선택한 그려진 모양을 육각형으로 덮습니다.', + fill: '선택한 그려진 도형을 헥스로 덮습니다.', fillInverse: '선택한 도형 내부를 제외하고 전체 페이지를 덮습니다.', - undo: '마지막 채우기를 실행 취소하고, 채우기를 반전하거나 숨기고, 사용한 모양을 복원합니다.', - reveal: '선택한 육각형과 선택한 모양 및 토큰 아래의 육각형을 표시합니다.', + undo: '마지막 채우기, 반전 채우기 또는 숨기기를 취소하고, 사용한 도형을 복원합니다.', + reveal: '선택한 헥스와, 선택한 도형 및 토큰 아래의 헥스를 공개합니다.', revealPage: '알림 없이 페이지의 모든 헥스를 공개합니다.', conceal: '선택한 모양과 토큰 아래 영역을 다시 헥스로 덮습니다.', explore: '선택한 토큰이 방금 그곳으로 이동한 것처럼 주변을 드러냅니다.', @@ -7124,11 +7130,11 @@ const HexplorationMod = (() => { '헥스 공개 거리는 헥스를 채울 때 각 헥스에 저장되므로 채우기 전에 설정하세요. 나중에 바꿔도 이미 맵에 있는 헥스에는 영향을 주지 않습니다. 토큰이 얼마나 멀리 볼 수 있든, 헥스를 공개하려면 그 헥스 수 이내에 있어야 하며, 0이면 헥스에 들어가야만 공개됩니다. 산맥의 경우: 헥스 공개 거리를 0으로 설정하고 산을 채운 다음, 다시 없음으로 되돌리고 그 너머의 땅을 채우세요. 시야 거리 3에 시선을 켜면, 일행은 주변의 탁 트인 땅은 보지만 산이나 그 뒤에 있는 것은 보지 못합니다. 각 산 헥스는 토큰이 그 안으로 걸어 들어갈 때 공개됩니다.', '반투명 모드에서는 시야 안의 헥스가 사라지는 대신 비쳐 보이게 되며, 토큰이 들어가면 제거됩니다. 반투명이 된 헥스는 시선을 가리지 않습니다.', 'Roll20은 토큰 이름, 막대, 오라를 헥스 위에 그립니다. 덮인 토큰 숨기기를 켜면 덮인 헥스 아래에 있는 토큰은 덮개가 벗겨질 때까지 플레이어에게 보이는 이름, 막대, 오라가 꺼지므로, 숨은 몬스터가 정체를 드러내지 않습니다. 토큰이 덮여 있는 동안 그중 하나를 켜면 숨겨진 상태로 유지되다가 덮개가 벗겨질 때 켜집니다.', - 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 선택됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', + 'API는 다른 모드의 움직임을 보고하지 않습니다. TokenMod 이동은 자동으로 감지됩니다. 다른 모드의 경우 토큰을 선택하고 탐색을 클릭하거나 자신의 모드에서 Hexploration.revealAround(token)를 호출하세요.', ], }, locations: { - heading: '명명된 육각형 및 위치', + heading: '이름 붙은 헥스와 위치', points: [ '위치 표시는 선택한 토큰을 숨겨진 위치로 바꿉니다. 이미 헥스 아래에 있는 토큰은 즉시 숨겨지고, 그렇지 않으면 그 토큰을 덮는 다음 채우기 때 숨겨집니다.', '흰색 타워 상태 표시가 있는 토큰도 버전 1에서와 같이 채우기 시 위치로 처리됩니다.', @@ -7141,8 +7147,8 @@ const HexplorationMod = (() => { heading: '설정', intro: '!hexploration set(또는 설정 버튼)으로 설정을 변경하세요. 헥스 레이어, 공개하는 토큰, 언어는 Mod 설정 페이지에서도 설정할 수 있습니다.', - colKey: '열쇠', - colName: '환경', + colKey: '키', + colName: '설정', colDesc: '설명', perPage: '(페이지별로 설정 가능합니다.)', }, @@ -7181,7 +7187,7 @@ const HexplorationMod = (() => { body: '!hexploration set language로 언어를 선택하세요. 사용 가능한 언어:', colLanguage: '언어', colNative: '현지어 이름', - colCode: '암호', + colCode: '코드', }, credits: { heading: '크레딧', @@ -7282,7 +7288,7 @@ const HexplorationMod = (() => { desc: 'Język menu, komunikatów i materiałów informacyjnych.', }, hexLayer: { - label: 'Warstwa heksagonów', + label: 'Warstwa heksów', desc: 'Gdzie rysowane są nowe heksy. Auto próbuje warstwy pierwszego planu (nad żetonami), a jeśli gra jej nie obsługuje, używa warstwy żetonów.', }, fillColor: { @@ -7295,7 +7301,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Kolor etykiety', - desc: 'Kolor etykiet z nazwami tylko dla GM na nazwanych heksach.', + desc: 'Kolor etykiet z nazwami tylko dla MG na nazwanych heksach.', }, glimpseColor: { label: 'Kolor przebłysku', @@ -7306,7 +7312,7 @@ const HexplorationMod = (() => { desc: 'Szerokość konturu nowych heksów w pikselach (0 do 20).', }, maxDistance: { - label: 'Odległość odkrywania heksagonów', + label: 'Odległość odkrywania heksów', desc: 'Zapisywana na heksach w chwili ich wypełniania, więc ustaw ją przed wypełnianiem: późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi; przy 0 odkrywa się je tylko przez wejście na nie. Używaj jej dla gór lub lasów. Pozostaw puste, aby nie było ograniczenia.', }, revealDistance: { @@ -7315,11 +7321,11 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Linia wzroku', - desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksagonów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', + desc: 'Kiedy jest włączone, heksy, które pozostają zakryte, np. góry wypełnione przy ustawieniu „Odległość odkrywania heksów”, zasłaniają heksy za nimi. Ma to znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej.', }, revealPath: { label: 'Odkrywaj wzdłuż ścieżki', - desc: 'Kiedy jest włączone, odkrywane jest każde pole, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', + desc: 'Kiedy jest włączone, odkrywany jest każdy heks, przez które przechodzi żeton podczas przeciągania (w tym punkty orientacyjne), a nie tylko miejsce, w którym się zatrzymuje.', }, revealBy: { label: 'Żetony odkrywające', @@ -7345,7 +7351,7 @@ const HexplorationMod = (() => { status: { engine: 'Silnik gry', grid: 'Siatka', - layer: 'Warstwa heksagonów', + layer: 'Warstwa heksów', hexes: 'Heksy', named: 'Nazwane heksy', icons: 'Żetony lokalizacji', @@ -7357,14 +7363,14 @@ const HexplorationMod = (() => { }, messages: { filled: - 'Wypełnienie zakończone. Wylosowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', + 'Wypełnienie zakończone. Narysowane heksy: {created}. Zmiana stylu: {restyled}. Ukryte lokalizacje: {icons}.', revealed: 'Ujawnione heksy: {count}.', - revealedPage: 'Każdy odkryty heks na stronie ({count}).', + revealedPage: 'Odkryto wszystkie heksy na stronie ({count}).', confirmReset: 'Usunąć wszystkie heksy z „{page}” ({count})? Żetony lokalizacji wracają na warstwę żetonów. Opcja Cofnij nie może tego odwrócić.', resetPage: 'Heksy usunięte ze strony: {count}.', undone: - 'Ostatnie wypełnienie nie zostało wykonane. Usunięte heksy: {removed}. Przywrócono nowe heksy: {restored}.', + 'Cofnięto ostatnie wypełnienie. Usunięte heksy: {removed}. Przywrócone heksy ze zmienionym stylem: {restored}.', named: 'Heksy o nazwie „{name}”: {count}.', unnamed: 'Nazwy zostały usunięte: {count}.', marked: @@ -7372,11 +7378,11 @@ const HexplorationMod = (() => { unmarked: 'Tokeny, które nie są już lokalizacjami: {count}.', settingChanged: '{setting} ustawiony na {value}.', rescanned: - 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Zgłoszono ponownie: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', + 'Ponowne skanowanie zakończone. Zachowane: {kept}. Przyjęto: {adopted}. Przeniesione: {moved}. Zaginione i zapomniane: {dropped}. Etykiety ponownie połączone: {labels}. Połączono ponownie tokeny lokalizacji: {icons}.', calibrated: - 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, ponownie złożone {moved}, przyjęte {adopted}.', + 'Skalibrowano siatkę (krok kolumny {colStep}px, krok wiersza {rowStep}px). Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', calibrationReset: - 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, ponownie przesłane {moved}, przyjęte {adopted}.', + 'Kalibracja usunięta. Ponowne skanowanie: zachowane {kept}, przeniesione {moved}, przyjęte {adopted}.', journalRebuilt: 'Przebudowano materiały informacyjne „{help}” i „{deck}”.', migrated: 'Twoje mapy heksowe z Hexploration 1.x zostały zaktualizowane. Jeśli ta gra została skopiowana z gry Legacy, uruchom „Skanuj ponownie” na każdej stronie z mapą heksową.', @@ -7431,7 +7437,7 @@ const HexplorationMod = (() => { menu: 'Pokaż menu.', fill: 'Zakryj wybrane narysowane kształty heksami.', fillInverse: 'Zakryj całą stronę z wyjątkiem wnętrza wybranych kształtów.', - undo: 'Cofnij ostatnie wypełnienie, odwróć wypełnienie lub ukryj i przywróć używane kształty.', + undo: 'Cofnij ostatnie wypełnienie, odwrotne wypełnienie lub zakrycie i przywróć użyte kształty.', reveal: 'Odsłoń wybrane heksy oraz heksy pod wybranymi kształtami i żetonami.', revealPage: 'Odkryj każdy heks na stronie bez ogłoszeń.', conceal: 'Ponownie zakryj obszar pod wybranymi kształtami i żetonami heksami.', @@ -7466,12 +7472,11 @@ const HexplorationMod = (() => { handout: { versionLabel: 'Wersja', subtitle: 'Eksploracja heks po heksie dla Roll20', - footer: - 'Skorzystaj z materiałów informacyjnych „{deck}”, aby uzyskać informacje na temat elementów sterujących jednym kliknięciem.', + footer: 'Używaj materiału informacyjnego „{deck}”, aby sterować jednym kliknięciem.', overview: { heading: 'Przegląd', - body: 'Heksploracja obejmuje mapę heksów nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', - demo: 'Obejrzyj krótkie demo (od wersji 1)', + body: 'Hexploration zakrywa mapę heksową nieprzezroczystymi heksami. Gdy drużyna się porusza, heksy, przez które przechodzi (oraz, jeśli wolisz, heksy wokół niej) są usuwane, więc mapa jest odkrywana heks po heksie. Ukryte lokalizacje można umieszczać pod heksami i ogłaszać je po ich znalezieniu. Działa w grach Jumpgate i Legacy, na siatkach Hex (V) i Hex (H) o dowolnym rozmiarze.', + demo: 'Obejrzyj krótkie demo (z wersji 1)', }, quickStart: { heading: 'Szybki start', @@ -7495,8 +7500,8 @@ const HexplorationMod = (() => { points: [ 'Heksy odkrywają tylko żetony na warstwie żetonów. To, które żetony się liczą, określa ustawienie „Żetony odkrywające”: domyślnie żetony graczy, więc MG może przesuwać potwory bez odkrywania mapy.', 'Żeton odkrywa każdy heks, który zajmuje (duże żetony zajmują kilka), a przy włączonej opcji „Odkrywaj wzdłuż ścieżki” także każdy heks na trasie, po której był przeciągany, łącznie z punktami pośrednimi.', - '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksagonów”.', - '„Odległość odkrywania heksagonów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksagonów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', + '„Zasięg wzroku” odkrywa heksy wokół każdego z tych heksów, zaczynając od najbliższych. Gdy „Linia wzroku” jest włączona, heks nie zostaje odkryty, dopóki między nim a żetonem leży zakryty heks. Bliższe heksy są zwykle odkrywane jako pierwsze, więc na otwartym terenie „Linia wzroku” niczego nie zmienia: ma znaczenie tylko wtedy, gdy „Zasięg wzroku” wynosi 2 lub więcej i istnieją heksy, które pozostają zakryte, np. teren wypełniony przy ustawieniu „Odległość odkrywania heksów”.', + '„Odległość odkrywania heksów” jest zapisywana na każdym heksie w chwili jego wypełniania, więc ustaw ją przed wypełnianiem; późniejsza zmiana nie wpływa na heksy, które już są na mapie. Żeton musi znajdować się w obrębie tylu heksów, aby je odkryć, niezależnie od tego, jak daleko widzi, a przy 0 odkrywa się je tylko przez wejście na nie. Dla pasma górskiego: ustaw „Odległość odkrywania heksów” na 0, wypełnij góry, ponownie wyczyść tę wartość (bez limitu), a potem wypełnij teren za nimi. Gdy „Zasięg wzroku” wynosi 3, a „Linia wzroku” jest włączona, drużyna widzi otwarty teren wokół siebie, ale nie góry ani to, co leży za nimi. Każdy heks górski zostaje odkryty, gdy wejdzie na niego żeton.', 'W trybie Przebłysk heksy w zasięgu wzroku stają się przezroczyste zamiast znikać i są usuwane, gdy wejdzie na nie żeton. Heksy widziane w trybie Przebłysk nie zasłaniają widoku przy włączonej opcji „Linia wzroku”.', 'Roll20 rysuje nazwy, paski i aury żetonów nad heksami. Przy włączonej opcji „Ukrywaj zakryte żetony” żeton pod zakrytym heksem ma wyłączone widoczne dla graczy nazwę, paski i aury, dopóki nie zostanie odkryty, więc ukryte potwory się nie zdradzą. Jeśli włączysz któryś z tych elementów, gdy żeton jest zakryty, pozostanie on ukryty i zostanie włączony po odkryciu żetonu.', 'API nie zgłasza ruchów wykonanych przez inne mody. Ruchy TokenMod są wychwytywane automatycznie; w przypadku innych modów zaznacz żetony i kliknij „Eksploruj” albo wywołaj Hexploration.revealAround(token) z własnego moda.', @@ -7505,27 +7510,27 @@ const HexplorationMod = (() => { locations: { heading: 'Nazwane heksy i lokalizacje', points: [ - 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które je zakrywa.', + 'Oznacz lokalizację zamienia wybrane żetony w ukryte lokalizacje. Żeton znajdujący się już pod heksem jest natychmiast ukrywany; w przeciwnym razie zostanie ukryty przez następne wypełnienie, które go zakryje.', 'Żetony ze znacznikiem stanu białej wieży są również traktowane jako lokalizacje podczas zapełniania, tak jak w wersji 1.', - 'Żetony ukrytych lokalizacji są przenoszone na warstwę GM. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z pokazaną nazwą i ogłaszają swoje odkrycie.', - '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksagonów” jest ustawiona na warstwę żetonów.', + 'Żetony ukrytych lokalizacji są przenoszone na warstwę MG. Kiedy ich heks zostanie odkryty, wracają na warstwę żetonów z widoczną nazwą, a ich odkrycie zostaje ogłoszone.', + '„Nazwij heks” nadaje heksowi nazwę bez żetonu. Nazwa jest pokazywana MG jako etykieta na warstwie MG i ogłaszana, gdy heks zostanie odkryty. Jumpgate rysuje warstwę MG pod warstwą pierwszego planu, więc w Jumpgate etykiety są widoczne tylko wtedy, gdy „Warstwa heksów” jest ustawiona na warstwę żetonów.', '„Ogłaszaj odkrycia” określa, czy ogłoszenie widzą wszyscy, tylko MG, czy nikt. „Pinguj odkrycia” dodatkowo przenosi widok graczy na lokalizację.', ], }, settings: { heading: 'Ustawienia', intro: - 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksagonów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', + 'Zmieniaj ustawienia poleceniem !hexploration set (lub przyciskiem Ustawienia). „Warstwa heksów”, „Żetony odkrywające” i „Język” można też ustawić na stronie ustawień moda.', colKey: 'Klucz', colName: 'Ustawienie', colDesc: 'Opis', perPage: '(Można ustawić na stronę.)', }, jumpgate: { - heading: 'Jumpgate i Dziedzictwo', + heading: 'Jumpgate i Legacy', points: [ - 'Heexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', - 'Gdy „Warstwa heksagonów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', + 'Hexploration sprawdza, z jakiego silnika korzysta gra, i rysuje odpowiedni kształt. Kształty narysowane w dowolnym edytorze można wypełnić.', + 'Gdy „Warstwa heksów” jest ustawiona na Auto, heksy są rysowane na warstwie pierwszego planu, nad żetonami, więc gracze nie widzą, co jest pod spodem. Jeśli warstwa pierwszego planu jest niedostępna, używana jest warstwa żetonów.', 'Jumpgate rysuje matematycznie regularne heksy, które mają nieco inny kształt niż heksy Legacy. Jeśli heksy nie pokrywają się z siatką strony, przyciągnij żeton do środka heksu, zaznacz go i kliknij „Kalibruj”. Zaznacz dwa żetony na sąsiednich heksach tego samego rzędu (Hex V) lub kolumny (Hex H), aby skorygować także rozmiar heksu.', 'Po skopiowaniu strony lub gry jej heksy otrzymują nowe identyfikatory. Uruchom „Skanuj ponownie” na stronie, aby ponownie je odnaleźć wraz z etykietami nazw i żetonami lokalizacji.', ], @@ -7559,7 +7564,7 @@ const HexplorationMod = (() => { colCode: 'Kod', }, credits: { - heading: 'Kredyty', + heading: 'Autorzy', original: 'Oryginalny mod autorstwa', maintainer: 'Wersja 2 obsługiwana przez', marketplace: 'Pakiety grafik Ady na Roll20 Marketplace', @@ -7686,7 +7691,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos em redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos por onde a ficha passa.', }, lineOfSight: { label: 'Linha de visão', @@ -7694,7 +7699,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revelar ao longo do percurso', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde pára.', + desc: 'Quando ativado, cada hexágono por onde uma ficha passa enquanto é arrastada (incluindo pontos de passagem) é revelado, e não apenas onde para.', }, revealBy: { label: 'Fichas que revelam', @@ -7714,7 +7719,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Ocultar fichas cobertas', - desc: 'Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, os tokens sob um hexágono coberto têm o seu nome, barras e auras visíveis para o jogador desligados e ligados novamente quando são descobertos.', + desc: 'O Roll20 desenha nomes, barras e auras por cima dos hexágonos. Quando ativado, as fichas sob um hexágono coberto têm o seu nome, barras e auras visíveis para os jogadores desligados, que voltam a ser ligados quando as fichas são descobertas.', }, }, status: { @@ -7733,7 +7738,7 @@ const HexplorationMod = (() => { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais escondidos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? As fichas de localização regressam à camada de fichas. Esta ação não pode ser revertida com Desfazer.', @@ -7743,15 +7748,15 @@ const HexplorationMod = (() => { named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais escondidos em hexágonos existentes: {attached}. Aguardam o próximo enchimento que os cobre: ​​​​{pending}.', - unmarked: 'Tokens que já não são locais: {count}.', + 'Locais escondidos em hexágonos existentes: {attached}. A aguardar o próximo preenchimento que os cubra: {pending}.', + unmarked: 'Fichas que já não são locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adoptado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos novamente ligados: {labels}. Tokens de localização novamente ligados: {icons}.', + 'Reanálise concluída. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos novamente ligados: {labels}. Fichas de local novamente ligadas: {icons}.', calibrated: - 'Grelha calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grelha calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova análise: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reanálise: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Os seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reanalisar em cada página com mapa de hexágonos.', @@ -7762,7 +7767,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que foram desenhados hexágonos na camada de tokens.', + 'Este jogo não suporta o desenho na camada de primeiro plano, pelo que os hexágonos foram desenhados na camada de fichas.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique a consola da API para obter detalhes.', }, @@ -7774,15 +7779,15 @@ const HexplorationMod = (() => { tooMany: 'Isto criaria muitos hexágonos de uma só vez ({count}).', nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', - noTokens: 'Selecione primeiro um ou mais tokens.', + noTokens: 'Selecione primeiro uma ou mais fichas.', noHexes: 'Selecione primeiro um ou mais hexágonos (ou fichas sobre hexágonos).', - nothingToUndo: 'Não há enchimento para desfazer.', + nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione uma ou duas fichas encaixadas em centros de hexágonos.', - calibrateFailed: 'Estes tokens não podem ser utilizados para calibrar.', + calibrateFailed: 'Estas fichas não podem ser utilizadas para calibrar.', unexpected: 'Algo correu mal: {message}', }, hints: { @@ -7793,7 +7798,7 @@ const HexplorationMod = (() => { emptyArea: 'Desenhe uma forma maior ou verifique as definições da grelha da página.', tooMany: 'Preencha uma área mais pequena ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de tokens; mude para essa camada para os selecionar.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de fichas; mude para essa camada para os selecionar.', unknownCommand: 'Introduza !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as definições.', calibrateNeedsTokens: @@ -7806,7 +7811,7 @@ const HexplorationMod = (() => { menu: 'Mostre o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último enchimento, inverta o enchimento ou ocultar e restaure as formas utilizadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que este utilizou.', reveal: 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', revealPage: 'Revele cada hexágono da página sem anúncios.', @@ -7814,9 +7819,9 @@ const HexplorationMod = (() => { explore: 'Revele à volta das fichas selecionadas como se tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta primeiro).', - name: 'Nomeie os hexágonos selecionados ou os hexágonos sob os tokens selecionados. Deixe o nome vazio para o limpar.', - mark: 'Transforme os tokens selecionados em locais ocultos.', - unmark: 'Impede que os tokens selecionados sejam locais ocultos.', + name: 'Nomeie os hexágonos selecionados ou os hexágonos sob as fichas selecionadas. Deixe o nome vazio para o limpar.', + mark: 'Transforme as fichas selecionadas em locais ocultos.', + unmark: 'Faça com que as fichas selecionadas deixem de ser locais ocultos.', set: 'Altere uma definição ou mostre todas as definições.', pageSet: 'Substituir uma configuração de revelação apenas na página atual.', pageClear: 'Remova as substituições da página atual.', @@ -7838,7 +7843,7 @@ const HexplorationMod = (() => { locationsDesc: 'Selecione fichas para as ocultar como locais sob hexágonos. Selecione hexágonos ou fichas para nomear um hexágono.', toolsDesc: - 'Definições, substituições de páginas, estado, nova digitalização de páginas copiadas e calibração da grelha.', + 'Definições, substituições de páginas, estado, reanálise de páginas copiadas e calibração da grelha.', footer: 'Consulte o folheto "{help}" para obter as instruções completas.', }, handout: { @@ -7880,11 +7885,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma as fichas selecionadas em locais escondidos. Uma ficha que já esteja sob um hexágono é ocultada imediatamente; caso contrário, ficará oculta pelo próximo preenchimento que a cobrir.', - 'Os tokens com o marcador de estado da torre branca também são tratados como locais quando preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando o seu hexágono é revelado, regressam à camada de token com o seu nome mostrado e a sua descoberta é anunciada.', + 'As fichas com o marcador de estado da torre branca também são tratadas como locais quando preenche, como na versão 1.', + 'As fichas de local ocultas são movidas para a camada do GM. Quando o seu hexágono é revelado, regressam à camada de fichas com o nome visível e a sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de uma ficha. O nome é mostrado ao GM como uma etiqueta na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM por baixo da camada de primeiro plano, pelo que no Jumpgate as etiquetas só aparecem quando a opção Camada dos hexágonos está definida como camada de fichas.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém vê o anúncio. Pingar descobertas também move a vista dos jogadores para o local.', ], @@ -7899,7 +7904,7 @@ const HexplorationMod = (() => { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual o motor que o jogo utiliza e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, por cima das fichas, para que os jogadores não consigam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, é utilizada a camada de fichas.', @@ -7938,7 +7943,7 @@ const HexplorationMod = (() => { credits: { heading: 'Créditos', original: 'Mod original de', - maintainer: 'Versão 2 mantida pela', + maintainer: 'Versão 2 mantida por', marketplace: 'Pacotes de arte de Ada no Roll20 Marketplace', support: 'Se encontrar um bug ou tiver uma ideia, publique no fórum Roll20 Mod ou abra um problema no GitHub e inclua quaisquer mensagens do registo da consola da API.', @@ -8059,11 +8064,11 @@ const HexplorationMod = (() => { }, maxDistance: { label: 'Distância de revelação dos hexágonos', - desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Uma ficha deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', + desc: 'Gravada nos hexágonos quando eles são preenchidos, então defina-a antes de preencher: alterá-la depois não afeta os hexágonos que já estão no mapa. Um token deve estar a no máximo este número de hexágonos para revelá-los, por mais longe que possa ver; com 0, eles só são revelados quando se entra neles. Use-a para montanhas ou florestas. Deixe em branco para não ter limite.', }, revealDistance: { label: 'Distância de visão', - desc: 'Quantos hexágonos ao redor de uma ficha em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', + desc: 'Quantos hexágonos ao redor de um token em movimento são revelados (0 a 20). 0 revela apenas os hexágonos pelos quais o token passa.', }, lineOfSight: { label: 'Linha de visão', @@ -8071,11 +8076,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Revelar ao longo do caminho', - desc: 'Quando ativado, cada hexágono que uma ficha passa enquanto é arrastada (incluindo waypoints) é revelado, não apenas onde ela para.', + desc: 'Quando ativado, cada hexágono pelo qual um token passa enquanto é arrastado (incluindo pontos de passagem) é revelado, não apenas onde ele para.', }, revealBy: { label: 'Tokens que revelam', - desc: 'Quais fichas na camada de fichas revelam hexágonos: fichas controladas por um jogador, fichas que representam qualquer personagem ou todas as fichas.', + desc: 'Quais tokens na camada de tokens revelam hexágonos: tokens controlados por um jogador, tokens que representam qualquer personagem ou todos os tokens.', }, revealMode: { label: 'Modo de revelação', @@ -8110,7 +8115,7 @@ const HexplorationMod = (() => { messages: { filled: 'Preenchimento completo. Hexágonos desenhados: {created}. Reestilizado: {restyled}. Locais ocultos: {icons}.', - revealed: 'Feitiços revelados: {count}.', + revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono da página revelado ({count}).', confirmReset: 'Remover todos os hexágonos de "{page}" ({count})? Os tokens de localização voltam para a camada de tokens. Esta ação não pode ser revertida com Desfazer.', @@ -8120,15 +8125,15 @@ const HexplorationMod = (() => { named: 'Hexágonos chamados "{name}": {count}.', unnamed: 'Nomes apagados: {count}.', marked: - 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cobre: ​​{pending}.', + 'Locais ocultos em hexágonos existentes: {attached}. Aguardando o próximo preenchimento que os cubra: {pending}.', unmarked: 'Tokens que não são mais locais: {count}.', settingChanged: '{setting} definido como {value}.', rescanned: - 'Nova verificação concluída. Mantido: {kept}. Adotado: {adopted}. Arquivado novamente: {moved}. Ausente e esquecido: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de localização vinculados novamente: {icons}.', + 'Reescaneamento concluído. Mantidos: {kept}. Adotados: {adopted}. Realocados: {moved}. Ausentes e esquecidos: {dropped}. Rótulos vinculados novamente: {labels}. Tokens de local vinculados novamente: {icons}.', calibrated: - 'Grade calibrada (etapa de coluna {colStep}px, etapa de linha {rowStep}px). Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Grade calibrada (passo da coluna {colStep}px, passo da linha {rowStep}px). Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', calibrationReset: - 'Calibração removida. Nova varredura: mantido {kept}, arquivado novamente {moved}, adotado {adopted}.', + 'Calibração removida. Reescaneamento: mantidos {kept}, realocados {moved}, adotados {adopted}.', journalRebuilt: 'Os folhetos "{help}" e "{deck}" foram reconstruídos.', migrated: 'Seus mapas de hexágonos do Hexploration 1.x foram atualizados. Se este jogo foi copiado de um jogo Legacy, execute Reescanear em cada página com mapa de hexágonos.', @@ -8139,7 +8144,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Este jogo não suporta desenho na camada de primeiro plano, então hexágonos foram desenhados na camada de token.', + 'Este jogo não suporta desenho na camada de primeiro plano, então os hexágonos foram desenhados na camada de tokens.', someFailed: 'Hexágonos que não puderam ser desenhados: {count}. Verifique o console da API para obter detalhes.', }, @@ -8149,17 +8154,17 @@ const HexplorationMod = (() => { noPolygons: 'Selecione uma ou mais formas desenhadas para preencher.', emptyArea: 'A área selecionada não contém nenhum centro de hexágono.', tooMany: 'Isso criaria muitos hexágonos de uma só vez ({count}).', - nothingToConceal: 'Selecione formas desenhadas ou fichas para ocultar.', - nothingToReveal: 'Selecione hexágonos, formas desenhadas ou fichas para revelar.', + nothingToConceal: 'Selecione formas desenhadas ou tokens para ocultar.', + nothingToReveal: 'Selecione hexágonos, formas desenhadas ou tokens para revelar.', noTokens: 'Selecione um ou mais tokens primeiro.', - noHexes: 'Selecione um ou mais hexágonos (ou fichas sobre hexágonos) primeiro.', + noHexes: 'Selecione um ou mais hexágonos (ou tokens sobre hexágonos) primeiro.', nothingToUndo: 'Não há preenchimento para desfazer.', unknownCommand: 'Comando desconhecido: {command}', unknownSetting: 'Configuração desconhecida: {key}', unknownPageSetting: 'Configurações que podem ser definidas por página: {keys}', invalidValue: '"{value}" não é um valor válido para {key}.', calibrateNeedsTokens: 'Selecione um ou dois tokens encaixados em centros de hexágonos.', - calibrateFailed: 'Esses tokens não podem ser usados ​​para calibrar.', + calibrateFailed: 'Esses tokens não podem ser usados para calibrar.', unexpected: 'Algo deu errado: {message}', }, hints: { @@ -8170,7 +8175,7 @@ const HexplorationMod = (() => { emptyArea: 'Desenhe uma forma maior ou verifique as configurações da grade da página.', tooMany: 'Preencha uma área menor ou divida a área em várias formas.', noHexes: - 'Os hexágonos estão no primeiro plano ou na camada de token; mude para essa camada para selecioná-los.', + 'Os hexágonos estão na camada de primeiro plano ou na camada de tokens; mude para essa camada para selecioná-los.', unknownCommand: 'Digite !hexploration help para listar os comandos.', unknownSetting: 'Digite !hexploration set para ver todas as configurações.', calibrateNeedsTokens: @@ -8183,11 +8188,11 @@ const HexplorationMod = (() => { menu: 'Mostrar o menu.', fill: 'Cubra as formas desenhadas selecionadas com hexágonos.', fillInverse: 'Cubra a página inteira, exceto dentro das formas selecionadas.', - undo: 'Desfaça o último preenchimento, inverta o preenchimento ou oculte e restaure as formas usadas.', + undo: 'Desfaça o último preenchimento, preenchimento inverso ou ocultação e restaure as formas que ele usou.', reveal: - 'Revele os hexágonos selecionados e os hexágonos sob as formas e fichas selecionadas.', + 'Revele os hexágonos selecionados e os hexágonos sob as formas e tokens selecionados.', revealPage: 'Revele cada hexágono da página sem anúncios.', - conceal: 'Cubra a área sob as formas e fichas selecionadas com hexágonos novamente.', + conceal: 'Cubra novamente com hexágonos a área sob as formas e tokens selecionados.', explore: 'Revele ao redor dos tokens selecionados como se eles tivessem acabado de se mover para lá.', resetPage: 'Remova todos os hexágonos da página (pergunta antes).', @@ -8215,7 +8220,7 @@ const HexplorationMod = (() => { locationsDesc: 'Selecione tokens para ocultá-los como locais sob hexágonos. Selecione hexágonos ou tokens para nomear um hexágono.', toolsDesc: - 'Configurações, substituições de páginas, status, nova digitalização de páginas copiadas e calibração da grade.', + 'Configurações, substituições de páginas, status, reescaneamento de páginas copiadas e calibração da grade.', footer: 'Consulte o folheto "{help}" para obter instruções completas.', }, handout: { @@ -8257,11 +8262,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Hexes e locais nomeados', + heading: 'Hexágonos nomeados e locais', points: [ 'Marcar local transforma os tokens selecionados em locais ocultos. Um token que já esteja sob um hexágono é ocultado imediatamente; caso contrário, ele será ocultado pelo próximo preenchimento que o cobrir.', 'Os tokens com o marcador de status da torre branca também são tratados como locais quando você preenche, como na versão 1.', - 'As fichas de localização oculta são movidas para a camada GM. Quando seu hexágono é revelado, eles retornam à camada de token com seu nome mostrado e sua descoberta é anunciada.', + 'Os tokens de local ocultos são movidos para a camada do GM. Quando seu hexágono é revelado, eles retornam à camada de tokens com seu nome à mostra e sua descoberta é anunciada.', 'Nomear hexágono dá um nome a um hexágono sem precisar de um token. O nome é mostrado ao GM como um rótulo na camada do GM e anunciado quando o hexágono é revelado. O Jumpgate desenha a camada do GM abaixo da camada de primeiro plano, então no Jumpgate os rótulos só aparecem quando a opção Camada dos hexágonos está definida como camada de tokens.', 'Anunciar descobertas escolhe se todos, apenas o GM ou ninguém verá o anúncio. Pingar descobertas também move a visão dos jogadores para o local.', ], @@ -8276,7 +8281,7 @@ const HexplorationMod = (() => { perPage: '(Pode ser definido por página.)', }, jumpgate: { - heading: 'Jumpgate e Legado', + heading: 'Jumpgate e Legacy', points: [ 'Hexploration descobre qual motor o jogo usa e desenha o tipo de forma correspondente. As formas desenhadas em qualquer editor podem ser preenchidas.', 'Com a Camada dos hexágonos definida como Automático, os hexágonos são desenhados na camada de primeiro plano, acima dos tokens, para que os jogadores não possam ver o que está por baixo. Se a camada de primeiro plano não estiver disponível, a camada de tokens é usada no lugar.', @@ -8299,7 +8304,7 @@ const HexplorationMod = (() => { heading: 'Solução de problemas', points: [ 'Nada acontece quando um token se move: verifique se o token está na camada de tokens e corresponde a Tokens que revelam, e se a página possui hexágonos (!hexploration status).', - 'Os hexágonos são deslocados da grade: use Calibrar e verifique com um token alguns hexágonos no mapa.', + 'Os hexágonos estão deslocados em relação à grade: use Calibrar e depois verifique com um token em alguns hexágonos pelo mapa.', 'Os hexágonos pararam de ser revelados após copiar uma página ou jogo: execute Reescanear na página.', 'Preencher diz que a área não tem centros de hexágonos: a forma precisa conter o centro de pelo menos um hexágono.', 'Para qualquer outra coisa, verifique o log do console da API e inclua suas mensagens ao pedir ajuda.', @@ -8308,7 +8313,7 @@ const HexplorationMod = (() => { languages: { heading: 'Idiomas', body: 'Escolha um idioma com !hexploration set language. Idiomas disponíveis:', - colLanguage: 'Linguagem', + colLanguage: 'Idioma', colNative: 'Nome original', colCode: 'Código', }, @@ -8411,12 +8416,12 @@ const HexplorationMod = (() => { desc: 'Язык меню, сообщений и раздаточных материалов.', }, hexLayer: { - label: 'Слой шестиугольников', + label: 'Слой гексов', desc: 'Где рисуются новые гексы. «Авто» пробует слой переднего плана (над токенами), а если игра его не поддерживает, использует слой токенов.', }, fillColor: { label: 'Цвет заливки', - desc: 'Цвет новых гексов. Используйте rgba() для прозрачных шестигранников, например rgba(0,0,0,0.8).', + desc: 'Цвет новых гексов. Используйте rgba() для прозрачных гексов, например rgba(0,0,0,0.8).', }, strokeColor: { label: 'Цвет границы', @@ -8424,7 +8429,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Цвет меток', - desc: 'Цвет меток с именами, предназначенными только для GM, на именованных гексах.', + desc: 'Цвет меток с именами, предназначенными только для ГМ, на именованных гексах.', }, glimpseColor: { label: 'Цвет проблеска', @@ -8432,10 +8437,10 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Ширина границы', - desc: 'Ширина контура новых шестиугольников в пикселях (от 0 до 20).', + desc: 'Ширина контура новых гексов в пикселях (от 0 до 20).', }, maxDistance: { - label: 'Дальность раскрытия шестиугольников', + label: 'Дальность раскрытия гексов', desc: 'Сохраняется в гексах при их заполнении, поэтому задайте значение до заполнения: его последующее изменение не влияет на гексы, уже находящиеся на карте. Жетон должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел; при значении 0 они раскрываются, только когда в них входят. Используйте для гор или лесов. Оставьте пустым, чтобы не было ограничений.', }, revealDistance: { @@ -8444,7 +8449,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Линия видимости', - desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия шестиугольников», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', + desc: 'Когда эта опция включена, гексы, которые остаются закрытыми, например горы, заполненные с параметром «Дальность раскрытия гексов», скрывают гексы за ними. Это имеет значение, только если «Расстояние обзора» равно 2 или больше.', }, revealPath: { label: 'Раскрывать вдоль пути', @@ -8464,11 +8469,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Пинговать находки', - desc: 'Если эта функция включена, игроки отправляются в указанное место при его обнаружении.', + desc: 'Если эта функция включена, при обнаружении именованной локации вид игроков переводится на неё.', }, hideCoveredTokens: { label: 'Скрывать токены под гексами', - desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, жетоны под закрытым гексом имеют видимое для игрока имя, полосы и ауры отключаются и снова включаются, когда они открываются.', + desc: 'Roll20 рисует имена, полосы и ауры над гексами. Когда эта функция включена, у токенов под закрытым гексом отключаются видимые игрокам имя, полосы и ауры, а когда токены открываются, они снова включаются.', }, }, status: { @@ -8491,21 +8496,21 @@ const HexplorationMod = (() => { revealedPage: 'Все гексы на странице открыты ({count}).', confirmReset: 'Удалить все гексы со страницы "{page}" ({count})? Токены локаций вернутся на слой токенов. Отменить это действие будет нельзя.', - resetPage: 'Со страницы удалены шестигранники: {count}.', + resetPage: 'Со страницы удалены гексы: {count}.', undone: - 'Последнее заполнение отменено. Удалены шестигранники: {removed}. Восстановлены измененные гексы: {restored}.', - named: 'Шестигранники с именем "{name}": {count}.', + 'Последнее заполнение отменено. Удалены гексы: {removed}. Восстановлены измененные гексы: {restored}.', + named: 'Гексы с именем "{name}": {count}.', unnamed: 'Имена удалены: {count}.', marked: 'Местоположение, скрытое в существующих гексах: {attached}. Ожидание следующей заливки, которая их закроет: {pending}.', unmarked: 'Токены, которые больше не являются локациями: {count}.', settingChanged: 'Для {setting} установлено значение {value}.', rescanned: - 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Повторно отправлено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', + 'Повторное сканирование завершено. Сохранено: {kept}. Принято: {adopted}. Перенесено: {moved}. Пропало и забыто: {dropped}. Ярлыки повторно связаны: {labels}. Токены местоположения повторно связаны: {icons}.', calibrated: - 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Сетка откалибрована (шаг столбца {colStep}px, шаг строки {rowStep}px). Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', calibrationReset: - 'Калибровка удалена. Повторное сканирование: сохранено {kept}, повторно сохранено {moved}, принято {adopted}.', + 'Калибровка удалена. Повторное сканирование: сохранено {kept}, перенесено {moved}, принято {adopted}.', journalRebuilt: 'Раздаточные материалы «{help}» и «{deck}» были перестроены.', migrated: 'Ваши гексовые карты Hexploration 1.x обновлены. Если эта игра скопирована из игры Legacy, выполните «Пересканировать» на каждой странице с гексовой картой.', @@ -8516,19 +8521,18 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Эта игра не поддерживает рисование на слое переднего плана, поэтому шестигранники рисовались на слое жетонов.', + 'Эта игра не поддерживает рисование на слое переднего плана, поэтому гексы рисовались на слое жетонов.', someFailed: 'Гексы, которые не удалось нарисовать: {count}. Подробности проверьте в консоли API.', }, errors: { noPage: 'Не удалось найти страницу для работы.', - notHex: 'На этой странице не используется шестигранная сетка.', + notHex: 'На этой странице не используется гексовая сетка.', noPolygons: 'Выберите одну или несколько нарисованных фигур для заливки.', - emptyArea: 'Выбранная область не содержит шестигранных центров.', - tooMany: 'Это создаст слишком много шестигранников за один раз ({count}).', + emptyArea: 'Выбранная область не содержит центров гексов.', + tooMany: 'Это создаст слишком много гексов за один раз ({count}).', nothingToConceal: 'Выберите нарисованные фигуры или жетоны, которые нужно скрыть.', - nothingToReveal: - 'Выбирайте шестигранники, нарисованные фигуры или жетоны, чтобы их показать.', + nothingToReveal: 'Выберите гексы, нарисованные фигуры или жетоны, чтобы их показать.', noTokens: 'Сначала выберите один или несколько жетонов.', noHexes: 'Сначала выберите один или несколько гексов (или жетоны, стоящие на гексах).', nothingToUndo: 'Нет заливки, которую можно было бы отменить.', @@ -8536,7 +8540,7 @@ const HexplorationMod = (() => { unknownSetting: 'Неизвестная настройка: {key}.', unknownPageSetting: 'Настройки, которые можно установить для каждой страницы: {keys}.', invalidValue: '«{value}» не является допустимым значением для {key}.', - calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к шестигранным центрам.', + calibrateNeedsTokens: 'Выберите один или два жетона, привязанных к центрам гексов.', calibrateFailed: 'Эти жетоны нельзя использовать для калибровки.', unexpected: 'Что-то пошло не так: {message}', }, @@ -8548,7 +8552,7 @@ const HexplorationMod = (() => { emptyArea: 'Нарисуйте фигуру большего размера или проверьте настройки сетки страницы.', tooMany: 'Заполните меньшую область или разделите ее на несколько фигур.', noHexes: - 'Шестигранники находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', + 'Гексы находятся на переднем плане или на слое жетонов; переключитесь на этот слой, чтобы выбрать их.', unknownCommand: 'Введите !hexploration help, чтобы просмотреть список команд.', unknownSetting: 'Введите !hexploration set, чтобы увидеть все настройки.', calibrateNeedsTokens: @@ -8559,23 +8563,24 @@ const HexplorationMod = (() => { }, help: { menu: 'Покажите меню.', - fill: 'Покройте выбранные нарисованные фигуры шестигранниками.', + fill: 'Покройте выбранные нарисованные фигуры гексами.', fillInverse: 'Закройте всю страницу, кроме выбранных фигур.', - undo: 'Отмените последнюю заливку, инвертируйте заливку или скройте и восстановите использованные фигуры.', + undo: 'Отмените последнюю заливку, обратную заливку или скрытие и восстановите использованные фигуры.', reveal: 'Покажите выбранные гексы, а также гексы под выбранными фигурами и жетонами.', revealPage: 'Раскройте каждый гекс на странице без объявлений.', - conceal: 'Снова покройте область под выбранными фигурами и жетонами шестигранниками.', - explore: 'Раскройте выбранные жетоны, как будто они только что туда переместились.', + conceal: 'Снова покройте область под выбранными фигурами и жетонами гексами.', + explore: + 'Раскройте гексы вокруг выбранных жетонов, как будто они только что туда переместились.', resetPage: 'Удалите все гексы на странице (сначала запрашивает подтверждение).', name: 'Назовите выбранные гексы или гексы под выбранными жетонами. Оставьте имя пустым, чтобы очистить его.', mark: 'Превратите выбранные жетоны в скрытые локации.', unmark: 'Препятствовать тому, чтобы выбранные токены были скрытыми местами.', set: 'Измените настройку или отобразите все настройки.', - pageSet: 'Переопределить настройку отображения только на текущей странице.', + pageSet: 'Переопределить настройку раскрытия только на текущей странице.', pageClear: 'Удалить переопределения текущей страницы.', rescan: 'Перестройте список гексов страницы, например после копирования страницы или игры.', calibrate: - 'Выровняйте шестигранную сетку с помощью одного или двух выбранных жетонов, привязанных к шестигранным центрам.', + 'Выровняйте гексовую сетку с помощью одного или двух выбранных жетонов, привязанных к центрам гексов.', calibrateReset: 'Удалить калибровку текущей страницы.', status: 'Покажите, что Hexploration знает о текущей странице.', journal: 'Пересоздайте раздаточные материалы «Помощь» и «Command Deck».', @@ -8615,7 +8620,7 @@ const HexplorationMod = (() => { commands: { heading: 'Команды', intro: - 'Только GM могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', + 'Только ГМ могут использовать эти команды. Большинство действует на выбранные объекты; остальные действуют на просматриваемой вами странице.', colCommand: 'Команда', colDesc: 'Что он делает', }, @@ -8624,8 +8629,8 @@ const HexplorationMod = (() => { points: [ 'Гексы раскрывают только токены на слое токенов. Какие именно, задаёт настройка «Раскрывающие токены»: по умолчанию это токены игроков, поэтому ГМ может перемещать монстров, не открывая карту.', 'Токен раскрывает каждый гекс, который он занимает (большие токены занимают несколько), а при включённой настройке «Раскрывать вдоль пути» — и каждый гекс на маршруте, по которому его перетаскивали, включая промежуточные точки.', - '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия шестиугольников».', - '«Дальность раскрытия шестиугольников» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия шестиугольников» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', + '«Расстояние обзора» раскрывает гексы вокруг каждого из этих гексов, начиная с ближайших. Когда «Линия видимости» включена, гекс не раскрывается, пока между ним и токеном лежит закрытый гекс. Ближние гексы обычно раскрываются первыми, поэтому на открытой местности «Линия видимости» ничего не меняет: она важна, только если «Расстояние обзора» равно 2 или больше и есть гексы, которые остаются закрытыми, например местность, заполненная с параметром «Дальность раскрытия гексов».', + '«Дальность раскрытия гексов» сохраняется в каждом гексе при его заполнении, поэтому задайте её до заполнения; последующее изменение не влияет на гексы, уже находящиеся на карте. Токен должен находиться в пределах этого количества гексов, чтобы раскрыть их, как бы далеко он ни видел, а при значении 0 они раскрываются, только когда в них входят. Для горного хребта: установите «Дальность раскрытия гексов» на 0, заполните горы, снова очистите значение (без ограничений), затем заполните земли за ними. Если «Расстояние обзора» равно 3, а «Линия видимости» включена, отряд видит открытую местность вокруг себя, но не горы и не то, что лежит за ними. Каждый горный гекс раскрывается, когда в него входит токен.', 'В режиме «Проблеск» гексы в пределах видимости не исчезают, а становятся полупрозрачными и удаляются, когда в них входит токен. Гексы, видимые в режиме «Проблеск», не загораживают обзор для параметра «Линия видимости».', 'Roll20 рисует имена, полоски и ауры токенов поверх гексов. При включённой настройке «Скрывать токены под гексами» у токена под закрытым гексом отключаются видимые игрокам имя, полоски и ауры, пока его не откроют, так что спрятанные монстры не выдают себя. Если включить что-то из этого, пока токен закрыт, оно останется скрытым и включится, когда токен откроется.', 'API не сообщает о перемещениях, сделанных другими модами. Перемещения TokenMod подхватываются автоматически; для других модов выделите токены и нажмите «Исследовать» или вызовите Hexploration.revealAround(token) из своего мода.', @@ -8636,25 +8641,25 @@ const HexplorationMod = (() => { points: [ '«Отметить локацию» превращает выбранные токены в скрытые локации. Токен, уже находящийся под гексом, прячется сразу; иначе его спрячет следующая заливка, которая его накроет.', 'Жетоны с маркером статуса белой башни также считаются локациями при заполнении, как и в версии 1.', - 'Жетоны скрытых локаций перемещаются на уровень GM. Когда их гекс раскрывается, они возвращаются на слой жетонов с указанием своего имени, и об их открытии объявляется.', - '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой шестиугольников» выбран слой токенов.', + 'Жетоны скрытых локаций перемещаются на слой ГМ. Когда их гекс раскрывается, они возвращаются на слой жетонов с показанным именем, и об их обнаружении объявляется.', + '«Назвать гекс» даёт гексу имя без токена. Имя показывается ГМу в виде метки на слое ГМ и объявляется, когда гекс открывается. Jumpgate рисует слой ГМ под слоем переднего плана, поэтому в Jumpgate метки видны, только если для параметра «Слой гексов» выбран слой токенов.', '«Объявлять об открытиях» определяет, увидят ли объявление все, только ГМ или никто. «Пинговать находки» также переводит взгляд игроков на локацию.', ], }, settings: { heading: 'Настройки', intro: - 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой шестиугольников», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', + 'Меняйте настройки командой !hexploration set (или кнопкой «Настройки»). «Слой гексов», «Раскрывающие токены» и «Язык» также можно задать на странице настроек мода.', colKey: 'Ключ', colName: 'Параметр', colDesc: 'Описание', perPage: '(Можно установить для каждой страницы.)', }, jumpgate: { - heading: 'Джампгейт и Наследие', + heading: 'Jumpgate и Legacy', points: [ 'Hexploration определяет, какой движок используется в игре, и рисует соответствующую форму. Фигуры, нарисованные в любом редакторе, можно закрашивать.', - 'Если для «Слоя шестиугольников» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', + 'Если для «Слоя гексов» выбрано «Авто», гексы рисуются на слое переднего плана, над токенами, так что игроки не видят, что под ними. Если слой переднего плана недоступен, используется слой токенов.', 'Jumpgate рисует математически правильные гексы, форма которых немного отличается от гексов Legacy. Если гексы не совпадают с сеткой страницы, привяжите токен к центру гекса, выделите его и нажмите «Калибровать». Чтобы заодно исправить размер гекса, выделите два токена в соседних гексах одной строки (Hex V) или одного столбца (Hex H).', 'При копировании страницы или игры её гексы получают новые идентификаторы. Выполните «Пересканировать» на странице, чтобы снова найти их вместе с метками названий и токенами локаций.', ], @@ -8688,7 +8693,7 @@ const HexplorationMod = (() => { colCode: 'Код', }, credits: { - heading: 'Кредиты', + heading: 'Авторы', original: 'Оригинальный мод от', maintainer: 'Версия 2 поддерживается', marketplace: 'Наборы произведений искусства Ады на торговой площадке Roll20', @@ -8799,7 +8804,7 @@ const HexplorationMod = (() => { }, labelColor: { label: 'Color de la etiqueta', - desc: 'Color de las etiquetas de nombres exclusivos para GM en hexágonos con nombre.', + desc: 'Color de las etiquetas de nombre, visibles solo para el DJ, en los hexágonos con nombre.', }, glimpseColor: { label: 'Color de vistazo', @@ -8843,7 +8848,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Ocultar fichas cubiertas', - desc: 'Roll20 dibuja nombres, barras y auras sobre hexágonos. Cuando están activadas, las fichas bajo un hexágono cubierto tienen su nombre, barras y auras visibles para el jugador desactivadas y se vuelven a activar cuando se descubren.', + desc: 'Roll20 dibuja nombres, barras y auras sobre los hexágonos. Cuando está activado, las fichas bajo un hexágono cubierto tienen desactivados su nombre, barras y auras visibles para los jugadores, que se vuelven a activar cuando se descubren.', }, }, status: { @@ -8865,22 +8870,22 @@ const HexplorationMod = (() => { revealed: 'Hexágonos revelados: {count}.', revealedPage: 'Cada hexágono en la página revelado ({count}).', confirmReset: - '¿Eliminar todos los hexágonos de "{page}" ({count})? Los tokens de ubicación regresan a la capa de tokens. Deshacer no puede revertir esto.', - resetPage: 'Hexes eliminados de la página: {count}.', + '¿Eliminar todos los hexágonos de "{page}" ({count})? Las fichas de ubicación regresan a la capa de fichas. Deshacer no puede revertir esto.', + resetPage: 'Hexágonos eliminados de la página: {count}.', undone: 'Último relleno deshecho. Hexágonos eliminados: {removed}. Hexágonos rediseñados restaurados: {restored}.', named: 'Hexágonos denominados "{name}": {count}.', unnamed: 'Nombres borrados: {count}.', marked: 'Ubicaciones ocultas en hexágonos existentes: {attached}. Esperando el siguiente relleno que los cubra: {pending}.', - unmarked: 'Tokens que ya no son ubicaciones: {count}.', + unmarked: 'Fichas que ya no son ubicaciones: {count}.', settingChanged: '{setting} establecido en {value}.', rescanned: - 'Volver a escanear completo. Mantenido: {kept}. Adoptado: {adopted}. Representado nuevamente: {moved}. Desaparecido y olvidado: {dropped}. Etiquetas vinculadas nuevamente: {labels}. Tokens de ubicación vueltos a vincular: {icons}.', + 'Nuevo escaneo completado. Conservados: {kept}. Adoptados: {adopted}. Reubicados: {moved}. Desaparecidos y olvidados: {dropped}. Etiquetas vinculadas de nuevo: {labels}. Fichas de ubicación vinculadas de nuevo: {icons}.', calibrated: - 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Cuadrícula calibrada (paso de columna {colStep}px, paso de fila {rowStep}px). Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', calibrationReset: - 'Se eliminó la calibración. Volver a escanear: mantuvo {kept}, volvió a presentar {moved}, adoptó {adopted}.', + 'Se eliminó la calibración. Nuevo escaneo: conservados {kept}, reubicados {moved}, adoptados {adopted}.', journalRebuilt: 'Se han reconstruido los folletos "{help}" y "{deck}".', migrated: 'Tus mapas de hexágonos de Hexploration 1.x se han actualizado. Si este juego se copió de un juego Legacy, ejecuta Volver a escanear en cada página con mapa de hexágonos.', @@ -8903,7 +8908,7 @@ const HexplorationMod = (() => { tooMany: 'Eso crearía demasiados hexágonos de una sola vez ({count}).', nothingToConceal: 'Seleccione formas dibujadas o fichas para ocultar.', nothingToReveal: 'Selecciona hexágonos, formas dibujadas o fichas para revelar.', - noTokens: 'Seleccione uno o más tokens primero.', + noTokens: 'Seleccione una o más fichas primero.', noHexes: 'Selecciona uno o más hexágonos (o fichas que se encuentren en hexágonos) primero.', nothingToUndo: 'No hay ningún relleno que deshacer.', unknownCommand: 'Comando desconocido: {command}', @@ -8928,33 +8933,33 @@ const HexplorationMod = (() => { unknownCommand: 'Escriba !hexploration help para enumerar los comandos.', unknownSetting: 'Escriba !hexploration set para ver todas las configuraciones.', calibrateNeedsTokens: - 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hex.', + 'Coloca una ficha en el centro de un hexágono y selecciónala. Seleccione una segunda ficha colocada en un hexágono vecino en la misma fila (Hex V) o columna (Hex H) para corregir también el tamaño del hexágono.', calibrateFailed: - 'Dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hex.', + 'Las dos fichas deben estar en la misma fila (Hex V) o en la misma columna (Hex H), separadas por al menos un hexágono.', unexpected: 'Los detalles se encuentran en el registro de la consola API.', }, help: { menu: 'Mostrar el menú.', fill: 'Cubre las formas dibujadas seleccionadas con hexágonos.', fillInverse: 'Cubre toda la página excepto el interior de las formas seleccionadas.', - undo: 'Deshaga el último relleno, invierta el relleno u oculte y restaure las formas que utilizó.', + undo: 'Deshace el último relleno, relleno inverso u ocultación, y restaura las formas que usó.', reveal: 'Revela los hexágonos seleccionados y los hexágonos debajo de las formas y fichas seleccionadas.', revealPage: 'Revela cada hexágono de la página sin anuncios.', conceal: 'Cubre el área debajo de las formas y fichas seleccionadas con hexágonos nuevamente.', - explore: 'Muestra las fichas seleccionadas como si acabaran de mudarse allí.', + explore: 'Revela alrededor de las fichas seleccionadas como si acabaran de moverse allí.', resetPage: 'Elimina todos los hexágonos de la página (pregunta primero).', name: 'Nombra los hexágonos seleccionados, o los hexágonos debajo de las fichas seleccionadas. Deje el nombre vacío para borrarlo.', mark: 'Convierte las fichas seleccionadas en ubicaciones ocultas.', - unmark: 'Evite que los tokens seleccionados sean ubicaciones ocultas.', + unmark: 'Hace que las fichas seleccionadas dejen de ser ubicaciones ocultas.', set: 'Cambie una configuración o muestre todas las configuraciones.', pageSet: 'Anula una configuración de revelación solo en la página actual.', pageClear: 'Elimine las anulaciones de la página actual.', rescan: 'Reconstruye la lista de hexágonos de la página, por ejemplo, después de copiar una página o un juego.', calibrate: - 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas encajadas en los centros hexagonales.', + 'Alinea la cuadrícula hexagonal con una o dos fichas seleccionadas ajustadas a los centros de los hexágonos.', calibrateReset: 'Elimina la calibración de la página actual.', status: 'Muestra lo que Hexploration sabe sobre la página actual.', journal: 'Reconstruye los folletos de Ayuda y del Command Deck.', @@ -8978,7 +8983,7 @@ const HexplorationMod = (() => { footer: 'Utilice el folleto "{deck}" para obtener controles con un solo clic.', overview: { heading: 'Descripción general', - body: 'La hexploración cubre un mapa de hexágonos con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', + body: 'Hexploration cubre un mapa hexagonal con hexágonos opacos. A medida que el grupo se mueve, los hexágonos por los que pasa (y, si lo desea, los hexágonos que los rodean) se eliminan, por lo que el mapa se descubre un hexágono a la vez. Las ubicaciones ocultas se pueden colocar debajo de hexágonos y se anuncian cuando se encuentran. Funciona en juegos Jumpgate y Legacy, en cuadrículas Hex (V) y Hex (H) de cualquier tamaño.', demo: 'Vea una breve demostración (de la versión 1)', }, quickStart: { @@ -8987,22 +8992,22 @@ const HexplorationMod = (() => { 'Abra una página cuya cuadrícula esté configurada en Hex (V) o Hex (H).', 'Dibuja una o más formas (polígono, rectángulo, elipse o a mano alzada) alrededor del área a ocultar.', 'Seleccione las formas y haga clic en Rellenar en el Command Deck (o escriba !hexploration fill). Las formas se sustituyen por hexágonos.', - 'Opcional: antes de completar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Están ocultos debajo de los hexágonos y se anuncian cuando se descubren.', + 'Opcional: antes de rellenar, seleccione fichas para lugares importantes y haga clic en Marcar ubicación. Quedan ocultas debajo de los hexágonos y se anuncian cuando se descubren.', 'Mueve una ficha de jugador. Se revelan cada hexágono por el que pasa y los hexágonos dentro de su distancia de visión.', ], }, commands: { heading: 'Comandos', intro: - 'Sólo los GM pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', - colCommand: 'Dominio', - colDesc: 'que hace', + 'Solo los DJ pueden usar estos comandos. La mayoría actúa sobre los objetos seleccionados; el resto actúa sobre la página que estás viendo.', + colCommand: 'Comando', + colDesc: 'Qué hace', }, revealing: { heading: 'Cómo funciona la revelación', points: [ 'Solo las fichas de la capa de fichas revelan hexágonos. Qué fichas cuentan se define con Fichas que revelan: por defecto, las fichas de jugador, para que el DJ pueda mover monstruos sin descubrir el mapa.', - 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrado, incluidos los puntos de ruta.', + 'Una ficha revela cada hexágono que cubre (las fichas grandes cubren varios) y, con Revelar a lo largo del camino activado, cada hexágono de la ruta por la que fue arrastrada, incluidos los puntos de ruta.', 'La Distancia de visión revela los hexágonos alrededor de cada uno de esos hexágonos, empezando por los más cercanos. Con la Línea de visión activada, un hexágono no se revela mientras haya un hexágono cubierto entre él y la ficha. Los hexágonos más cercanos suelen revelarse primero, así que en terreno abierto la Línea de visión no cambia nada: sólo importa con una Distancia de visión de 2 o más y hexágonos que siguen cubiertos, como el terreno rellenado con una Distancia de revelación de hexágonos.', 'La Distancia de revelación de hexágonos se guarda en cada hexágono cuando se rellena, así que configúrela antes de rellenar; cambiarla después no afecta a los hexágonos que ya están en el mapa. Una ficha debe estar a esa cantidad de hexágonos como máximo para revelarlos, por muy lejos que pueda ver, y con 0 sólo se revelan al entrar en ellos. Para una cordillera: ponga la Distancia de revelación de hexágonos en 0, rellene las montañas, vuelva a dejarla sin límite y después rellene las tierras que hay más allá. Con una Distancia de visión de 3 y la Línea de visión activada, el grupo ve el terreno abierto a su alrededor, pero no las montañas ni lo que hay detrás de ellas. Cada hexágono de montaña se revela cuando una ficha entra en él.', 'En el modo Vistazo, los hexágonos a la vista se vuelven transparentes en lugar de desaparecer, y se eliminan cuando una ficha entra en ellos. Los hexágonos transparentes del modo Vistazo no bloquean la Línea de visión.', @@ -9014,8 +9019,8 @@ const HexplorationMod = (() => { heading: 'Hexágonos y ubicaciones con nombre', points: [ 'Marcar ubicación convierte las fichas seleccionadas en ubicaciones ocultas. Una ficha que ya está bajo un hexágono se oculta de inmediato; si no, la oculta el siguiente relleno que la cubra.', - 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando las llenas, como en la versión 1.', - 'Las fichas de ubicación oculta se mueven a la capa de GM. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', + 'Las fichas con el marcador de estado de la torre blanca también se tratan como ubicaciones cuando rellenas, como en la versión 1.', + 'Las fichas de ubicación oculta se mueven a la capa del DJ. Cuando se revela su hexágono, regresan a la capa de fichas con su nombre mostrado y se anuncia su descubrimiento.', 'Nombrar hexágono da un nombre a un hexágono sin usar ninguna ficha. El nombre se muestra al DJ como una etiqueta en la capa del DJ y se anuncia cuando se revela el hexágono. Jumpgate dibuja la capa del DJ por debajo de la capa de primer plano, así que en Jumpgate las etiquetas solo se ven cuando Capa de hexágonos está configurada en la capa de fichas.', 'Anunciar descubrimientos elige si ven el anuncio todos, solo el DJ o nadie. Hacer ping a los descubrimientos también mueve la vista de los jugadores a la ubicación.', ], @@ -9024,13 +9029,13 @@ const HexplorationMod = (() => { heading: 'Ajustes', intro: 'Cambie la configuración con !hexploration set (o el botón Configuración). Capa de hexágonos, Fichas que revelan e Idioma también se pueden configurar en la página de configuración del mod.', - colKey: 'Llave', + colKey: 'Clave', colName: 'Configuración', colDesc: 'Descripción', perPage: '(Se puede configurar por página).', }, jumpgate: { - heading: 'Jumpgate y legado', + heading: 'Jumpgate y Legacy', points: [ 'Hexploration determina qué motor utiliza el juego y dibuja el tipo de forma correspondiente. Las formas dibujadas en cualquiera de los editores se pueden rellenar.', 'Con Capa de hexágonos en Auto, los hexágonos se dibujan en la capa de primer plano, encima de las fichas, para que los jugadores no puedan ver lo que hay debajo. Si la capa de primer plano no está disponible, se usa la capa de fichas.', @@ -9166,7 +9171,7 @@ const HexplorationMod = (() => { }, hexLayer: { label: 'Lager för hexar', - desc: 'Där nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', + desc: 'Var nya hexar ritas. Auto provar förgrundslagret (ovanför tokens) och faller tillbaka till tokenlagret om spelet inte stöder det.', }, fillColor: { label: 'Fyllningsfärg', @@ -9174,11 +9179,11 @@ const HexplorationMod = (() => { }, strokeColor: { label: 'Kantfärg', - desc: 'Färg på konturerna av nya sexkanter.', + desc: 'Färg på konturerna av nya hexar.', }, labelColor: { label: 'Etikettfärg', - desc: 'Färgen på namnetiketterna endast för GM på namngivna sexkanter.', + desc: 'Färgen på namnetiketterna endast för GM på namngivna hexar.', }, glimpseColor: { label: 'Glimtfärg', @@ -9186,7 +9191,7 @@ const HexplorationMod = (() => { }, strokeWidth: { label: 'Kantbredd', - desc: 'Bredden på konturerna av nya hex, i pixlar (0 till 20).', + desc: 'Bredden på konturerna av nya hexar, i pixlar (0 till 20).', }, maxDistance: { label: 'Avslöjandeavstånd för hexar', @@ -9202,11 +9207,11 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Avslöja längs vägen', - desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive waypoints), inte bara där den stannar.', + desc: 'När den är på avslöjas varje hex som en token passerar genom medan den dras (inklusive mellanpunkter), inte bara där den stannar.', }, revealBy: { label: 'Tokens som avslöjar', - desc: 'Vilka tokens på tokenlagret avslöjar hexes: tokens som kontrolleras av en spelare, tokens som representerar vilken karaktär som helst eller varje token.', + desc: 'Vilka tokens på tokenlagret som avslöjar hexar: tokens som kontrolleras av en spelare, tokens som representerar vilken rollperson som helst eller alla tokens.', }, revealMode: { label: 'Avslöjandeläge', @@ -9222,7 +9227,7 @@ const HexplorationMod = (() => { }, hideCoveredTokens: { label: 'Dölj täckta tokens', - desc: 'Roll20 ritar namn, staplar och auror ovanför hexen. När de är på, har tokens under en täckt sexkant sitt spelare-synliga namn, staplar och auror avstängda och påslagna igen när de avslöjas.', + desc: 'Roll20 ritar namn, staplar och auror ovanför hexarna. När den är på stängs det namn, de staplar och de auror som spelarna kan se av för tokens under en täckt hex, och slås på igen när de avtäcks.', }, }, status: { @@ -9239,26 +9244,27 @@ const HexplorationMod = (() => { undo: 'Ångra tillgängligt', }, messages: { - filled: 'Fyllning klar. Hex ritade: {created}. Omstylad: {restyled}. Gömda platser: {icons}.', - revealed: 'Hexen avslöjade: {count}.', - revealedPage: 'Varje hex på sidan avslöjas ({count}).', + filled: + 'Fyllning klar. Ritade hexar: {created}. Omformaterade: {restyled}. Gömda platser: {icons}.', + revealed: 'Avslöjade hexar: {count}.', + revealedPage: 'Alla hexar på sidan avslöjade ({count}).', confirmReset: - 'Ta bort varje hex från "{page}" ({count})? Platssymboler återgår till tokenlagret. Ångra kan inte ångra detta.', - resetPage: 'Hexen har tagits bort från sidan: {count}.', + 'Ta bort alla hexar från "{page}" ({count})? Platstokens återgår till tokenlagret. Ångra kan inte ångra detta.', + resetPage: 'Hexar som tagits bort från sidan: {count}.', undone: - 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omstylade hexar som återställts: {restored}.', - named: 'Hex med namnet "{name}": {count}.', + 'Senaste fyllningen ångrad. Borttagna hexar: {removed}. Omformaterade hexar som återställts: {restored}.', + named: 'Hexar med namnet "{name}": {count}.', unnamed: 'Namn raderade: {count}.', marked: 'Platser dolda i befintliga hexar: {attached}. Väntar på nästa fyllning som täcker dem: {pending}.', unmarked: 'Tokens som inte längre är platser: {count}.', settingChanged: '{setting} inställd på {value}.', rescanned: - 'Omsökningen är klar. Sparade: {kept}. Antagen: {adopted}. Återarkiverad: {moved}. Saknas och glöms: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', + 'Omsökningen är klar. Behållna: {kept}. Övertagna: {adopted}. Omplacerade: {moved}. Saknade och glömda: {dropped}. Etiketter återlänkade: {labels}. Platstokens återlänkade: {icons}.', calibrated: - 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Rutnät kalibrerat (kolumnsteg {colStep}px, radsteg {rowStep}px). Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', calibrationReset: - 'Kalibrering har tagits bort. Skanna om: behöll {kept}, arkiverade på nytt {moved}, antog {adopted}.', + 'Kalibrering har tagits bort. Skanna om: behöll {kept}, omplacerade {moved}, tog över {adopted}.', journalRebuilt: '"{help}" och "{deck}" har byggts om.', migrated: 'Dina hexkartor från Hexploration 1.x har uppgraderats. Om det här spelet kopierades från ett Legacy-spel kör du Skanna igen på varje sida med en hexkarta.', @@ -9269,25 +9275,25 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Det här spelet stöder inte ritning på förgrundslagret, så hexadecken ritades på tokenlagret.', - someFailed: 'Hex som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', + 'Det här spelet stöder inte ritning på förgrundslagret, så hexarna ritades på tokenlagret.', + someFailed: 'Hexar som inte kunde ritas: {count}. Kontrollera API-konsolen för detaljer.', }, errors: { noPage: 'Kunde inte hitta sidan att arbeta på.', notHex: 'Den här sidan använder inte ett hex-rutnät.', noPolygons: 'Välj en eller flera ritade former att fylla.', - emptyArea: 'Det valda området innehåller inga hexa-center.', + emptyArea: 'Det valda området innehåller inga hexmittpunkter.', tooMany: 'Det skulle skapa för många hexar på en gång ({count}).', nothingToConceal: 'Välj ritade former eller tokens att dölja.', - nothingToReveal: 'Välj hex, ritade former eller polletter att avslöja.', + nothingToReveal: 'Välj hexar, ritade former eller tokens att avslöja.', noTokens: 'Välj först en eller flera tokens.', - noHexes: 'Välj en eller flera hexes (eller polletter som står på hexes) först.', + noHexes: 'Välj en eller flera hexar (eller tokens som står på hexar) först.', nothingToUndo: 'Det finns ingen fyllning att ångra.', unknownCommand: 'Okänt kommando: {command}', unknownSetting: 'Okänd inställning: {key}', unknownPageSetting: 'Inställningar som kan ställas in per sida: {keys}', invalidValue: '"{value}" är inte ett giltigt värde för {key}.', - calibrateNeedsTokens: 'Välj en eller två polletter som knäpps till hexade centra.', + calibrateNeedsTokens: 'Välj en eller två tokens som är fästa i hexmittpunkter.', calibrateFailed: 'Dessa tokens kan inte användas för att kalibrera.', unexpected: 'Något gick fel: {message}', }, @@ -9298,7 +9304,8 @@ const HexplorationMod = (() => { 'Rita en polygon, rektangel, ellips eller frihandsform runt området, markera det och försök sedan igen.', emptyArea: 'Rita en större form eller kontrollera inställningarna för sidrutnätet.', tooMany: 'Fyll ett mindre område, eller dela området i flera former.', - noHexes: 'Hex är på förgrunden eller symbollagret; växla till det lagret för att välja dem.', + noHexes: + 'Hexarna ligger på förgrundslagret eller tokenlagret; växla till det lagret för att välja dem.', unknownCommand: 'Skriv !hexploration help för att lista kommandona.', unknownSetting: 'Skriv !hexploration set för att se alla inställningar.', calibrateNeedsTokens: @@ -9309,15 +9316,15 @@ const HexplorationMod = (() => { }, help: { menu: 'Visa menyn.', - fill: 'Täck de utvalda ritade formerna med hex.', + fill: 'Täck de valda ritade formerna med hexar.', fillInverse: 'Täck hela sidan utom inuti de valda formerna.', - undo: 'Ångra den sista fyllningen, inverterad fyllning eller dölj och återställ formerna den använde.', - reveal: 'Avslöja de valda hexen och hexen under de valda formerna och symbolerna.', - revealPage: 'Avslöja varje hex på sidan utan tillkännagivanden.', - conceal: 'Täck området under de valda formerna och polletterna med hexar igen.', + undo: 'Ångra den senaste fyllningen, omvända fyllningen eller döljningen och återställ formerna den använde.', + reveal: 'Avslöja de valda hexarna och hexarna under de valda formerna och tokens.', + revealPage: 'Avslöja alla hexar på sidan utan tillkännagivanden.', + conceal: 'Täck området under de valda formerna och tokens med hexar igen.', explore: 'Avslöja runt de valda tokens som om de precis hade flyttat dit.', - resetPage: 'Ta bort varje hex på sidan (frågar först).', - name: 'Namnge de valda hexorna, eller hexarna under de valda polletterna. Lämna namnet tomt för att rensa det.', + resetPage: 'Ta bort alla hexar på sidan (frågar först).', + name: 'Namnge de valda hexarna, eller hexarna under de valda tokens. Lämna namnet tomt för att rensa det.', mark: 'Förvandla de valda tokens till dolda platser.', unmark: 'Stoppa de valda tokens från att vara dolda platser.', set: 'Ändra en inställning eller visa alla inställningar.', @@ -9325,7 +9332,8 @@ const HexplorationMod = (() => { pageClear: 'Ta bort den aktuella sidans åsidosättningar.', rescan: 'Bygg om sidans hex-lista, till exempel efter att du kopierat en sida eller ett spel.', - calibrate: 'Rada hex-rutnätet med en eller två utvalda tokens fästa till hex-centrum.', + calibrate: + 'Rikta in hex-rutnätet efter en eller två valda tokens som är fästa i hexmittpunkter.', calibrateReset: 'Ta bort den aktuella sidans kalibrering.', status: 'Visa vad Hexploration vet om den aktuella sidan.', journal: 'Bygg om handouterna Help och Command Deck.', @@ -9338,18 +9346,18 @@ const HexplorationMod = (() => { revealDesc: 'Välj hexar, former eller tokens för att avslöja dem eller täcka dem igen. Utforska avslöjar runt valda tokens som om de hade flyttats dit.', locationsDesc: - 'Välj tokens för att dölja dem som platser under hex. Välj hex eller token för att namnge en hex.', + 'Välj tokens för att dölja dem som platser under hexar. Välj hexar eller tokens för att namnge en hex.', toolsDesc: 'Inställningar, sidöverstyrningar, status, skanna om kopierade sidor och kalibrering av rutnätet.', footer: 'Se "{help}"-handouten för fullständiga instruktioner.', }, handout: { versionLabel: 'Version', - subtitle: 'Hex-by-hex-utforskning för Roll20', + subtitle: 'Utforskning hex för hex i Roll20', footer: 'Använd "{deck}"-handouten för kontroller med ett klick.', overview: { heading: 'Översikt', - body: 'Hexploration täcker en hex-karta med ogenomskinliga hexes. När sällskapet rör sig tas hexen de passerar igenom (och, om du vill, hexen runt dem) bort, så kartan avslöjas en hex i taget. Dolda platser kan placeras under hex och meddelas när de hittas. Det fungerar i Jumpgate och Legacy-spel, på Hex (V) och Hex (H) rutnät av alla storlekar.', + body: 'Hexploration täcker en hexkarta med ogenomskinliga hexar. När sällskapet rör sig tas hexarna det passerar igenom (och, om du vill, hexarna runt det) bort, så att kartan avslöjas en hex i taget. Dolda platser kan placeras under hexar och tillkännages när de hittas. Det fungerar i Jumpgate- och Legacy-spel, på Hex (V)- och Hex (H)-rutnät av alla storlekar.', demo: 'Se en kort demo (från version 1)', }, quickStart: { @@ -9358,7 +9366,7 @@ const HexplorationMod = (() => { 'Öppna en sida vars rutnät är inställt på Hex (V) eller Hex (H).', 'Rita en eller flera former (polygon, rektangel, ellips eller frihand) runt området för att dölja.', 'Markera formerna och klicka på Fyll i Command Deck (eller skriv !hexploration fill). Formerna ersätts av hexar.', - 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De är gömda under hexen och tillkännages när de upptäcks.', + 'Valfritt: innan du fyller, välj tokens för viktiga platser och klicka på Markera plats. De göms under hexarna och tillkännages när de upptäcks.', 'Flytta en spelartoken. Varje hex den passerar, och hexarna inom dess Siktavstånd, avslöjas.', ], }, @@ -9382,11 +9390,11 @@ const HexplorationMod = (() => { ], }, locations: { - heading: 'Namngivna Hex och platser', + heading: 'Namngivna hexar och platser', points: [ 'Markera plats förvandlar de valda tokens till dolda platser. En token redan under en hex döljs direkt; annars döljs den av nästa fyllning som täcker den.', 'Tokens med statusmarkören för det vita tornet behandlas också som platser när du fyller, som i version 1.', - 'Dolda platssymboler flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med deras namn visat, och deras upptäckt tillkännages.', + 'Dolda platstokens flyttas till GM-lagret. När deras hex avslöjas återvänder de till tokenlagret med sitt namn visat, och deras upptäckt tillkännages.', 'Namnge hex ger en hex ett namn utan en token. Namnet visas för GM som en etikett på GM-lagret och tillkännages när hexen avslöjas. Jumpgate ritar GM-lagret under förgrundslagret, så i Jumpgate syns etiketterna bara när Lager för hexar är inställt på tokenlagret.', 'Tillkännage upptäckter väljer om alla, bara GM eller ingen ser tillkännagivandet. Pinga upptäckter flyttar också spelarnas vy till platsen.', ], @@ -9396,7 +9404,7 @@ const HexplorationMod = (() => { intro: 'Ändra inställningar med !hexploration set (eller knappen Inställningar). Lager för hexar, Tokens som avslöjar och Språk kan också ställas in på modens inställningssida.', colKey: 'Nyckel', - colName: 'Miljö', + colName: 'Inställning', colDesc: 'Beskrivning', perPage: '(Kan ställas in per sida.)', }, @@ -9424,7 +9432,7 @@ const HexplorationMod = (() => { heading: 'Felsökning', points: [ 'Ingenting händer när en token flyttas: kontrollera att token ligger på tokenlagret och matchar Tokens som avslöjar, och att sidan har hexar (!hexploration status).', - 'Hexen är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', + 'Hexarna är förskjutna från rutnätet: använd Kalibrera och kontrollera sedan med en token på några hexar över kartan.', 'Hexar slutade avslöjas efter att en sida eller ett spel kopierats: kör Skanna igen på sidan.', 'Fyll säger att området inte innehåller några hexmittpunkter: formen måste innehålla mittpunkten på minst en hex.', 'För allt annat, kontrollera API-konsolloggen och inkludera dess meddelanden när du ber om hjälp.', @@ -9432,13 +9440,13 @@ const HexplorationMod = (() => { }, languages: { heading: 'Språk', - body: 'Välj ett språk med !hexploration set språk. Tillgängliga språk:', + body: 'Välj ett språk med !hexploration set language. Tillgängliga språk:', colLanguage: 'Språk', colNative: 'Eget namn', - colCode: 'Koda', + colCode: 'Kod', }, credits: { - heading: 'Krediter', + heading: 'Medverkande', original: 'Originalmod av', maintainer: 'Version 2 underhålls av', marketplace: 'Adas konstpaket på Roll20 Marketplace', @@ -9565,7 +9573,7 @@ const HexplorationMod = (() => { }, revealDistance: { label: 'Görüş Mesafesi', - desc: 'Hareket eden bir jetonun etrafındaki kaç tane altıgen ortaya çıkar (0 ila 20). 0 yalnızca belirtecin geçtiği altıgenleri ortaya çıkarır.', + desc: 'Hareket eden bir jetonun çevresinde kaç altıgenin açığa çıkacağı (0 ila 20). 0 yalnızca jetonun geçtiği altıgenleri açığa çıkarır.', }, lineOfSight: { label: 'Görüş Hattı', @@ -9573,7 +9581,7 @@ const HexplorationMod = (() => { }, revealPath: { label: 'Yol Boyunca Açığa Çıkar', - desc: 'Açık olduğunda, bir jetonun sürüklenirken geçtiği her altıgen (ara noktalar dahil) yalnızca durduğu yer değil, ortaya çıkar.', + desc: 'Açık olduğunda, bir jetonun yalnızca durduğu yer değil, sürüklenirken geçtiği her altıgen (ara noktalar dahil) açığa çıkar.', }, revealBy: { label: 'Açığa Çıkaran Jetonlar', @@ -9589,11 +9597,11 @@ const HexplorationMod = (() => { }, pingDiscoveries: { label: 'Keşifleri Pingle', - desc: 'Açık olduğunda, oyuncular keşfedildiklerinde adlandırılmış bir konuma ping atılır.', + desc: 'Açık olduğunda, adlandırılmış bir konum keşfedildiğinde oyunculara o konuma ping atılır.', }, hideCoveredTokens: { label: 'Örtülü Jetonları Gizle', - desc: 'Roll20 altıgenlerin üzerine isimleri, çubukları ve auraları çizer. Açıkken, kapalı bir altıgen altındaki jetonların oyuncuların görebileceği adları vardır, çubuklar ve auralar kapatılır ve açığa çıktıklarında tekrar açılır.', + desc: 'Roll20 adları, çubukları ve auraları altıgenlerin üzerine çizer. Açıkken, örtülü bir altıgenin altındaki jetonların oyunculara görünen adı, çubukları ve auraları kapatılır ve açığa çıktıklarında yeniden açılır.', }, }, status: { @@ -9612,10 +9620,10 @@ const HexplorationMod = (() => { messages: { filled: 'Doldurma tamamlandı. Çizilen altıgenler: {created}. Yeniden stil: {restyled}. Gizlenen konumlar: {icons}.', - revealed: 'Büyüler ortaya çıktı: {count}.', + revealed: 'Açığa çıkan altıgenler: {count}.', revealedPage: 'Sayfadaki her altıgen ortaya çıktı ({count}).', confirmReset: - '"{page}" ({count}) öğesindeki her altıgen kaldırılsın mı? Konum belirteçleri, belirteç katmanına geri döner. Geri alma işlemi bunu tersine çeviremez.', + '"{page}" sayfasındaki tüm altıgenler ({count}) kaldırılsın mı? Konum jetonları jeton katmanına geri döner. Geri Al bunu tersine çeviremez.', resetPage: 'Sayfadan kaldırılan altıgenler: {count}.', undone: 'Son doldurma geri alındı. Kaldırılan altıgenler: {removed}. Yeniden biçimlendirilen altıgenler geri yüklendi: {restored}.', @@ -9640,7 +9648,7 @@ const HexplorationMod = (() => { }, warnings: { foregroundUnavailable: - 'Bu oyun ön plan katmanında çizimi desteklemediğinden, simge katmanına altıgenler çizildi.', + 'Bu oyun ön plan katmanında çizimi desteklemediğinden, altıgenler jeton katmanına çizildi.', someFailed: 'Çizilemeyen altıgenler: {count}. Ayrıntılar için API konsolunu kontrol edin.', }, errors: { @@ -9649,7 +9657,7 @@ const HexplorationMod = (() => { noPolygons: 'Doldurulacak bir veya daha fazla çizilmiş şekli seçin.', emptyArea: 'Seçilen alan herhangi bir altıgen merkez içermiyor.', tooMany: 'Bu, tek seferde çok fazla altıgen oluşturacaktır ({count}).', - nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya simgeleri seçin.', + nothingToConceal: 'Gizlenecek çizilmiş şekilleri veya jetonları seçin.', nothingToReveal: 'Ortaya çıkarmak için altıgenleri, çizilmiş şekilleri veya jetonları seçin.', noTokens: 'Önce bir veya daha fazla jeton seçin.', noHexes: @@ -9671,7 +9679,7 @@ const HexplorationMod = (() => { emptyArea: 'Daha büyük bir şekil çizin veya sayfa ızgarası ayarlarını kontrol edin.', tooMany: 'Daha küçük bir alanı doldurun veya alanı birkaç şekle bölün.', noHexes: - 'Altıgenler ön planda veya simge katmanındadır; bunları seçmek için o katmana geçin.', + 'Altıgenler ön plan katmanında veya jeton katmanındadır; bunları seçmek için o katmana geçin.', unknownCommand: 'Komutları listelemek için !hexploration help yazın.', unknownSetting: 'Her ayarı görmek için !hexploration set yazın.', calibrateNeedsTokens: @@ -9684,18 +9692,18 @@ const HexplorationMod = (() => { menu: 'Menüyü göster.', fill: 'Seçilen çizilen şekilleri altıgenlerle kaplayın.', fillInverse: 'Seçilen şekillerin içi hariç tüm sayfayı kaplayın.', - undo: 'Son dolguyu geri alın, ters dolguyu ters çevirin veya gizleyin ve kullandığı şekilleri geri yükleyin.', + undo: 'Son doldurmayı, ters doldurmayı veya gizlemeyi geri alın ve kullandığı şekilleri geri yükleyin.', reveal: - 'Seçilen altıgenleri ve seçilen şekillerin ve simgelerin altındaki altıgenleri ortaya çıkarın.', + 'Seçilen altıgenleri ve seçilen şekillerin ve jetonların altındaki altıgenleri açığa çıkarın.', revealPage: 'Sayfadaki her altıgeni duyuru yapmadan ortaya çıkarın.', conceal: 'Seçilen şekillerin ve jetonların altındaki alanı tekrar altıgenlerle kaplayın.', explore: 'Seçilen jetonların etrafını sanki oraya yeni taşınmışlar gibi gösterin.', resetPage: 'Sayfadaki her altıgeni kaldırın (önce sorar).', - name: 'Seçilen altıgenleri veya seçilen belirteçlerin altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', + name: 'Seçilen altıgenleri veya seçilen jetonların altındaki altıgenleri adlandırın. Temizlemek için adı boş bırakın.', mark: 'Seçilen jetonları gizli konumlara dönüştürün.', - unmark: 'Seçilen belirteçlerin gizli konumlar olmasını durdurun.', + unmark: 'Seçilen jetonların gizli konum olmasını sonlandırın.', set: 'Bir ayarı değiştirin veya tüm ayarları gösterin.', - pageSet: 'Yalnızca geçerli sayfadaki bir gösterme ayarını geçersiz kılın.', + pageSet: 'Yalnızca geçerli sayfadaki bir açığa çıkarma ayarını geçersiz kılın.', pageClear: 'Geçerli sayfanın geçersiz kılmalarını kaldırın.', rescan: 'Sayfanın altıgen listesini yeniden oluşturun; örneğin bir sayfayı veya oyunu kopyaladıktan sonra.', @@ -9713,14 +9721,14 @@ const HexplorationMod = (() => { revealDesc: 'Altıgenleri, şekilleri veya jetonları açığa çıkarmak ya da yeniden örtmek için seçin. Keşfet, seçili jetonların çevresini sanki oraya yeni gitmişler gibi açığa çıkarır.', locationsDesc: - 'Altıgenlerin altındaki konumlar olarak gizlemek için belirteçleri seçin. Bir altıgeni adlandırmak için altıgenleri veya belirteçleri seçin.', + 'Jetonları altıgenlerin altında konum olarak gizlemek için seçin. Bir altıgeni adlandırmak için altıgenleri veya jetonları seçin.', toolsDesc: 'Ayarlar, sayfa geçersiz kılmaları, durum, kopyalanan sayfaları yeniden tarama ve ızgarayı kalibre etme.', footer: 'Talimatların tamamı için "{help}" broşürüne bakın.', }, handout: { versionLabel: 'Sürüm', - subtitle: 'Roll20 için hex-hex keşif', + subtitle: 'Roll20 için altıgen altıgen keşif', footer: 'Tek tıklamayla kontroller için "{deck}" broşürünü kullanın.', overview: { heading: 'Genel Bakış', @@ -9740,8 +9748,8 @@ const HexplorationMod = (() => { commands: { heading: 'Komutlar', intro: - "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçilen nesneler üzerinde hareket eder; geri kalanı görüntülediğiniz sayfada hareket eder.", - colCommand: 'Emretmek', + "Bu komutları yalnızca GM'ler kullanabilir. Çoğu seçili nesneler üzerinde çalışır; geri kalanı görüntülediğiniz sayfada çalışır.", + colCommand: 'Komut', colDesc: 'Ne işe yarar', }, revealing: { @@ -9761,7 +9769,7 @@ const HexplorationMod = (() => { points: [ 'Konumu İşaretle, seçilen jetonları gizli konumlara dönüştürür. Zaten altıgen altında olan bir jeton hemen gizlenir; aksi takdirde onu kapsayan bir sonraki dolgu tarafından gizlenir.', "Beyaz kule durum işaretçisine sahip jetonlar da, sürüm 1'de olduğu gibi, doldurduğunuzda konum olarak kabul edilir.", - 'Gizli konum belirteçleri GM katmanına taşınır. Altıgenleri ortaya çıktığında, adlarının gösterildiği simge katmanına geri dönerler ve keşifleri duyurulur.', + 'Gizli konum jetonları GM katmanına taşınır. Altıgenleri açığa çıktığında adları görünür şekilde jeton katmanına geri dönerler ve keşifleri duyurulur.', "Altıgeni Adlandır, bir altıgene jeton olmadan ad verir. Ad, GM katmanında bir etiket olarak GM'ye gösterilir ve altıgen açığa çıktığında duyurulur. Jumpgate, GM katmanını ön plan katmanının altında çizer; bu nedenle Jumpgate'te etiketler yalnızca Altıgen Katmanı jeton katmanı olarak ayarlandığında görünür.", "Keşifleri Duyur, duyuruyu herkesin mi, yalnızca GM'nin mi yoksa hiç kimsenin mi göreceğini seçer. Keşifleri Pingle ayrıca oyuncuların görünümünü konuma taşır.", ], @@ -9776,7 +9784,7 @@ const HexplorationMod = (() => { perPage: '(Sayfa başına ayarlanabilir.)', }, jumpgate: { - heading: 'Jumpgate ve Eski', + heading: 'Jumpgate ve Legacy', points: [ 'Hexploration, oyunun hangi motoru kullandığını belirler ve uygun türde şekil çizer. Her iki düzenleyicide çizilen şekiller doldurulabilir.', 'Altıgen Katmanı Otomatik olarak ayarlandığında altıgenler ön plan katmanında, jetonların üzerine çizilir; böylece oyuncular altında ne olduğunu göremez. Ön plan katmanı kullanılamıyorsa bunun yerine jeton katmanı kullanılır.', @@ -9788,7 +9796,7 @@ const HexplorationMod = (() => { heading: "Sürüm 1'den yükseltme", points: [ "Sürüm 2'nin artık PathMath, MatrixMath, Vector Math veya HTML Builder'a ihtiyacı yok. Başka bir mod kullanmadığı sürece bunları kaldırabilirsiniz.", - 'Mevcut altıgen haritalar, adlar, konum belirteçleri ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', + 'Mevcut altıgen haritalar, adlar, konum jetonları ve ayarlar ilk başlangıçta otomatik olarak yükseltilir.', 'Hexploration_menu makrosu dahil sürüm 1 komutları hâlâ çalışır.', "Sürüm 1, bir karakteri temsil eden her jetonun altıgenleri açığa çıkarmasına izin veriyordu. Bu davranışı korumak için Açığa Çıkaran Jetonlar'ı Karakter jetonları olarak ayarlayın.", ], @@ -9813,9 +9821,9 @@ const HexplorationMod = (() => { colCode: 'Kod', }, credits: { - heading: 'Kredi', + heading: 'Emeği Geçenler', original: 'Orijinal modun yapımcısı', - maintainer: 'Versiyon 2 tarafından sürdürülen', + maintainer: "Sürüm 2'nin bakımını yapan", marketplace: "Ada'nın sanat paketleri Roll20 Marketplace'te", support: "Bir hata bulursanız veya bir fikriniz varsa Roll20 Mod forumuna gönderin veya GitHub'da bir sorun açın ve API konsolu günlüğündeki tüm mesajları ekleyin.", @@ -9911,12 +9919,12 @@ const HexplorationMod = (() => { desc: 'Мова для меню, повідомлень і роздаткових матеріалів.', }, hexLayer: { - label: 'Шар шестикутників', + label: 'Шар гексів', desc: 'Де малюються нові гекси. «Авто» пробує шар переднього плану (над маркерами), а якщо гра його не підтримує, використовує шар маркерів.', }, fillColor: { label: 'Колір заливки', - desc: 'Колір нових гексів. Використовуйте rgba() для прозорих шестигранників, наприклад rgba(0,0,0,0.8).', + desc: 'Колір нових гексів. Використовуйте rgba() для прозорих гексів, наприклад rgba(0,0,0,0.8).', }, strokeColor: { label: 'Колір контуру', @@ -9935,7 +9943,7 @@ const HexplorationMod = (() => { desc: 'Ширина контуру нових гексів у пікселях (від 0 до 20).', }, maxDistance: { - label: 'Відстань розкриття шестикутників', + label: 'Відстань розкриття гексів', desc: 'Зберігається в гексах під час їх заповнення, тому задайте значення до заповнення: подальша зміна не впливає на гекси, що вже є на карті. Жетон має бути в межах такої кількості гексів, щоб відкрити їх, хоч би як далеко він бачив; при значенні 0 вони відкриваються лише тоді, коли на них заходять. Використовуйте для гір або лісів. Залиште порожнім, щоб не було обмежень.', }, revealDistance: { @@ -9944,7 +9952,7 @@ const HexplorationMod = (() => { }, lineOfSight: { label: 'Лінія видимості', - desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття шестикутників», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', + desc: 'Коли ввімкнено, гекси, які залишаються закритими, як-от гори, заповнені з параметром «Відстань розкриття гексів», приховують гекси за ними. Це має значення лише тоді, коли «Дальність огляду» становить 2 або більше.', }, revealPath: { label: 'Розкривати вздовж шляху', @@ -9960,21 +9968,21 @@ const HexplorationMod = (() => { }, announce: { label: 'Оголошувати відкриття', - desc: 'Хто бачить повідомлення чату, коли виявлено вказане місце.', + desc: 'Хто бачить повідомлення в чаті, коли виявлено іменовану локацію.', }, pingDiscoveries: { label: 'Пінгувати знахідки', - desc: 'Коли ввімкнено, гравці відправляються до вказаного місця, коли його виявляють.', + desc: 'Коли ввімкнено, під час виявлення іменованої локації погляд гравців переміщується до неї.', }, hideCoveredTokens: { label: 'Ховати маркери під гексами', - desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, жетони під закритим гексагоном мають видимі для гравця назви, смужки та аури вимикаються та знову вмикаються, коли їх відкривають.', + desc: 'Roll20 малює імена, смужки та аури над гексами. Коли ввімкнено, у маркерів під закритим гексом вимикаються видимі гравцям ім’я, смужки та аури, а коли маркери відкривають, вони знову вмикаються.', }, }, status: { engine: 'Ігровий рушій', grid: 'Сітка', - layer: 'Шар шестикутників', + layer: 'Шар гексів', hexes: 'Гекси', named: 'Іменовані гекси', icons: 'Маркери локацій', @@ -9991,7 +9999,7 @@ const HexplorationMod = (() => { revealedPage: 'Розкрито кожен гекс на сторінці ({count}).', confirmReset: 'Видалити всі гекси зі сторінки "{page}" ({count})? Маркери локацій повернуться на маркерний шар. Скасувати цю дію не вдасться.', - resetPage: 'Зі сторінки видалено шестигранники: {count}.', + resetPage: 'Зі сторінки видалено гекси: {count}.', undone: 'Останнє заповнення скасовано. Видалені гекси: {removed}. Відновлено оновлені гекси: {restored}.', named: 'Гекси з назвою "{name}": {count}.', @@ -10001,11 +10009,11 @@ const HexplorationMod = (() => { unmarked: 'Жетони, які більше не є місцеположеннями: {count}.', settingChanged: '{setting} встановлено на {value}.', rescanned: - 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Повторно подано: {moved}. Відсутній і забутий: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', + 'Повторне сканування завершено. Збережено: {kept}. Прийнято: {adopted}. Переміщено: {moved}. Відсутні й забуті: {dropped}. Мітки повторно пов’язані: {labels}. Маркери розташування повторно пов’язані: {icons}.', calibrated: - 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Сітка відкалібрована (крок стовпця {colStep}px, крок рядка {rowStep}px). Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', calibrationReset: - 'Калібрування видалено. Повторне сканування: збережено {kept}, повторно подано {moved}, прийнято {adopted}.', + 'Калібрування видалено. Повторне сканування: збережено {kept}, переміщено {moved}, прийнято {adopted}.', journalRebuilt: 'Роздаткові матеріали «{help}» та «{deck}» було перебудовано.', migrated: 'Ваші гексові карти Hexploration 1.x оновлено. Якщо цю гру скопійовано з гри Legacy, виконайте «Пересканувати» на кожній сторінці з гексовою картою.', @@ -10024,10 +10032,10 @@ const HexplorationMod = (() => { noPage: 'Не вдалося знайти сторінку для роботи.', notHex: 'На цій сторінці не використовується гексова сітка.', noPolygons: 'Виберіть одну або кілька намальованих фігур для заповнення.', - emptyArea: 'Вибрана область не містить шестигранних центрів.', + emptyArea: 'Вибрана область не містить центрів гексів.', tooMany: 'Це призведе до створення забагато гексів за один раз ({count}).', nothingToConceal: 'Виберіть намальовані фігури або жетони, щоб приховати.', - nothingToReveal: 'Виберіть шестигранники, намальовані фігури або жетони, щоб розкрити їх.', + nothingToReveal: 'Виберіть гекси, намальовані фігури або жетони, щоб розкрити їх.', noTokens: 'Спочатку виберіть один або кілька токенів.', noHexes: 'Спочатку виберіть один або кілька гексів (або жетонів, що стоять на гексах).', nothingToUndo: 'Немає заповнення, яке можна скасувати.', @@ -10035,7 +10043,7 @@ const HexplorationMod = (() => { unknownSetting: 'Невідоме налаштування: {key}', unknownPageSetting: 'Параметри, які можна встановити для кожної сторінки: {keys}', invalidValue: '"{value}" не є дійсним значенням для {key}.', - calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до шестигранних центрів.', + calibrateNeedsTokens: 'Виберіть один або два жетони, прикріплені до центрів гексів.', calibrateFailed: 'Ці жетони не можна використовувати для калібрування.', unexpected: 'Щось пішло не так: {message}', }, @@ -10051,26 +10059,26 @@ const HexplorationMod = (() => { unknownCommand: 'Введіть !hexploration help, щоб отримати список команд.', unknownSetting: 'Введіть !hexploration set, щоб побачити кожне налаштування.', calibrateNeedsTokens: - 'Прив’яжіть жетон до центру шестигранника та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього шестигранника в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір шестигранника.', + 'Прив’яжіть жетон до центру гекса та виберіть його. Виберіть другий жетон, прив’язаний до сусіднього гекса в тому ж рядку (Hex V) або стовпці (Hex H), щоб також виправити розмір гекса.', calibrateFailed: - 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гексагон.', + 'Два жетони мають бути в одному рядку (Hex V) або в одному стовпці (Hex H) на відстані принаймні один гекс.', unexpected: 'Подробиці в журналі консолі API.', }, help: { menu: 'Показати меню.', - fill: 'Покрийте вибрані намальовані форми шестигранниками.', + fill: 'Покрийте вибрані намальовані форми гексами.', fillInverse: 'Покрийте всю сторінку, за винятком вибраних форм.', undo: 'Скасуйте останню заливку, інверсну заливку або приховання та відновіть використані форми.', reveal: 'Розкрийте вибрані гекси та гекси під вибраними фігурами та жетонами.', revealPage: 'Відкрийте кожен гекс на сторінці без оголошень.', - conceal: 'Знову покрийте область під вибраними фігурами та жетонами шестигранниками.', + conceal: 'Знову покрийте область під вибраними фігурами та жетонами гексами.', explore: 'Розкрийте навколо вибраних жетонів так, ніби вони щойно туди перемістилися.', resetPage: 'Видаліть кожен гекс на сторінці (спочатку запитує).', name: 'Назвіть вибрані гекси або гекси під вибраними жетонами. Залиште ім’я порожнім, щоб очистити його.', mark: 'Перетворіть вибрані жетони на приховані місця.', - unmark: 'Заборонити вибрані маркери бути прихованими місцями.', + unmark: 'Зробіть так, щоб вибрані маркери більше не були прихованими місцями.', set: 'Змінити налаштування або показати всі налаштування.', - pageSet: 'Перевизначити налаштування показу лише на поточній сторінці.', + pageSet: 'Перевизначити налаштування розкриття лише на поточній сторінці.', pageClear: 'Видаліть перевизначення поточної сторінки.', rescan: 'Перебудуйте список гексів сторінки, наприклад після копіювання сторінки чи гри.', calibrate: @@ -10098,7 +10106,7 @@ const HexplorationMod = (() => { footer: 'Використовуйте роздатковий матеріал "{deck}" для керування одним натисканням.', overview: { heading: 'Огляд', - body: 'Hexploration охоплює шестигранну карту з непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', + body: 'Hexploration накриває гексову карту непрозорими гексами. Коли група рухається, гекси, через які вони проходять (і, якщо хочете, гекси навколо них) видаляються, тому карта відкривається по одному гексу за раз. Приховані локації можна розмістити під гексами та оголошувати, коли вони знайдені. Він працює в іграх Jumpgate і Legacy, на Hex (V) і Hex (H) сітках будь-якого розміру.', demo: 'Перегляньте коротку демонстрацію (з версії 1)', }, quickStart: { @@ -10123,8 +10131,8 @@ const HexplorationMod = (() => { points: [ 'Гекси розкривають лише маркери на шарі маркерів. Які саме, визначає параметр «Маркери, що розкривають»: типово це маркери гравців, тож GM може пересувати монстрів, не відкриваючи карту.', 'Маркер розкриває кожен гекс, який він займає (великі маркери займають кілька), а з увімкненим параметром «Розкривати вздовж шляху» — і кожен гекс на маршруті, яким його перетягнули, включно з проміжними точками.', - '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття шестикутників».', - '«Відстань розкриття шестикутників» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття шестикутників» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', + '«Дальність огляду» розкриває гекси навколо кожного з цих гексів, починаючи з найближчих. Коли «Лінія видимості» ввімкнена, гекс не розкривається, доки між ним і маркером лежить закритий гекс. Ближчі гекси зазвичай розкриваються першими, тож на відкритій місцевості «Лінія видимості» нічого не змінює: вона має значення лише тоді, коли «Дальність огляду» становить 2 або більше і є гекси, які залишаються закритими, як-от місцевість, заповнена з параметром «Відстань розкриття гексів».', + '«Відстань розкриття гексів» зберігається в кожному гексі під час його заповнення, тому задайте її до заповнення; подальша зміна не впливає на гекси, що вже є на карті. Маркер має бути в межах такої кількості гексів, щоб розкрити їх, хоч би як далеко він бачив, а при значенні 0 вони розкриваються лише тоді, коли на них заходять. Для гірського хребта: встановіть «Відстань розкриття гексів» на 0, заповніть гори, знову очистьте значення (без обмежень), а потім заповніть землі за ними. Коли «Дальність огляду» становить 3, а «Лінія видимості» ввімкнена, загін бачить відкриту місцевість навколо себе, але не гори й не те, що лежить за ними. Кожен гірський гекс розкривається, коли на нього заходить маркер.', 'У режимі «Проблиск» гекси в межах видимості не зникають, а стають напівпрозорими й видаляються, коли на них заходить маркер. Гекси, побачені в режимі «Проблиск», не закривають огляд для параметра «Лінія видимості».', "Roll20 малює імена, смуги й аури маркерів поверх гексів. З увімкненим параметром «Ховати маркери під гексами» у маркера під закритим гексом вимикаються видимі гравцям ім'я, смуги й аури, доки його не відкриють, тож сховані монстри себе не видають. Якщо ввімкнути щось із цього, поки маркер закритий, воно лишиться прихованим і ввімкнеться, коли маркер відкриють.", 'API не повідомляє про переміщення, зроблені іншими модами. Переміщення TokenMod підхоплюються автоматично; для інших модів виділіть маркери й натисніть «Дослідити» або викличте Hexploration.revealAround(token) зі свого моду.', @@ -10135,25 +10143,25 @@ const HexplorationMod = (() => { points: [ '«Позначити локацію» перетворює вибрані маркери на приховані локації. Маркер, який уже стоїть під гексом, ховається відразу; інакше його сховає наступне заповнення, що його накриє.', 'Жетони з маркером статусу білої вежі також розглядаються як локації, коли ви заповнюєте, як у версії 1.', - 'Жетони прихованого розташування переміщуються на рівень GM. Коли їхній гексагон розкривається, вони повертаються до рівня маркерів із показом свого імені та оголошують про своє відкриття.', - '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар шестикутників» вибрано шар маркерів.', + 'Маркери прихованих локацій переміщуються на шар GM. Коли їхній гекс розкривається, вони повертаються на шар маркерів із показаним ім’ям, а про їхнє виявлення оголошується.', + '«Назвати гекс» дає гексу назву без маркера. Назва показується GM як мітка на шарі GM і оголошується, коли гекс відкривається. Jumpgate малює шар GM під шаром переднього плану, тому в Jumpgate мітки видно лише тоді, коли для параметра «Шар гексів» вибрано шар маркерів.', '«Оголошувати відкриття» визначає, чи бачитимуть оголошення всі, лише GM чи ніхто. «Пінгувати знахідки» також переміщує погляд гравців на локацію.', ], }, settings: { heading: 'Налаштування', intro: - 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар шестикутників», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', - colKey: 'ключ', + 'Змінюйте налаштування командою !hexploration set (або кнопкою «Налаштування»). «Шар гексів», «Маркери, що розкривають» і «Мова» також можна задати на сторінці налаштувань мода.', + colKey: 'Ключ', colName: 'Налаштування', - colDesc: 'опис', + colDesc: 'Опис', perPage: '(Можна встановити на сторінку.)', }, jumpgate: { heading: 'Jumpgate і Legacy', points: [ - 'Hexploration визначає, який двигун використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', - 'Якщо для «Шару шестикутників» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', + 'Hexploration визначає, який рушій використовує гра, і малює відповідну форму. Фігури, намальовані в будь-якому редакторі, можна заливати.', + 'Якщо для «Шару гексів» вибрано «Авто», гекси малюються на шарі переднього плану, над маркерами, тож гравці не бачать, що під ними. Якщо шар переднього плану недоступний, використовується шар маркерів.', 'Jumpgate малює математично правильні гекси, форма яких трохи відрізняється від гексів Legacy. Якщо гекси не збігаються із сіткою сторінки, прив’яжіть маркер до центру гекса, виберіть його та натисніть «Відкалібрувати». Щоб заодно виправити розмір гекса, виберіть два маркери в сусідніх гексах одного рядка (Hex V) або стовпця (Hex H).', 'Коли сторінку чи гру копіюють, її гекси отримують нові ідентифікатори. Виконайте «Пересканувати» на сторінці, щоб знову знайти їх разом із мітками назв і маркерами локацій.', ], @@ -10187,7 +10195,7 @@ const HexplorationMod = (() => { colCode: 'Код', }, credits: { - heading: 'Кредити', + heading: 'Автори', original: 'Оригінальний мод від', maintainer: 'Версія 2 підтримується', marketplace: 'Художні набори Ади на Roll20 Marketplace',