79 |
80 |
81 | Polyglot is available in the following languages:
82 |
83 | - Czech, thanks to [KarelZavicak](https://github.com/KarelZavicak)
84 | - English
85 | - Finnish, thanks to [Demian Wright](https://github.com/DemianWright)
86 | - French, thanks to [sladecraven](https://github.com/sladecraven)
87 | - German, thanks to [Nyhles](https://github.com/Nyhles)
88 | - Italian, thanks to [EldritchTranslator](https://github.com/EldritchTranslator)
89 | - Japanese, thanks to [BrotherSharper](https://github.com/BrotherSharper)
90 | - Korean, thanks to [drdwing](https://github.com/drdwing)
91 | - Polish, thanks to [MichalGolaszewski](https://github.com/MichalGolaszewski)
92 | - Portuguese (Brazil)
93 | - Spanish, thanks to [juanfrank](https://github.com/juanfrank), [lozalojo](https://github.com/lozalojo), [GoR](github.com/Git-GoR)
94 | - Swedish, thanks to [Jonas Karlsson](https://github.com/xdy)
95 |
96 | ## Contributing
97 |
98 | If you want to contribute with any translation, check out [Polyglot's Weblate page](https://weblate.foundryvtt-hub.com/engage/polyglot/).
99 |
100 | ### System Specific Translations
101 |
102 | Some translations are specific to a system (e.g. `COC7`, `SWADE`, and `WFRP4E`. When in doubt about its translation, check up with other translators of the system or the Babele module's translation.
103 |
--------------------------------------------------------------------------------
/src/module/providers/draw-steel.js:
--------------------------------------------------------------------------------
1 | import LanguageProvider from "./templates/Base.js";
2 |
3 | export default class drawSteelLanguageProvider extends LanguageProvider {
4 | languages = {
5 | // ancestry languages
6 | caelian: { // common
7 | font: "Meroitic Demotic",
8 | },
9 | anjali: {
10 | font: "High Drowic",
11 | },
12 | axiomatic: {
13 | font: "Miroslav Normal",
14 | },
15 | filliaric: {
16 | font: "Kargi",
17 | },
18 | highKuric: {
19 | font: "Maras Eye",
20 | },
21 | hyrallic: {
22 | font: "Ar Ciela",
23 | },
24 | illyvric: {
25 | font: "Ar Ciela",
26 | },
27 | kalliak: {
28 | font: "Kargi",
29 | },
30 | kethaic: {
31 | font: "Semphari",
32 | },
33 | khelt: {
34 | font: "Barazhad",
35 | },
36 | khoursirian: {
37 | font: "Meroitic Demotic",
38 | },
39 | lowKuric: {
40 | font: "Ork Glyphs",
41 | },
42 | mindspeech: {
43 | font: "Saurian",
44 | },
45 | protoCtholl: {
46 | font: "Tengwar",
47 | },
48 | szetch: {
49 | font: "Kargi",
50 | },
51 | theFirstLanguage: {
52 | font: "Mage Script",
53 | },
54 | tholl: {
55 | font: "Tengwar",
56 | },
57 | urollialic: {
58 | font: "Skaven",
59 | },
60 | variac: {
61 | font: "Skaven",
62 | },
63 | vastariax: {
64 | font: "Rellanic",
65 | },
66 | vhoric: {
67 | font: "Maras Eye",
68 | },
69 | voll: {
70 | font: "Celestial",
71 | },
72 | yllyric: {
73 | font: "Ar Ciela",
74 | },
75 | zahariax: {
76 | font: "Dark Eldar",
77 | },
78 | zaliac: {
79 | font: "Floki",
80 | },
81 | // Human languages. Khoursirian already covered
82 | higaran: {
83 | font: "Meroitic Demotic",
84 | },
85 | khemharic: {
86 | font: "Meroitic Demotic",
87 | },
88 | oaxuatl: {
89 | font: "Meroitic Demotic",
90 | },
91 | phaedran: {
92 | font: "Meroitic Demotic",
93 | },
94 | riojan: {
95 | font: "Meroitic Demotic",
96 | },
97 | uvalic: {
98 | font: "Meroitic Demotic",
99 | },
100 | vaniric: {
101 | font: "Meroitic Demotic",
102 | },
103 | vasloria: {
104 | font: "Meroitic Demotic",
105 | },
106 | // Dead languages
107 | highRhyvian: {
108 | font: "Ar Ciela",
109 | },
110 | khamish: {
111 | font: "Jungle Slang",
112 | },
113 | kheltivari: {
114 | font: "Barazhad",
115 | },
116 | lowRhivian: {
117 | font: "Ar Ciela",
118 | },
119 | oldVariac: {
120 | font: "Skaven",
121 | },
122 | phorialtic: {
123 | font: "Ork Glyphs",
124 | },
125 | rallarian: {
126 | font: "Floki",
127 | },
128 | ullorvic: {
129 | font: "Ar Ciela",
130 | },
131 | };
132 |
133 | async getLanguages() {
134 | if (this.replaceLanguages) {
135 | this.languages = {};
136 | return;
137 | }
138 | const languagesSetting = game.settings.get("polyglot", "Languages");
139 | this.languages = Object.keys(CONFIG.DRAW_STEEL.languages).reduce((outputLangs, lang) => {
140 | outputLangs[lang] = {
141 | label: CONFIG.DRAW_STEEL.languages[lang].label,
142 | font: languagesSetting[lang]?.font || this.languages[lang]?.font || this.defaultFont,
143 | rng: languagesSetting[lang]?.rng ?? "default",
144 | };
145 | return outputLangs;
146 | }, {});
147 | }
148 |
149 | getUserLanguages(actor) {
150 | let known_languages = new Set();
151 | let literate_languages = new Set();
152 |
153 | const actorLangs = Array.from(actor.system.biography?.languages);
154 |
155 | if (actorLangs) {
156 | known_languages = new Set(actorLangs);
157 | }
158 |
159 | return [known_languages, literate_languages];
160 | }
161 |
162 | getSystemDefaultLanguage() {
163 | return "caelian";
164 | }
165 |
166 | addToConfig(key, lang) {
167 | if (CONFIG.DRAW_STEEL.languages) {
168 | CONFIG.DRAW_STEEL.languages[key] = { label: lang };
169 | }
170 | }
171 |
172 | removeFromConfig(key) {
173 | if (CONFIG.DRAW_STEEL.languages) delete CONFIG.DRAW_STEEL.languages[key];
174 | }
175 | }
176 |
--------------------------------------------------------------------------------
/src/module/providers/pf1.js:
--------------------------------------------------------------------------------
1 | import LanguageProvider from "./templates/Base.js";
2 |
3 | export default class pf1LanguageProvider extends LanguageProvider {
4 | languages = {
5 | common: {
6 | font: "Thorass",
7 | },
8 | aboleth: {
9 | font: "Ar Ciela",
10 | },
11 | abyssal: {
12 | font: "Barazhad",
13 | },
14 | aklo: {
15 | font: "Ophidian",
16 | },
17 | algollthu: {
18 | font: "Ar Ciela",
19 | },
20 | anadi: {
21 | font: "Jungle Slang",
22 | },
23 | aquan: {
24 | font: "Olde Thorass",
25 | },
26 | arboreal: {
27 | font: "Olde Espruar",
28 | },
29 | auran: {
30 | font: "Olde Thorass",
31 | },
32 | azlanti: {
33 | font: "Tengwar",
34 | },
35 | boggard: {
36 | font: "Semphari",
37 | },
38 | caligni: {
39 | font: "High Drowic",
40 | },
41 | celestial: {
42 | font: "Celestial",
43 | },
44 | cyclops: {
45 | font: "Meroitic Demotic",
46 | },
47 | daemonic: {
48 | font: "Infernal",
49 | },
50 | dark: {
51 | font: "High Drowic",
52 | },
53 | destrachan: {
54 | font: "Ar Ciela",
55 | },
56 | draconic: {
57 | font: "Iokharic",
58 | },
59 | drowsign: {
60 | font: "Finger Alphabet",
61 | },
62 | druidic: {
63 | font: "Jungle Slang",
64 | },
65 | dwarven: {
66 | font: "Dethek",
67 | },
68 | dziriak: {
69 | font: "Pulsian",
70 | },
71 | elven: {
72 | font: "Espruar",
73 | },
74 | erutaki: {
75 | font: "Tuzluca",
76 | },
77 | garundi: {
78 | font: "Qijomi",
79 | },
80 | giant: {
81 | font: "Meroitic Demotic",
82 | },
83 | gnoll: {
84 | font: "Kargi",
85 | },
86 | gnome: {
87 | font: "Dethek",
88 | },
89 | gnomish: {
90 | font: "Dethek",
91 | },
92 | goblin: {
93 | font: "Kargi",
94 | },
95 | grippli: {
96 | font: "Semphari",
97 | },
98 | hallit: {
99 | font: "Tengwar",
100 | },
101 | ignan: {
102 | font: "Dethek",
103 | },
104 | iruxi: {
105 | font: "Semphari",
106 | },
107 | jistkan: {
108 | font: "Valmaric",
109 | },
110 | jotun: {
111 | font: "Meroitic Demotic",
112 | },
113 | jyoti: {
114 | font: "Celestial",
115 | },
116 | infernal: {
117 | font: "Infernal",
118 | },
119 | kelish: {
120 | font: "Highschool Runes",
121 | },
122 | mwangi: {
123 | font: "Tengwar",
124 | },
125 | necril: {
126 | font: "High Drowic",
127 | },
128 | orc: {
129 | font: "Dethek",
130 | },
131 | orcish: {
132 | font: "Dethek",
133 | },
134 | polyglot: {
135 | font: "Tengwar",
136 | },
137 | protean: {
138 | font: "Barazhad",
139 | },
140 | requian: {
141 | font: "Reanaarian",
142 | },
143 | shoanti: {
144 | font: "Tengwar",
145 | },
146 | skald: {
147 | font: "Valmaric",
148 | },
149 | sphinx: {
150 | font: "Reanaarian",
151 | },
152 | strix: {
153 | font: "Infernal",
154 | },
155 | sylvan: {
156 | font: "Olde Espruar",
157 | },
158 | shoony: {
159 | font: "Dethek",
160 | },
161 | taldane: {
162 | font: "Tengwar",
163 | },
164 | tengu: {
165 | font: "Oriental",
166 | },
167 | terran: {
168 | font: "Dethek",
169 | },
170 | thassilonian: {
171 | font: "Thassilonian",
172 | },
173 | tien: {
174 | font: "Oriental",
175 | },
176 | treant: {
177 | font: "Olde Espruar",
178 | },
179 | undercommon: {
180 | font: "High Drowic",
181 | },
182 | utopian: {
183 | font: "Maras Eye",
184 | },
185 | varisian: {
186 | font: "Tengwar",
187 | },
188 | vegepygmy: {
189 | font: "Kargi",
190 | },
191 | vudrani: {
192 | font: "Qijomi",
193 | },
194 | };
195 |
196 | getUserLanguages(actor) {
197 | let knownLanguages = new Set();
198 | let literateLanguages = new Set();
199 | if (actor.system?.traits?.languages) {
200 | for (let lang of actor.system.traits.languages.total) {
201 | knownLanguages.add(lang);
202 | }
203 | if (actor.system.traits.languages.customTotal) {
204 | for (let lang of actor.system.traits.languages.customTotal) {
205 | const key = lang.trim().toLowerCase();
206 | knownLanguages.add(key);
207 | }
208 | }
209 | }
210 | return [knownLanguages, literateLanguages];
211 | }
212 | }
213 |
--------------------------------------------------------------------------------
/src/module/api.js:
--------------------------------------------------------------------------------
1 | import * as providers from "./providers/_module.js";
2 | import { providerKeys } from "./providers/_shared.js";
3 | import { addSetting } from "./settings.js";
4 |
5 | export class PolyglotAPI {
6 | constructor() {
7 | this.providers = {};
8 | this.polyglot = null;
9 | }
10 |
11 | init() {
12 | // Assumes the first class in the file is the actual LanguageProvider class. This is better than adding an if-clause in the loop
13 | const supportedSystems = Object.keys(providers)
14 | .filter((provider) => provider !== "LanguageProvider")
15 | .map((provider) => provider.replace("LanguageProvider", ""))
16 | .join("|");
17 | const systemsRegex = new RegExp(`^(${supportedSystems})$`);
18 | let providerString = game.system.id;
19 | if (!systemsRegex.test(game.system.id)) {
20 | providerString = providerKeys[game.system.id] || "Generic";
21 | }
22 |
23 | const providerId = `native${providerString !== "Generic" ? `.${providerString}` : ""}`;
24 | this.providers[providerId] = new providers[`${providerString}LanguageProvider`](providerId);
25 | }
26 |
27 | get languageProvider() {
28 | return this.polyglot.languageProvider;
29 | }
30 |
31 | /**
32 | * @param {String} provider
33 | */
34 | set languageProvider(provider) {
35 | this.polyglot.languageProvider = this.providers[provider];
36 | }
37 |
38 | attach() {
39 | game.polyglot.api = this;
40 | this.polyglot = game.polyglot;
41 | }
42 |
43 | defaultProvider() {
44 | /** providerIds should always be sorted the same way so this should achieve a stable default. */
45 | const providerIds = Object.keys(this.providers);
46 | let defaultValue = providerIds[0];
47 |
48 | const module = providerIds.find((key) => key.startsWith("module."));
49 | if (module) defaultValue = module;
50 |
51 | const gameSystem = providerIds.find((key) => key.startsWith("system.") || key.includes(game.system.id));
52 | if (gameSystem) defaultValue = gameSystem;
53 |
54 | addSetting("languageProvider", {
55 | // Has no name or hint
56 | config: false,
57 | type: String,
58 | default: defaultValue,
59 | onChange: (s) => {
60 | this.languageProvider = this.providers[s];
61 | },
62 | });
63 | }
64 |
65 | updateProvider() {
66 | // If the configured provider is registered use that one. If not use the default provider
67 | const configuredProvider = game.settings.get("polyglot", "languageProvider");
68 | const fallbackProvider = game.settings.settings.get("polyglot.languageProvider").default;
69 | this.polyglot.languageProvider = this.providers[configuredProvider] || this.providers[fallbackProvider];
70 | this.polyglot.omniglot = game.settings.get("polyglot", "omniglot");
71 | this.polyglot.comprehendLanguages = game.settings.get("polyglot", "comprehendLanguages");
72 | this.polyglot.truespeech = game.settings.get("polyglot", "truespeech");
73 | }
74 |
75 | /**
76 | * @param {String} moduleId
77 | * @param {providers.LanguageProvider} languageProvider
78 | */
79 | registerModule(moduleId, languageProvider) {
80 | const module = game.modules.get(moduleId);
81 | if (!module) {
82 | console.warn(
83 | `Polyglot | A module tried to register with the id "${moduleId}". However no active module with this id was found. This api registration call was ignored. If you are the author of that module please check that the id passed to "registerModule" matches the id in your manifest exactly.`,
84 | );
85 | return;
86 | }
87 | if (moduleId === "polyglot") {
88 | console.warn(
89 | `Polyglot | A module tried to register with the id "${moduleId}", which is not allowed. This api registration call was ignored. If you're the author of the module please use the id of your own module as it's specified in your manifest to register to this api.`,
90 | );
91 | return;
92 | }
93 |
94 | this.#register(`module.${module.id}`, languageProvider);
95 | }
96 |
97 | /**
98 | * @param {providers.LanguageProvider} languageProvider
99 | */
100 | registerSystem(languageProvider) {
101 | this.#register(`system.${game.system.id}`, languageProvider);
102 | }
103 |
104 | /**
105 | * @param {String} id
106 | * @param {providers.LanguageProvider} languageProvider
107 | */
108 | #register(id, languageProvider) {
109 | const providerInstance = new languageProvider(id);
110 | this.providers[providerInstance.id] = providerInstance;
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/fonts/licenses/ny stormning.txt:
--------------------------------------------------------------------------------
1 | Copyright (c) 2016, Mew Too, Robert Jablonski (Cannot Into Space Fonts) (cannotintospacefonts@gmail.com),
2 | with Reserved Font Name Ny Stormning.
3 |
4 | This Font Software is licensed under the SIL Open Font License, Version 1.1.
5 | This license is copied below, and is also available with a FAQ at:
6 | http://scripts.sil.org/OFL
7 |
8 |
9 | -----------------------------------------------------------
10 | SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
11 | -----------------------------------------------------------
12 |
13 | PREAMBLE
14 | The goals of the Open Font License (OFL) are to stimulate worldwide
15 | development of collaborative font projects, to support the font creation
16 | efforts of academic and linguistic communities, and to provide a free and
17 | open framework in which fonts may be shared and improved in partnership
18 | with others.
19 |
20 | The OFL allows the licensed fonts to be used, studied, modified and
21 | redistributed freely as long as they are not sold by themselves. The
22 | fonts, including any derivative works, can be bundled, embedded,
23 | redistributed and/or sold with any software provided that any reserved
24 | names are not used by derivative works. The fonts and derivatives,
25 | however, cannot be released under any other type of license. The
26 | requirement for fonts to remain under this license does not apply
27 | to any document created using the fonts or their derivatives.
28 |
29 | DEFINITIONS
30 | "Font Software" refers to the set of files released by the Copyright
31 | Holder(s) under this license and clearly marked as such. This may
32 | include source files, build scripts and documentation.
33 |
34 | "Reserved Font Name" refers to any names specified as such after the
35 | copyright statement(s).
36 |
37 | "Original Version" refers to the collection of Font Software components as
38 | distributed by the Copyright Holder(s).
39 |
40 | "Modified Version" refers to any derivative made by adding to, deleting,
41 | or substituting -- in part or in whole -- any of the components of the
42 | Original Version, by changing formats or by porting the Font Software to a
43 | new environment.
44 |
45 | "Author" refers to any designer, engineer, programmer, technical
46 | writer or other person who contributed to the Font Software.
47 |
48 | PERMISSION & CONDITIONS
49 | Permission is hereby granted, free of charge, to any person obtaining
50 | a copy of the Font Software, to use, study, copy, merge, embed, modify,
51 | redistribute, and sell modified and unmodified copies of the Font
52 | Software, subject to the following conditions:
53 |
54 | 1) Neither the Font Software nor any of its individual components,
55 | in Original or Modified Versions, may be sold by itself.
56 |
57 | 2) Original or Modified Versions of the Font Software may be bundled,
58 | redistributed and/or sold with any software, provided that each copy
59 | contains the above copyright notice and this license. These can be
60 | included either as stand-alone text files, human-readable headers or
61 | in the appropriate machine-readable metadata fields within text or
62 | binary files as long as those fields can be easily viewed by the user.
63 |
64 | 3) No Modified Version of the Font Software may use the Reserved Font
65 | Name(s) unless explicit written permission is granted by the corresponding
66 | Copyright Holder. This restriction only applies to the primary font name as
67 | presented to the users.
68 |
69 | 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
70 | Software shall not be used to promote, endorse or advertise any
71 | Modified Version, except to acknowledge the contribution(s) of the
72 | Copyright Holder(s) and the Author(s) or with their explicit written
73 | permission.
74 |
75 | 5) The Font Software, modified or unmodified, in part or in whole,
76 | must be distributed entirely under this license, and must not be
77 | distributed under any other license. The requirement for fonts to
78 | remain under this license does not apply to any document created
79 | using the Font Software.
80 |
81 | TERMINATION
82 | This license becomes null and void if any of the above conditions are
83 | not met.
84 |
85 | DISCLAIMER
86 | THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
87 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
88 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
89 | OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
90 | COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
91 | INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
92 | DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
93 | FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
94 | OTHER DEALINGS IN THE FONT SOFTWARE.
95 |
--------------------------------------------------------------------------------
/src/lang/sv.json:
--------------------------------------------------------------------------------
1 | {
2 | "POLYGLOT": {
3 | "Languages.hint": "Ändrar alfabetet som används för språken. Återställning till standardinställningarna laddar om.",
4 | "enableAllFonts": {
5 | "choices": {
6 | "0": "Ingen",
7 | "1": "Polyglot's Teckensnitt",
8 | "2": "Foundry's Extrafonter",
9 | "3": "Bägge"
10 | },
11 | "title": "Lägg till teckensnitt i teckensnitts- och språkinställningarna",
12 | "hint": "Lägg till teckensnitt i teckensnitts- och språkinställningarna."
13 | },
14 | "LanguageProvider": {
15 | "choices": {
16 | "module": "[Modul] {name}",
17 | "native": "Generisk",
18 | "system": "[System] {name}"
19 | },
20 | "name": "Provider av språkinställningar",
21 | "hint": "Välj vem som tillhandahåller språkinformation för alfabet och språk. Fler språkleverantörer kan göras tillgängliga via spelsystem och installerade moduler. Alternativen nedan beror på vilken språkleverantör som väljs här. ⚠️ Om du byter leverantör har du för att spara och öppna dessa inställningar igen."
22 | },
23 | "UESRPG.Language": "Språk",
24 | "COC7": {
25 | "LanguageOwn": "Språk",
26 | "LanguageAny": "Språk",
27 | "LanguageOther": "Språk",
28 | "LanguageSpec": "Språk"
29 | },
30 | "DND5E": {
31 | "SpecialLanguages.title": "Ersätt specialspråk",
32 | "SpecialLanguages.hint": "Namnet på språket som kommer att ersätta \"språk\" som \"alla språk det kunde i livet\"."
33 | },
34 | "SWADE": {
35 | "LanguageSkills": "Språk"
36 | },
37 | "WFRP4E": {
38 | "LanguageSkills": "Språk"
39 | },
40 | "Runes": "Runor",
41 | "Generic": {
42 | "Language": "Språk"
43 | },
44 | "DefaultAlphabet": "Standardalfabet",
45 | "FontSettings": "Teckensnittsinställningar",
46 | "LanguageSettings": "Språkinställningar",
47 | "ChatSettings": "Chatinställningar",
48 | "Languages.title": "Språk",
49 | "Font": "Teckensnitt",
50 | "Fonts": "Teckensnitt",
51 | "FontSize": "Teckenstorlek (%)",
52 | "CustomLanguages.title": "Anpassade språk",
53 | "CustomLanguages.hint": "Definiera en lista över anpassade, kommaseparerade språk att lägga till i systemet.",
54 | "ComprehendLanguages.title": "Magiformeln Förstå Språk",
55 | "ComprehendLanguages.hint": "Sätt ett språk vars talare förstår alla andra språk, men som inte kan talas eller skrivas.",
56 | "Truespeech.title": "Tala i tungor",
57 | "Truespeech.hint": "Sätt ett språk vars talare förstår alla talade språk (kan inte läsa jJurnaler) och som förstås av alla varelser.",
58 | "JournalHighlight.title": "Journalmarkering Opacitet (%)",
59 | "JournalHighlight.hint": "Definierar opaciteten för markeringen över teckensnitt på journalen.",
60 | "logographicalFontToggle.title": "Logografiska teckensnitt",
61 | "logographicalFontToggle.hint": "Halverar storleken på fraser med hjälp av logografiska teckensnitt (t.ex. japanska, kinesiska tecken).",
62 | "DefaultLanguage.title": "Standardspråk",
63 | "DefaultLanguage.hint": "Namnet på standardspråket att välja. Lämna tomt för att använda systemets standard.",
64 | "ReplaceLanguages.title": "Ersätt systemets språk",
65 | "ReplaceLanguages.hint": "Ersätter systemets standardspråk med dina anpassade språk. Det första språket på listan blir det nya standardspråket.",
66 | "ScrambleGM.title": "Förvräng meddelanden för SL",
67 | "ScrambleGM.hint": "Översätt inte texten för SL (se globens färg för att se vad spelfigur förstår). Kräver omladdning.",
68 | "RandomizeRunes.title": "Randomisera runor",
69 | "RandomizeRunes.hint": "Detta avgör vilken typ av slumpgenerator som används för att generera en fras. ⚠️ Alternativet \"Ingen\" stöder endast alfanumeriska tecken (inga accenter).",
70 | "RandomizeRunesOptions": {
71 | "a": "Standard",
72 | "b": "Unika fraser",
73 | "c": "Inga ⚠️"
74 | },
75 | "ExportFonts.title": "Lägg till Polyglots teckensnitt till Foundry",
76 | "ExportFonts.hint": "Lägg till Polyglots teckensnitt till Foundry meny för ytterligare teckensnitt.",
77 | "DisplayTranslated.title": "Visa översättningar",
78 | "DisplayTranslated.hint": "För språk som är översatta i chattfönstret, visa originaltexten och en översättning nedan.",
79 | "HideTranslation.title": "Dölj indikatorer från spelare",
80 | "AllowOOC.title": "Förvräng OOC Chat Messages",
81 | "AllowOOC.hint": "Välj vems användare som ska få sina meddelanden förvrängda. OOC = Utan karaktär.",
82 | "AllowOOCOptions": {
83 | "a": "Alla",
84 | "b": "Endast GM",
85 | "c": "Endast spelare",
86 | "d": "Ingen"
87 | },
88 | "LanguageRegex": {
89 | "title": "Språkregex",
90 | "hint": "Du kan använda detta för att ändra termen som söks på objekt från \"Språk\" till något annat, som \"Tungomål\". Den här inställningen är mer användbar för icke-engelsktalande."
91 | },
92 | "Translation": "Översättning",
93 | "TranslatedFrom": "Översatt från ",
94 | "LanguageLabel": "Språk",
95 | "LatinAlphabet": "Latinska alfabetet",
96 | "ToggleRunes": "Växla runor",
97 | "HideTranslation.hint": "Döljer globen och texten \"Översatt från\" i chattmeddelanden till spelare. Perfekt för när du inte vill visa spelare vilket språk du talar. Kräver omladdning.",
98 | "AlphabetLabel": "Alfabet"
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/src/lang/it.json:
--------------------------------------------------------------------------------
1 | {
2 | "POLYGLOT": {
3 | "LanguageSettings": "Impostazioni lingua",
4 | "ChatSettings": "Impostazioni chat",
5 | "Languages.title": "Lingue",
6 | "FontSize": "Dimensione dei caratteri (%)",
7 | "CustomLanguages.title": "Lingue personalizzate",
8 | "CustomLanguages.hint": "Definisci una lista di lingue personalizzate, separate da virgole, da aggiungere al sistema.",
9 | "ComprehendLanguages.title": "Incantesimo Comprensione dei Linguaggi",
10 | "source": {
11 | "data": "Dati",
12 | "s3": "S3",
13 | "forgevtt": "Forge"
14 | },
15 | "Truespeech.title": "Incantesimo Lingue",
16 | "Truespeech.hint": "Determina una lingua che fa capire a chi la conosce tutte le lingue parlate (non fa leggere i Diari) e che può essere capita da tutte le creature.",
17 | "JournalHighlight.title": "Opacità dell'evidenziatore nei Diari (%)",
18 | "DefaultLanguage.title": "Lingua predefinita",
19 | "DefaultLanguage.hint": "Nome del linguaggio predefinito da selezionare. Se vuoto, usa il predefinito di sistema.",
20 | "ReplaceLanguages.title": "Sostituisci le lingue di sistema",
21 | "ScrambleGM.title": "Rimescola i messaggi per il GM",
22 | "ScrambleGM.hint": "Non tradurre i testi per il GM (fai riferimento al colore del mappamondo per capire se il token comprende). Richiede il ricaricamento.",
23 | "enableAllFonts": {
24 | "hint": "Aggiungi i font alle impostazioni di font e lingua.",
25 | "choices": {
26 | "0": "Nessuno",
27 | "2": "Font aggiuntivi di base",
28 | "3": "Entrambi",
29 | "1": "Font di Polyglot"
30 | },
31 | "title": "Aggiungi font alle impostazioni di font e lingua"
32 | },
33 | "logographicalFontToggle.hint": "Dimezza la dimensione di frasi che usano font logografici (esempio: giapponese, cinese).",
34 | "logographicalFontToggle.title": "Font logografici",
35 | "directory": {
36 | ".hint": "Indica una cartella al di fuori della cartella \"modules\" che contiene i file dei font.",
37 | "name": "Cartella dei font personalizzati"
38 | },
39 | "Fonts": "Font",
40 | "Font": "Font",
41 | "FontSettings": "Impostazioni font",
42 | "RandomizeRunes.title": "Randomizza le rune",
43 | "RandomizeRunesOptions": {
44 | "a": "Default",
45 | "b": "Frasi uniche",
46 | "c": "Nessuno ⚠️"
47 | },
48 | "ExportFonts.title": "Aggiungi i font di Polyglot a quelli base",
49 | "ExportFonts.hint": "Aggiungi i font di Polyglot al menù di Font Addizionali.",
50 | "DisplayTranslated.title": "Mostra traduzioni",
51 | "HideTranslation.title": "Nascondi indicatori ai Giocatori",
52 | "HideTranslation.hint": "Nasconde il Mappamondo e il testo \"Tradotto da\" nei messaggi in chat ai giocatori. Perfetto per quando vuoi nascondere loro che lingua stai parlando.",
53 | "AllowOOC.title": "Rimescola i messaggi OOC in chat",
54 | "AllowOOC.hint": "Scegli che utenti hanno i messaggi rimescolati. OOC = Fuori personaggio (Out of Character).",
55 | "AllowOOCOptions": {
56 | "a": "Tutti",
57 | "b": "Solo GM",
58 | "c": "Solo Giocatori",
59 | "d": "Nessuno"
60 | },
61 | "LanguageProvider": {
62 | "name": "Fonte delle impostazioni delle lingue",
63 | "choices": {
64 | "module": "[Modulo] {name}",
65 | "native": "Generico",
66 | "system": "[Sistema] {name}"
67 | },
68 | "hint": "Seleziona la fonte delle informazioni per gli alfabeti e le lingue. Altre fonti possono essere rese disponibili tramite sistemi e moduli installati. Le opzioni sottostanti dipendono dalla fonte stabilita qui. ⚠️ Se cambi la fonte, devi salvare e riaprire queste impostazioni."
69 | },
70 | "LanguageRegex": {
71 | "title": "RegEx lingua",
72 | "hint": "Puoi usare questa impostazione per cambiare il termine cercato tra gli oggetti da \"Lingua\" a qualcos'altro, come \"Linguaggio\"."
73 | },
74 | "Translation": "Traduzione",
75 | "DefaultAlphabet": "Alfabeto predefinito",
76 | "Languages.hint": "Cambia l'alfabeto usato per le lingue. Ripristinare le impostazioni predefinite ricaricherà la pagina.",
77 | "ComprehendLanguages.hint": "Determina una lingua che fa comprendere a chi la conosce tutte le altre lingue, ma che non può essere parlata o scritta.",
78 | "JournalHighlight.hint": "Definisci l'opacità dell'evidenziamento in un Dario.",
79 | "ReplaceLanguages.hint": "Sostituisce le lingue predefinite del sistema con le tue lingue personalizzate. La prima della lista diventerà la nuova lingua predefinita.",
80 | "RandomizeRunes.hint": "Questo determina che tipo di RNG viene usato per generare una frase. ⚠️ L'opzione \"Nessuno\" supporta solo caratteri alfanumerici (no accenti).",
81 | "DisplayTranslated.hint": "Per le lingue che sono tradotte nella chat, mostra il testo originale con la traduzione sotto.",
82 | "Generic": {
83 | "Language": "Lingua"
84 | },
85 | "UESRPG.Language": "Lingua",
86 | "Runes": "Rune",
87 | "ToggleRunes": "Attiva / disattiva rune",
88 | "LatinAlphabet": "Alfabeto latino",
89 | "AlphabetLabel": "Alfabeto",
90 | "LanguageLabel": "Lingua",
91 | "TranslatedFrom": "Tradotto dal ",
92 | "SWADE": {
93 | "LanguageSkills": "Lingua"
94 | },
95 | "DND5E": {
96 | "SpecialLanguages.hint": "Nome della lingua che rimpiazzerà \"lingue\" come \"tutte le lingue conosciute in vita\".",
97 | "SpecialLanguages.title": "Sostituisci lingue speciali"
98 | },
99 | "COC7": {
100 | "LanguageSpec": "Lingua",
101 | "LanguageOther": "Lingua",
102 | "LanguageAny": "Lingua",
103 | "LanguageOwn": "Lingua"
104 | },
105 | "WFRP4E": {
106 | "LanguageSkills": "Lingua"
107 | }
108 | }
109 | }
110 |
--------------------------------------------------------------------------------
/src/module/tour.js:
--------------------------------------------------------------------------------
1 |
2 | class PolyglotTour extends foundry.nue.Tour {
3 | async _preStep() {
4 | await super._preStep();
5 |
6 | if (this.currentStep.actions) await this.performActions(this.currentStep.actions);
7 |
8 | // If there's tab info, switch to that tab
9 | if (this.currentStep.tab) await this.switchTab(this.currentStep.tab);
10 | }
11 |
12 | async performActions(actions) {
13 | for (const action of actions) {
14 | switch (action) {
15 | case "chat-message": {
16 | await ChatMessage.create({ content: "Polyglot Test Message", flags: { polyglot: { language: "test" } } });
17 | break;
18 | }
19 | case "user-config": {
20 | await game.user.sheet.render(true);
21 | break;
22 | }
23 | case "end": {
24 | this.configurator?.close();
25 | game.user.sheet.close();
26 | break;
27 | }
28 | }
29 | }
30 | }
31 |
32 | async switchTab(tab) {
33 | switch (tab.parent) {
34 | case "sidebar":
35 | ui.sidebar.activateTab(tab.id);
36 | break;
37 | case "settings": {
38 | const app = game.settings.sheet;
39 | await app._render(true);
40 | app.activateTab(tab.id);
41 | break;
42 | }
43 | case "general": {
44 | if (!this.configurator) {
45 | const configurator = game.settings.menus.get("polyglot.GeneralSettings");
46 | this.configurator = new configurator.type();
47 | }
48 | await this.configurator._render(true);
49 | this.configurator.activateTab(tab.id);
50 | break;
51 | }
52 | }
53 | }
54 | }
55 |
56 | export function registerTours() {
57 | game.tours.register("polyglot", "test", new PolyglotTour(
58 | {
59 | title: "POLYGLOT.TOURS.Main.title",
60 | description: "POLYGLOT.TOURS.Main.desc",
61 | restricted: true,
62 | display: game.settings.get("polyglot", "enableChatFeatures"),
63 | canBeResumed: true,
64 | steps: [
65 | {
66 | id: "canvas",
67 | title: "POLYGLOT.TOURS.Main.Canvas.Title",
68 | content: "POLYGLOT.TOURS.Main.Canvas.Content",
69 | tab: { parent: "sidebar", id: "chat" }
70 | },
71 | {
72 | id: "language-selector",
73 | selector: ".polyglot-lang-select",
74 | title: "POLYGLOT.TOURS.Main.LanguageSelector.Title",
75 | content: "POLYGLOT.TOURS.Main.LanguageSelector.Content"
76 | },
77 | {
78 | id: "language-selector-dropdown",
79 | selector: ".polyglot-lang-select .ts-wrapper",
80 | title: "POLYGLOT.TOURS.Main.LanguageSelectorSelect.Title",
81 | content: "POLYGLOT.TOURS.Main.LanguageSelectorSelect.Content"
82 | },
83 | {
84 | id: "language-selector-dropdown",
85 | selector: ".polyglot-lang-select .ts-wrapper",
86 | title: "POLYGLOT.TOURS.Main.LanguageSelectorSelect2.Title",
87 | content: "POLYGLOT.TOURS.Main.LanguageSelectorSelect2.Content"
88 | },
89 | {
90 | id: "language-selector-pips",
91 | selector: ".polyglot-lang-select .ts-wrapper",
92 | title: "POLYGLOT.TOURS.Main.LanguageSelectorPips.Title",
93 | content: "POLYGLOT.TOURS.Main.LanguageSelectorPips.Content",
94 | actions: ["chat-message"]
95 | },
96 | {
97 | id: "chat-message",
98 | selector: ".chat-log .chat-message:last-of-type",
99 | title: "POLYGLOT.TOURS.Main.ChatMessage.Title",
100 | content: "POLYGLOT.TOURS.Main.ChatMessage.Content",
101 | },
102 | {
103 | id: "chat-message-scrambled",
104 | selector: ".chat-log .chat-message:last-of-type .polyglot-original-text",
105 | title: "POLYGLOT.TOURS.Main.ChatMessageScrambled.Title",
106 | content: "POLYGLOT.TOURS.Main.ChatMessageScrambled.Content",
107 | },
108 | {
109 | id: "chat-message-translation",
110 | selector: ".chat-log .chat-message:last-of-type .polyglot-translation-text",
111 | title: "POLYGLOT.TOURS.Main.ChatMessageTranslation.Title",
112 | content: "POLYGLOT.TOURS.Main.ChatMessageTranslation.Content",
113 | },
114 | {
115 | id: "chat-message-globe",
116 | selector: ".chat-log .chat-message:last-of-type .polyglot-message-language",
117 | title: "POLYGLOT.TOURS.Main.ChatMessageGlobe.Title",
118 | content: "POLYGLOT.TOURS.Main.ChatMessageGlobe.Content",
119 | },
120 | {
121 | id: "chat-message-ending",
122 | selector: ".chat-log .chat-message:last-of-type",
123 | title: "POLYGLOT.TOURS.Main.ChatMessageEnding.Title",
124 | content: "POLYGLOT.TOURS.Main.ChatMessageEnding.Content",
125 | },
126 | {
127 | id: "players-list",
128 | selector: "#ui-left aside#players #players-active",
129 | title: "POLYGLOT.TOURS.Main.PlayersList.Title",
130 | content: "POLYGLOT.TOURS.Main.PlayersList.Content"
131 | },
132 | {
133 | id: "user-config",
134 | selector: ".application.user-config",
135 | title: "POLYGLOT.TOURS.Main.UserConfig.Title",
136 | content: "POLYGLOT.TOURS.Main.UserConfig.Content",
137 | actions: ["user-config"]
138 | },
139 | {
140 | id: "user-config-select-character",
141 | selector: ".application.user-config fieldset:has(.form-group.character)",
142 | title: "POLYGLOT.TOURS.Main.UserConfigSelectCharacter.Title",
143 | content: "POLYGLOT.TOURS.Main.UserConfigSelectCharacter.Content",
144 | actions: ["user-config"]
145 | },
146 | {
147 | id: "actor-ownership",
148 | selector: "#sidebar #actors",
149 | title: "POLYGLOT.TOURS.Main.ActorOwnership.Title",
150 | content: "POLYGLOT.TOURS.Main.ActorOwnership.Content",
151 | tab: { parent: "sidebar", id: "actors" }
152 | },
153 | {
154 | id: "end",
155 | title: "POLYGLOT.TOURS.Main.End.Title",
156 | content: "POLYGLOT.TOURS.Main.End.Content",
157 | actions: ["end"]
158 | }
159 | ]
160 | }
161 | ));
162 | }
163 |
--------------------------------------------------------------------------------
/src/module/forms/FontSettings.js:
--------------------------------------------------------------------------------
1 | const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
2 |
3 | export class PolyglotFontSettings extends HandlebarsApplicationMixin(ApplicationV2) {
4 | static get classes() {
5 | const classes = ["sheet", "polyglot", "polyglot-font-settings"];
6 | if (game.system?.id === "wfrp4e") {
7 | classes.push(game.system.id);
8 | }
9 | return classes;
10 | }
11 |
12 | static DEFAULT_OPTIONS = {
13 | id: "polyglot-font-form",
14 | classes: this.classes,
15 | actions: {
16 | reset: PolyglotFontSettings.reset
17 | },
18 | form: {
19 | handler: PolyglotFontSettings.#onSubmit,
20 | closeOnSubmit: true,
21 | },
22 | position: {
23 | width: 780,
24 | height: 680,
25 | },
26 | tag: "form",
27 | window: {
28 | icon: "fas fa-font",
29 | title: "Font Settings",
30 | contentClasses: ["standard-form"],
31 | resizable: true,
32 | }
33 | };
34 |
35 | get title() {
36 | return `Polyglot: ${game.i18n.localize(this.options.window.title)}`;
37 | }
38 |
39 | static PARTS = {
40 | form: {
41 | template: "./modules/polyglot/templates/FontSettings.hbs"
42 | },
43 | footer: {
44 | template: "templates/generic/form-footer.hbs",
45 | },
46 | };
47 |
48 | _prepareContext() {
49 | const fonts = game.settings.get("polyglot", "Alphabets");
50 | this.fonts = {};
51 |
52 | for (let key in fonts) {
53 | this.fonts[key] = {
54 | label: key,
55 | family: fonts[key].fontFamily,
56 | size: game.polyglot.CustomFontSizes[key] || "100",
57 | alphabeticOnly: fonts[key]?.alphabeticOnly || false,
58 | logographical: fonts[key]?.logographical || false,
59 | };
60 | }
61 |
62 | return {
63 | fonts: this.fonts,
64 | fields: game.settings.settings.get("polyglot.Alphabets").type.element.fields,
65 | buttons: [
66 | { type: "submit", icon: "fa-solid fa-save", label: "SETTINGS.Save" },
67 | { type: "reset", action: "reset", icon: "fa-solid fa-undo", label: "SETTINGS.Reset" },
68 | ]
69 | };
70 | }
71 |
72 | _onRender(context, options) {
73 | super._onRender(context, options);
74 |
75 | const changeFontSize = async (event) => {
76 | event.preventDefault();
77 | if (!event.target.hasFocus) return;
78 | let size = event.target.value;
79 | if (event.type !== "change") {
80 | const multiplier = event.deltaY / Math.abs(event.deltaY); // 1 or -1
81 | const step = Number(event.target.step) || 10;
82 | size = Math.floor(size - (multiplier * step));
83 | }
84 | if (size < 50) return;
85 | event.target.value = size;
86 | const parent = event.target.parentElement;
87 | const font = parent.previousElementSibling.textContent;
88 | parent.nextElementSibling.nextElementSibling.nextElementSibling.style.fontSize = `${size}%`;
89 | this.fonts[font].size = size;
90 | };
91 | const changeFontAlphabetic = async (event) => {
92 | const parent = event.target.parentElement;
93 | const font = parent.previousElementSibling.previousElementSibling.textContent;
94 | this.fonts[font].alphabeticOnly = event.target.checked;
95 | };
96 | const changeFontLogographical = async (event) => {
97 | const parent = event.target.parentElement;
98 | const font = parent.previousElementSibling.previousElementSibling.previousElementSibling.textContent;
99 | this.fonts[font].logographical = event.target.checked;
100 | };
101 |
102 | this.element.querySelectorAll(".alphabeticOnly").forEach((el) => el.addEventListener("change", changeFontAlphabetic));
103 | this.element.querySelectorAll(".logographical").forEach((el) => el.addEventListener("change", changeFontLogographical));
104 |
105 | this.element.querySelectorAll(".selectatr").forEach((el) => el.addEventListener("focus", (event) => {
106 | event.target.hasFocus = true;
107 | }));
108 | this.element.querySelectorAll(".selectatr").forEach((el) => el.addEventListener("blur", (event) => {
109 | event.target.hasFocus = false;
110 | }));
111 | this.element.querySelectorAll(".selectatr").forEach((el) => el.addEventListener("change", changeFontSize));
112 | this.element.querySelectorAll(".selectatr").forEach((el) => el.addEventListener("wheel", changeFontSize));
113 | }
114 |
115 | static async reset() {
116 | const defaultAlphabets = new game.polyglot.languageProvider.constructor().fonts;
117 | game.polyglot.languageProvider.fonts = defaultAlphabets;
118 | await game.settings.set("polyglot", "Alphabets", game.polyglot.languageProvider.fonts);
119 | const defaultCustomFontSizes = game.settings.settings.get("polyglot.CustomFontSizes").default;
120 | await game.settings.set("polyglot", "CustomFontSizes", defaultCustomFontSizes);
121 | this.close();
122 | SettingsConfig.reloadConfirm({ world: true });
123 | }
124 |
125 | static async #onSubmit() {
126 | const customFontSizes = {};
127 | for (const [key, font] of Object.entries(this.fonts)) {
128 | customFontSizes[key] = font.size;
129 | game.polyglot.languageProvider.fonts[key].alphabeticOnly = font.alphabeticOnly;
130 | game.polyglot.languageProvider.fonts[key].logographical = font.logographical;
131 | }
132 | let current = game.settings.get("polyglot", "Alphabets");
133 | await game.settings.set("polyglot", "Alphabets", game.polyglot.languageProvider.fonts);
134 | current = game.settings.get("polyglot", "CustomFontSizes");
135 | game.polyglot.CustomFontSizes = customFontSizes;
136 | await game.settings.set("polyglot", "CustomFontSizes", game.polyglot.CustomFontSizes);
137 | const changes = !foundry.utils.isEmpty(foundry.utils.diffObject(current, game.polyglot.languageProvider.fonts))
138 | || !foundry.utils.isEmpty(foundry.utils.diffObject(current, customFontSizes));
139 | if (changes) SettingsConfig.reloadConfirm({ world: true });
140 | }
141 | }
142 |
--------------------------------------------------------------------------------
/gulpfile.mjs:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2022 Johannes Loher
2 | // SPDX-FileCopyrightText: 2022 David Archibald
3 | //
4 | // SPDX-License-Identifier: MIT
5 |
6 | import fs from "fs-extra";
7 | import gulp from "gulp";
8 | import prefix from "gulp-autoprefixer";
9 | import sass from "gulp-dart-sass";
10 | import sourcemaps from "gulp-sourcemaps";
11 | import path from "node:path";
12 | import buffer from "vinyl-buffer";
13 | import source from "vinyl-source-stream";
14 | import yargs from "yargs";
15 | import { hideBin } from "yargs/helpers";
16 |
17 | import rollupStream from "@rollup/stream";
18 |
19 | import rollupConfig from "./rollup.config.mjs";
20 |
21 | /********************/
22 | /* CONFIGURATION */
23 | /********************/
24 |
25 | const packageId = "polyglot";
26 | const sourceDirectory = "./src";
27 | const distDirectory = "./dist";
28 | const stylesDirectory = `${sourceDirectory}/styles`;
29 | const stylesExtension = "scss";
30 | const sourceFileExtension = "js";
31 | const staticFiles = ["assets", "fonts", "lang", "lib", "packs", "styles/fonts.css", "templates", "module.json"];
32 |
33 | /********************/
34 | /* BUILD */
35 | /********************/
36 |
37 | let cache;
38 |
39 | /**
40 | * Build the distributable JavaScript code
41 | */
42 | function buildCode() {
43 | return rollupStream({ ...rollupConfig(), cache })
44 | .on("bundle", (bundle) => {
45 | cache = bundle;
46 | })
47 | .pipe(source(`${packageId}.js`))
48 | .pipe(buffer())
49 | .pipe(sourcemaps.init({ loadMaps: true }))
50 | .pipe(sourcemaps.write("."))
51 | .pipe(gulp.dest(`${distDirectory}/module`));
52 | }
53 |
54 | /**
55 | * Build style sheets
56 | */
57 | function buildStyles() {
58 | return gulp.src([`${stylesDirectory}/**/*.${stylesExtension}`], { base: `${stylesDirectory}/` })
59 | .pipe(sourcemaps.init({ loadMaps: true }))
60 | .pipe(sass({ outputStyle: "compressed" }).on("error", sass.logError))
61 | .pipe(prefix({ cascade: false }))
62 | .pipe(sourcemaps.write("."))
63 | .pipe(gulp.dest(`${distDirectory}/styles`));
64 | }
65 |
66 | /**
67 | * Copy static files
68 | */
69 | async function copyFiles() {
70 | for (const file of staticFiles) {
71 | if (fs.existsSync(`${sourceDirectory}/${file}`)) {
72 | await fs.copy(`${sourceDirectory}/${file}`, `${distDirectory}/${file}`);
73 | }
74 | }
75 | }
76 |
77 | function tomSelect() {
78 | return gulp.src([
79 | "node_modules/tom-select/dist/js/tom-select.complete.min.js",
80 | "node_modules/tom-select/dist/js/tom-select.complete.min.js.map",
81 | "node_modules/tom-select/dist/css/tom-select.min.css",
82 | "node_modules/tom-select/dist/css/tom-select.min.css.map",
83 | ]).pipe(gulp.dest("dist/lib/tom-select"));;
84 | }
85 |
86 | /**
87 | * Watch for changes for each build step
88 | */
89 | export function watch() {
90 | tomSelect();
91 | gulp.watch(`${sourceDirectory}/**/*.${sourceFileExtension}`, { ignoreInitial: false }, buildCode);
92 | gulp.watch(`${stylesDirectory}/**/*.${stylesExtension}`, { ignoreInitial: false }, buildStyles);
93 | gulp.watch(
94 | staticFiles.map((file) => `${sourceDirectory}/${file}`),
95 | { ignoreInitial: false },
96 | copyFiles,
97 | );
98 | }
99 |
100 | export const build = gulp.series(clean, gulp.parallel(buildCode, buildStyles, tomSelect, copyFiles));
101 |
102 | /********************/
103 | /* CLEAN */
104 | /********************/
105 |
106 | /**
107 | * Remove built files from `dist` folder while ignoring source files
108 | */
109 | export async function clean() {
110 | const files = [...staticFiles, "styles", "module"];
111 |
112 | console.log(" ", "Files to clean:");
113 | console.log(" ", files.join("\n "));
114 |
115 | for (const filePath of files) {
116 | await fs.remove(`${distDirectory}/${filePath}`);
117 | }
118 | }
119 |
120 | /********************/
121 | /* LINK */
122 | /********************/
123 |
124 | /**
125 | * Get the data paths of Foundry VTT based on what is configured in `foundryconfig.json`
126 | */
127 | function getDataPaths() {
128 | const config = fs.readJSONSync("foundryconfig.json");
129 | const dataPath = config?.dataPath;
130 |
131 | if (dataPath) {
132 | const dataPaths = Array.isArray(dataPath) ? dataPath : [dataPath];
133 |
134 | return dataPaths.map((dataPath) => {
135 | if (typeof dataPath !== "string") {
136 | throw new Error(`Property dataPath in foundryconfig.json is expected to be a string or an array of strings, but found ${dataPath}`);
137 | }
138 | if (!fs.existsSync(path.resolve(dataPath))) {
139 | throw new Error(`The dataPath ${dataPath} does not exist on the file system`);
140 | }
141 | return path.resolve(dataPath);
142 | });
143 | } else {
144 | throw new Error("No dataPath defined in foundryconfig.json");
145 | }
146 | }
147 |
148 | /**
149 | * Link build to User Data folder
150 | */
151 | export async function link() {
152 | let destinationDirectory;
153 | if (fs.existsSync(path.resolve(sourceDirectory, "module.json"))) {
154 | destinationDirectory = "modules";
155 | } else {
156 | throw new Error("Could not find module.json");
157 | }
158 |
159 | const linkDirectories = getDataPaths().map((dataPath) => path.resolve(dataPath, "Data", destinationDirectory, packageId));
160 |
161 | const argv = yargs(hideBin(process.argv)).option("clean", {
162 | alias: "c",
163 | type: "boolean",
164 | default: false,
165 | }).argv;
166 | const clean = argv.c;
167 |
168 | for (const linkDirectory of linkDirectories) {
169 | if (clean) {
170 | console.log(`Removing build in ${linkDirectory}.`);
171 |
172 | await fs.remove(linkDirectory);
173 | } else if (!fs.existsSync(linkDirectory)) {
174 | console.log(`Linking dist to ${linkDirectory}.`);
175 | await fs.ensureDir(path.resolve(linkDirectory, ".."));
176 | await fs.symlink(path.resolve(distDirectory), linkDirectory);
177 | } else {
178 | console.log(`Skipped linking to ${linkDirectory}, as it already exists.`);
179 | }
180 | }
181 | }
182 |
--------------------------------------------------------------------------------
/src/module/providers/cyberpunk-red-core.js:
--------------------------------------------------------------------------------
1 | import LanguageProvider from "./templates/Base.js";
2 |
3 | export default class cyberpunkRedLanguageProvider extends LanguageProvider {
4 | defaultFont = "Olde English";
5 |
6 | languages = {
7 | streetslang: {
8 | font: "Olde English",
9 | },
10 | arabic: {
11 | font: "Ar Ciela",
12 | },
13 | bengali: {
14 | font: "Olde English",
15 | },
16 | berber: {
17 | font: "Olde English",
18 | },
19 | burmese: {
20 | font: "Ar Ciela",
21 | },
22 | cantonese: {
23 | font: "Oriental",
24 | },
25 | chinese: {
26 | font: "Oriental",
27 | },
28 | cree: {
29 | font: "Olde English",
30 | },
31 | creole: {
32 | font: "Olde English",
33 | },
34 | dari: {
35 | font: "Olde English",
36 | },
37 | dutch: {
38 | font: "Olde English",
39 | },
40 | english: {
41 | font: "Olde English",
42 | },
43 | farsi: {
44 | font: "Ar Ciela",
45 | },
46 | filipino: {
47 | font: "Ar Ciela",
48 | },
49 | finnish: {
50 | font: "Kremlin Premier",
51 | },
52 | french: {
53 | font: "Olde English",
54 | },
55 | german: {
56 | font: "Miroslav Normal",
57 | },
58 | guarani: {
59 | font: "Olde English",
60 | },
61 | hausa: {
62 | font: "Olde English",
63 | },
64 | hawaiian: {
65 | font: "Olde English",
66 | },
67 | hebrew: {
68 | font: "Olde English",
69 | },
70 | hindi: {
71 | font: "Ar Ciela",
72 | },
73 | indonesian: {
74 | font: "Ar Ciela",
75 | },
76 | italian: {
77 | font: "Olde English",
78 | },
79 | japanese: {
80 | font: "Oriental",
81 | },
82 | khmer: {
83 | font: "Ar Ciela",
84 | },
85 | korean: {
86 | font: "Oriental",
87 | },
88 | lingala: {
89 | font: "Olde English",
90 | },
91 | malayan: {
92 | font: "Ar Ciela",
93 | },
94 | mandarin: {
95 | font: "Oriental",
96 | },
97 | maori: {
98 | font: "Olde English",
99 | },
100 | mayan: {
101 | font: "Olde English",
102 | },
103 | mongolian: {
104 | font: "Ar Ciela",
105 | },
106 | navajo: {
107 | font: "Olde English",
108 | },
109 | nepali: {
110 | font: "Ar Ciela",
111 | },
112 | norwegian: {
113 | font: "Miroslav Normal",
114 | },
115 | oromo: {
116 | font: "Olde English",
117 | },
118 | pamanyungan: {
119 | font: "Olde English",
120 | },
121 | polish: {
122 | font: "Kremlin Premier",
123 | },
124 | portuguese: {
125 | font: "Olde English",
126 | },
127 | quechua: {
128 | font: "Olde English",
129 | },
130 | romanian: {
131 | font: "Kremlin Premier",
132 | },
133 | russian: {
134 | font: "Kremlin Premier",
135 | },
136 | sinhalese: {
137 | font: "Olde English",
138 | },
139 | spanish: {
140 | font: "Olde English",
141 | },
142 | swahili: {
143 | font: "Olde English",
144 | },
145 | tahitian: {
146 | font: "Olde English",
147 | },
148 | tamil: {
149 | font: "Olde English",
150 | },
151 | turkish: {
152 | font: "Ar Ciela",
153 | },
154 | twi: {
155 | font: "Olde English",
156 | },
157 | ukrainian: {
158 | font: "Kremlin Premier",
159 | },
160 | urdu: {
161 | font: "Ar Ciela",
162 | },
163 | vietnamese: {
164 | font: "Ar Ciela",
165 | },
166 | yoruba: {
167 | font: "Olde English",
168 | },
169 | };
170 |
171 | get settings() {
172 | return {
173 | LanguageRegex: {
174 | type: String,
175 | default: game.i18n.localize("POLYGLOT.Generic.Language"),
176 | },
177 | };
178 | }
179 |
180 | async getLanguages() {
181 | const originalLanguages = {
182 | streetslang: "Streetslang",
183 | arabic: "Arabic",
184 | bengali: "Bengali",
185 | berber: "Berber",
186 | burmese: "Burmese",
187 | cantonese: "Cantonese",
188 | chinese: "Scrapbook Chinese",
189 | cree: "Cree",
190 | creole: "Creole",
191 | dari: "Dari",
192 | dutch: "Dutch",
193 | english: "English",
194 | farsi: "Farsi",
195 | filipino: "Filipino",
196 | finnish: "Finnish",
197 | french: "French",
198 | german: "German",
199 | guarani: "Guarani",
200 | hausa: "Hausa",
201 | hawaiian: "Hawaiian",
202 | hebrew: "Hebrew",
203 | hindi: "Hindi",
204 | indonesian: "Indonesian",
205 | italian: "Italian",
206 | japanese: "Japanese",
207 | khmer: "Khmer",
208 | korean: "Korean",
209 | lingala: "Lingala",
210 | malayan: "Malayan",
211 | mandarin: "Mandarin",
212 | maori: "Maori",
213 | mayan: "Mayan",
214 | mongolian: "Mongolian",
215 | navajo: "Navajo",
216 | nepali: "Nepali",
217 | norwegian: "Norwegian",
218 | oromo: "Oromo",
219 | pamanyungan: "Pama-nyungan",
220 | polish: "Polish",
221 | portuguese: "Portuguese",
222 | quechua: "Quechua",
223 | romanian: "Romanian",
224 | russian: "Russian",
225 | sinhalese: "Sinhalese",
226 | spanish: "Spanish",
227 | swahili: "Swahili",
228 | tahitian: "Tahitian",
229 | tamil: "Tamil",
230 | turkish: "Turkish",
231 | twi: "Twi",
232 | ukrainian: "Ukrainian",
233 | urdu: "Urdu",
234 | vietnamese: "Vietnamese",
235 | yoruba: "Yoruba",
236 | };
237 | const langs = {};
238 | const languagesSetting = game.settings.get("polyglot", "Languages");
239 | for (let lang in originalLanguages) {
240 | const label = originalLanguages[lang];
241 | if (!label) continue;
242 | langs[lang] = {
243 | label,
244 | font: languagesSetting[lang]?.font || this.languages[lang]?.font || this.defaultFont,
245 | rng: languagesSetting[lang]?.rng ?? "default",
246 | };
247 | }
248 | this.languages = this.replaceLanguages ? {} : langs;
249 | }
250 |
251 | getUserLanguages(actor) {
252 | let knownLanguages = new Set();
253 | let literateLanguages = new Set();
254 | const languageRegex = game.settings.get("polyglot", "LanguageRegex");
255 | let myRegex = new RegExp(`${languageRegex}\\s*\\((.+)\\)`, "i");
256 | for (let item of actor.items) {
257 | if (item.type === "skill") {
258 | if (myRegex.test(item.name)) {
259 | knownLanguages.add(item.name.match(myRegex)[1].trim().toLowerCase());
260 | }
261 | }
262 | }
263 | return [knownLanguages, literateLanguages];
264 | }
265 | }
266 |
--------------------------------------------------------------------------------
/src/module/providers/dnd5e.js:
--------------------------------------------------------------------------------
1 | import LanguageProvider from "./templates/Base.js";
2 |
3 | export default class dnd5eLanguageProvider extends LanguageProvider {
4 | languages = {
5 | aarakocra: {
6 | font: "Olde Thorass",
7 | },
8 | abyssal: {
9 | font: "Infernal",
10 | },
11 | aquan: {
12 | font: "Dethek",
13 | },
14 | auran: {
15 | font: "Dethek",
16 | },
17 | celestial: {
18 | font: "Celestial",
19 | },
20 | common: {
21 | font: "Thorass",
22 | },
23 | deep: {
24 | font: "Ar Ciela",
25 | },
26 | draconic: {
27 | font: "Iokharic",
28 | },
29 | druidic: {
30 | font: "Jungle Slang",
31 | },
32 | dwarvish: {
33 | font: "Dethek",
34 | },
35 | elvish: {
36 | font: "Espruar",
37 | },
38 | giant: {
39 | font: "Dethek",
40 | },
41 | gith: {
42 | font: "Pulsian",
43 | },
44 | gnoll: {
45 | font: "Kargi",
46 | },
47 | gnomish: {
48 | font: "Dethek",
49 | },
50 | goblin: {
51 | font: "Dethek",
52 | },
53 | halfling: {
54 | font: "Thorass",
55 | },
56 | ignan: {
57 | font: "Dethek",
58 | },
59 | infernal: {
60 | font: "Infernal",
61 | },
62 | orc: {
63 | font: "Dethek",
64 | },
65 | primordial: {
66 | font: "Dethek",
67 | },
68 | sylvan: {
69 | font: "Olde Espruar",
70 | },
71 | terran: {
72 | font: "Dethek",
73 | },
74 | cant: {
75 | font: "Thorass",
76 | },
77 | undercommon: {
78 | font: "High Drowic",
79 | },
80 | };
81 |
82 | get settings() {
83 | return {
84 | "DND5E.SpecialLanguages": {
85 | type: String,
86 | default: game.i18n.localize("DND5E.Language.Language.Common"),
87 | }
88 | };
89 | }
90 |
91 | languageRarities = ["standard", "exotic"];
92 |
93 | multiLanguages = {
94 | primordial: {
95 | parent: "exotic"
96 | }
97 | };
98 |
99 | async getLanguages() {
100 | const languagesSetting = game.settings.get("polyglot", "Languages");
101 | const langs = {};
102 | if (this.replaceLanguages) {
103 | CONFIG.DND5E.languages = {};
104 | this.languageRarities = [];
105 | this.multiLanguages = {};
106 | }
107 | const systemLanguages = CONFIG.DND5E.languages;
108 | const getLang = (key, target) => {
109 | const processLanguage = (label) => {
110 | if (label) {
111 | langs[key] = {
112 | label,
113 | font: languagesSetting[key]?.font || this.languages[key]?.font || this.defaultFont,
114 | rng: languagesSetting[key]?.rng ?? "default",
115 | };
116 | }
117 | };
118 |
119 | if (key in this.multiLanguages) {
120 | processLanguage(game.i18n.localize(target[key].label));
121 | }
122 | if (target[key].children) {
123 | Object.keys(target[key].children).forEach((kkey) => {
124 | getLang(kkey, target[key].children);
125 | });
126 | } else {
127 | processLanguage(game.i18n.localize(target[key]));
128 | }
129 | };
130 | Object.keys(systemLanguages).forEach((key) => {
131 | if (this.languageRarities.includes(key)) {
132 | Object.keys(systemLanguages[key].children).forEach((kkey) => {
133 | getLang(kkey, systemLanguages[key].children);
134 | });
135 | } else {
136 | getLang(key, systemLanguages);
137 | }
138 | });
139 | this.languages = langs;
140 | }
141 |
142 | getUserLanguages(actor) {
143 | let knownLanguages = new Set();
144 | let literateLanguages = new Set();
145 | if (actor.system?.traits?.languages) {
146 | for (let lang of actor.system.traits.languages.value) {
147 | if (this.languageRarities.includes(lang)) {
148 | for (let l in CONFIG.DND5E.languages[lang].children) {
149 | knownLanguages.add(l.trim().replace(/[\s']/g, "_"));
150 | }
151 | } else {
152 | knownLanguages.add(lang.trim().replace(/[\s']/g, "_"));
153 | }
154 | if (lang in this.multiLanguages) {
155 | const parent = this.multiLanguages[lang].parent;
156 | let languages;
157 | if (parent) {
158 | const parentChildren = CONFIG.DND5E.languages[parent].children;
159 | languages = parentChildren[lang].children;
160 | } else {
161 | languages = CONFIG.DND5E.languages[lang].children;
162 | }
163 | for (let l in languages) {
164 | knownLanguages.add(l.trim().replace(/[\s']/g, "_"));
165 | }
166 | }
167 | }
168 | if (actor.system.traits.languages.custom) {
169 | const defaultSpecialLanguage = game.settings
170 | .get("polyglot", "DND5E.SpecialLanguages")
171 | .trim()
172 | .toLowerCase();
173 | // eslint-disable-next-line no-unsafe-optional-chaining
174 | for (let lang of actor.system.traits.languages?.custom.split(/[;]/)) {
175 | let key = lang.trim().toLowerCase();
176 | try {
177 | if (/(usually common)|(in life)|(its creator)|(?<=any)(.*)(?=language)/i.test(key)) {
178 | knownLanguages.add(defaultSpecialLanguage);
179 | } else if (/(?<=usually)(.*)(?=\))/g.test(key)) {
180 | key = key.match(/(?<=usually)(.*)(?=\))/g)[0].trim();
181 | knownLanguages.add(key);
182 | } else if (/(?<=understands)(.*)(?=but can't speak it)/g.test(key)) {
183 | key = key.match(/(?<=understands)(.*)(?=but can't speak it)/g)[0].trim();
184 | knownLanguages.add(key);
185 | } else if (/(.*)(?=plus)/.test(key)) {
186 | key = key.match(/(.*)(?=plus)/)[0].trim();
187 | knownLanguages.add(key);
188 | } else {
189 | knownLanguages.add(key);
190 | }
191 | } catch(err) {
192 | console.error(
193 | `Polyglot | Failed to get custom language "${key}" from actor "${actor.name}".`,
194 | err
195 | );
196 | }
197 | }
198 | }
199 | }
200 | return [knownLanguages, literateLanguages];
201 | }
202 |
203 | filterUsers(ownedActors) {
204 | const filtered = super.filterUsers(ownedActors);
205 | const party = game.settings.get("dnd5e", "primaryParty")?.actor;
206 | if (party?.system?.members.length) {
207 | const members = Array.from(party.system.members.ids);
208 | const users = filtered.filter((u) => ownedActors.some((actor) => members.includes(actor.id) && actor.testUserPermission(u, "OWNER")));
209 | return users;
210 | }
211 | return filtered;
212 | }
213 | }
214 |
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2022 Johannes Loher
2 | #
3 | # SPDX-License-Identifier: MIT
4 |
5 | name: Release
6 |
7 | on:
8 | release:
9 | types: [published]
10 |
11 | env:
12 | package_type: module
13 | node_version: 22
14 |
15 | jobs:
16 | lint:
17 | runs-on: ubuntu-latest
18 | steps:
19 | - name: Checkout code
20 | uses: actions/checkout@v5
21 |
22 | - name: Install node
23 | uses: actions/setup-node@v6
24 | with:
25 | node-version: ${{ env.node_version }}
26 |
27 | - name: Cache Node.js modules
28 | uses: actions/cache@v4
29 | with:
30 | path: .npm
31 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }}
32 | restore-keys: |
33 | ${{ runner.OS }}-node-
34 | ${{ runner.OS }}-
35 |
36 | - name: Install dependencies
37 | run: npm ci --cache .npm --prefer-offline
38 |
39 | - name: Lint
40 | run: npm run lint
41 |
42 | build:
43 | runs-on: ubuntu-latest
44 | steps:
45 | - name: Checkout code
46 | uses: actions/checkout@v5
47 |
48 | - name: Install node
49 | uses: actions/setup-node@v6
50 | with:
51 | node-version: ${{ env.node_version }}
52 |
53 | - name: Cache Node.js modules
54 | uses: actions/cache@v4
55 | with:
56 | path: .npm
57 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }}
58 | restore-keys: |
59 | ${{ runner.OS }}-node-
60 | ${{ runner.OS }}-
61 |
62 | - name: Install dependencies
63 | run: npm ci --cache .npm --prefer-offline
64 |
65 | - name: Extract tag version number
66 | id: get_version
67 | uses: battila7/get-version-action@v2
68 |
69 | - name: Substitute Manifest and Download Links For Versioned Ones
70 | id: sub_manifest_link_version
71 | uses: microsoft/variable-substitution@v1
72 | with:
73 | files: "src/${{ env.package_type }}.json"
74 | env:
75 | version: ${{ steps.get_version.outputs.version-without-v }}
76 | url: https://github.com/${{ github.repository }}
77 | manifest: https://github.com/${{ github.repository }}/releases/latest/download/${{ env.package_type }}.json
78 | download: https://github.com/${{ github.repository }}/releases/download/${{ github.event.release.tag_name }}/${{ env.package_type }}.zip
79 |
80 | - name: Build
81 | run: npm run build
82 |
83 | - name: Archive production artifacts
84 | uses: actions/upload-artifact@v4
85 | with:
86 | name: dist
87 | path: dist
88 |
89 | publish:
90 | needs:
91 | - lint
92 | - build
93 | runs-on: ubuntu-latest
94 | steps:
95 | - name: Checkout code
96 | uses: actions/checkout@v5
97 |
98 | - name: Download production artifacts for publication
99 | uses: actions/download-artifact@v5
100 | with:
101 | name: dist
102 | path: dist
103 |
104 | - name: Create zip file
105 | working-directory: ./dist
106 | run: zip -r ../${{ env.package_type }}.zip .
107 |
108 | - name: Create release
109 | id: create_version_release
110 | uses: ncipollo/release-action@v1
111 | with:
112 | allowUpdates: true
113 | name: ${{ github.event.release.name }}
114 | token: ${{ secrets.GITHUB_TOKEN }}
115 | artifacts: "./dist/${{ env.package_type }}.json, ./${{ env.package_type }}.zip"
116 | tag: ${{ github.event.release.tag_name }}
117 | body: ${{ github.event.release.body }}
118 |
119 | - name: Get Module ID
120 | id: moduleID
121 | uses: notiz-dev/github-action-json-property@release
122 | with:
123 | path: "./dist/${{ env.package_type }}.json"
124 | prop_path: "id"
125 |
126 | - name: Get mininum
127 | id: minimum
128 | uses: notiz-dev/github-action-json-property@release
129 | with:
130 | path: "./dist/${{ env.package_type }}.json"
131 | prop_path: "compatibility.minimum"
132 |
133 | - name: Get verified
134 | id: verified
135 | uses: notiz-dev/github-action-json-property@release
136 | with:
137 | path: "./dist/${{ env.package_type }}.json"
138 | prop_path: "compatibility.verified"
139 |
140 | - name: Extract tag version number
141 | id: get_version
142 | uses: battila7/get-version-action@v2
143 |
144 | - name: Foundry Release API
145 | uses: fjogeleit/http-request-action@v1
146 | with:
147 | url: "https://api.foundryvtt.com/_api/packages/release_version"
148 | method: "POST"
149 | customHeaders: '{"Content-Type": "application/json", "Authorization" : "${{ secrets.FOUNDRY_KEY }}"}'
150 | data: '{"id": "${{ steps.moduleID.outputs.prop }}", "release": {"version": "${{ steps.get_version.outputs.version-without-v }}", "manifest": "https://github.com/${{ github.repository }}/releases/download/${{ github.event.release.tag_name }}/${{ env.package_type }}.json", "notes": "https://github.com/${{ github.repository }}/releases/tag/${{ github.event.release.tag_name }}/", "compatibility" : {"minimum": "${{ steps.minimum.outputs.prop }}", "verified": "${{ steps.verified.outputs.prop }}"}}}'
151 | preventFailureOnNoResponse: true
152 |
--------------------------------------------------------------------------------
/.eslintrc.cjs:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2022 Johannes Loher
2 | // SPDX-FileCopyrightText: 2022 David Archibald
3 | //
4 | // SPDX-License-Identifier: MIT
5 |
6 | module.exports = {
7 | parserOptions: {
8 | ecmaVersion: 13,
9 | extraFileExtensions: [".cjs", ".mjs"],
10 | sourceType: "module",
11 | },
12 |
13 | env: {
14 | browser: true,
15 | es6: true,
16 | jquery: true,
17 | },
18 |
19 | extends: ["eslint:recommended", "@typhonjs-fvtt/eslint-config-foundry.js/0.8.0"],
20 |
21 | plugins: [],
22 |
23 | rules: {
24 | "array-bracket-spacing": ["warn", "never"],
25 | "array-callback-return": "warn",
26 | "arrow-spacing": "warn",
27 | "brace-style": "warn",
28 | "comma-dangle": ["warn", "only-multiline"],
29 | "comma-style": "warn",
30 | "computed-property-spacing": "warn",
31 | "constructor-super": "error",
32 | "default-param-last": "warn",
33 | "dot-location": ["warn", "property"],
34 | "eol-last": ["error", "always"],
35 | eqeqeq: ["warn", "smart"],
36 | "func-call-spacing": "warn",
37 | "func-names": ["warn", "never"],
38 | "getter-return": "warn",
39 | indent: ["warn", "tab", { SwitchCase: 1 }],
40 | "lines-between-class-members": "warn",
41 | "new-parens": ["warn", "always"],
42 | "no-alert": "warn",
43 | "no-array-constructor": "warn",
44 | "no-class-assign": "warn",
45 | "no-compare-neg-zero": "warn",
46 | "no-cond-assign": "warn",
47 | "no-const-assign": "error",
48 | "no-constant-condition": "warn",
49 | "no-constructor-return": "warn",
50 | "no-delete-var": "warn",
51 | "no-dupe-args": "warn",
52 | "no-dupe-class-members": "warn",
53 | "no-dupe-keys": "warn",
54 | "no-duplicate-case": "warn",
55 | "no-duplicate-imports": ["warn", { includeExports: true }],
56 | "no-else-return": "warn",
57 | "no-empty": ["warn", { allowEmptyCatch: true }],
58 | "no-empty-character-class": "warn",
59 | "no-empty-pattern": "warn",
60 | "no-func-assign": "warn",
61 | "no-global-assign": "warn",
62 | "no-implicit-coercion": ["warn", { allow: ["!!"] }],
63 | "no-implied-eval": "warn",
64 | "no-import-assign": "warn",
65 | "no-invalid-regexp": "warn",
66 | "no-irregular-whitespace": "warn",
67 | "no-iterator": "warn",
68 | "no-lone-blocks": "warn",
69 | "no-lonely-if": "warn",
70 | "no-misleading-character-class": "warn",
71 | "no-mixed-operators": "warn",
72 | "no-multi-str": "warn",
73 | "no-multiple-empty-lines": ["warn", { max: 1 }],
74 | "no-new-func": "warn",
75 | "no-new-object": "warn",
76 | "no-new-symbol": "warn",
77 | "no-new-wrappers": "warn",
78 | "no-nonoctal-decimal-escape": "warn",
79 | "no-obj-calls": "warn",
80 | "no-octal": "warn",
81 | "no-octal-escape": "warn",
82 | "no-promise-executor-return": "warn",
83 | "no-proto": "warn",
84 | "no-regex-spaces": "warn",
85 | "no-script-url": "warn",
86 | "no-self-assign": "warn",
87 | "no-self-compare": "warn",
88 | "no-setter-return": "warn",
89 | "no-sequences": "warn",
90 | "no-template-curly-in-string": "warn",
91 | "no-this-before-super": "error",
92 | "no-unexpected-multiline": "warn",
93 | "no-unmodified-loop-condition": "warn",
94 | "no-unneeded-ternary": "warn",
95 | "no-unreachable": "warn",
96 | "no-unreachable-loop": "warn",
97 | "no-unsafe-negation": ["warn", { enforceForOrderingRelations: true }],
98 | "no-unsafe-optional-chaining": ["warn", { disallowArithmeticOperators: true }],
99 | "no-unused-expressions": "warn",
100 | "no-useless-backreference": "warn",
101 | "no-useless-call": "warn",
102 | "no-useless-catch": "warn",
103 | "no-useless-computed-key": ["warn", { enforceForClassMembers: true }],
104 | "no-useless-concat": "warn",
105 | "no-useless-constructor": "warn",
106 | "no-useless-rename": "warn",
107 | "no-useless-return": "warn",
108 | "no-var": "warn",
109 | "no-void": "warn",
110 | "no-whitespace-before-property": "warn",
111 | "prefer-numeric-literals": "warn",
112 | "prefer-object-spread": "warn",
113 | "prefer-regex-literals": "warn",
114 | "prefer-spread": "warn",
115 | "rest-spread-spacing": ["warn", "never"],
116 | "semi-spacing": "warn",
117 | "semi-style": ["warn", "last"],
118 | "space-unary-ops": ["warn", { words: true, nonwords: false }],
119 | "switch-colon-spacing": "warn",
120 | "symbol-description": "warn",
121 | "template-curly-spacing": ["warn", "never"],
122 | "unicode-bom": ["warn", "never"],
123 | "use-isnan": ["warn", { enforceForSwitchCase: true, enforceForIndexOf: true }],
124 | "valid-typeof": ["warn", { requireStringLiterals: true }],
125 | "wrap-iife": ["warn", "inside"],
126 |
127 | "arrow-parens": ["warn", "always"],
128 | "comma-spacing": "warn",
129 | "dot-notation": "warn",
130 | "key-spacing": "warn",
131 | "keyword-spacing": ["warn", { overrides: { catch: { before: true, after: false } } }],
132 | "max-len": [
133 | "warn",
134 | {
135 | code: 120,
136 | ignoreComments: true,
137 | ignoreTrailingComments: true,
138 | ignoreUrls: true,
139 | ignoreStrings: true,
140 | ignoreTemplateLiterals: true,
141 | ignoreRegExpLiterals: true,
142 | },
143 | ],
144 | "no-extra-boolean-cast": ["warn", { enforceForLogicalOperands: true }],
145 | "no-extra-semi": "warn",
146 | "no-multi-spaces": ["warn", { ignoreEOLComments: true }],
147 | "no-throw-literal": "error",
148 | "no-trailing-spaces": "warn",
149 | "no-useless-escape": "warn",
150 | "no-unused-vars": ["warn", { args: "none" }],
151 | "nonblock-statement-body-position": ["warn", "beside"],
152 | "one-var": ["warn", "never"],
153 | "operator-linebreak": [
154 | "warn",
155 | "before",
156 | {
157 | overrides: { "=": "after", "+=": "after", "-=": "after" },
158 | },
159 | ],
160 | "prefer-template": "warn",
161 | "quote-props": ["warn", "as-needed", { keywords: false }],
162 | quotes: ["warn", "double", { avoidEscape: true, allowTemplateLiterals: false }],
163 | semi: "warn",
164 | "space-before-blocks": ["warn", "always"],
165 | "space-before-function-paren": [
166 | "warn",
167 | {
168 | anonymous: "always",
169 | named: "never",
170 | asyncArrow: "always",
171 | },
172 | ],
173 | "spaced-comment": "warn",
174 | },
175 |
176 | globals: {
177 | globalThis: false,
178 | GURPS: false,
179 | JournalTextPageSheet: false,
180 | ProseMirror: false,
181 | TomSelect: false,
182 | Tour: false,
183 | },
184 |
185 | overrides: [
186 | {
187 | files: ["./*.js", "./*.cjs", "./*.mjs"],
188 | env: {
189 | node: true,
190 | },
191 | },
192 | ],
193 | };
194 |
--------------------------------------------------------------------------------
/src/module/forms/LanguageSettings.js:
--------------------------------------------------------------------------------
1 | import { providerKeys } from "../providers/_shared.js";
2 |
3 | export class PolyglotLanguageSettings extends FormApplication {
4 | /**
5 | * Default Options for this FormApplication
6 | */
7 | static get defaultOptions() {
8 | const classes = ["sheet", "polyglot", "polyglot-language-settings"];
9 | if (game.system.id === "wfrp4e") {
10 | classes.push(game.system.id);
11 | }
12 | return foundry.utils.mergeObject(super.defaultOptions, {
13 | id: "polyglot-language-form",
14 | title: "Polyglot Language Settings",
15 | template: "./modules/polyglot/templates/LanguageSettings.hbs",
16 | classes,
17 | width: 600,
18 | height: 680,
19 | closeOnSubmit: true,
20 | resizable: true,
21 | });
22 | }
23 |
24 | getData() {
25 | const data = {};
26 | const selectedProvider = game.polyglot.languageProvider.id;
27 | // Insert all speed providers into the template data
28 | data.providers = Object.values(game.polyglot.api.providers).map((languageProvider) => {
29 | const provider = {};
30 | provider.id = languageProvider.id;
31 | let dotPosition = provider.id.indexOf(".");
32 | if (dotPosition === -1) dotPosition = provider.id.length;
33 | const type = provider.id.substring(0, dotPosition);
34 | const id = provider.id.substring(dotPosition + 1);
35 | if (type === "native") {
36 | let title = id === game.system.id || id === providerKeys[game.system.id] ? game.system.title : id;
37 | provider.selectTitle = (`${game.i18n.localize("POLYGLOT.LanguageProvider.choices.native")} ${title}`).trim();
38 | } else {
39 | const name = type === "module" ? game.modules.get(id).title : game.system.title;
40 | provider.selectTitle = game.i18n.format(`POLYGLOT.LanguageProvider.choices.${type}`, { name });
41 | }
42 | provider.isSelected = provider.id === selectedProvider;
43 | return provider;
44 | });
45 |
46 | data.providerSelection = {
47 | id: "languageProvider",
48 | name: game.i18n.localize("POLYGLOT.LanguageProvider.name"),
49 | hint: game.i18n.localize("POLYGLOT.LanguageProvider.hint"),
50 | type: String,
51 | choices: data.providers.reduce((choices, provider) => {
52 | choices[provider.id] = provider.selectTitle;
53 | return choices;
54 | }, {}),
55 | value: selectedProvider,
56 | isCheckbox: false,
57 | isSelect: true,
58 | isRange: false,
59 | };
60 |
61 | this.languageProvider = data.providerSelection.value;
62 |
63 | function prepSetting(key) {
64 | const { name, hint } = game.settings.settings.get(`polyglot.${key}`);
65 | const value = game.settings.get("polyglot", `${key}`);
66 | return { value, name, hint };
67 | }
68 |
69 | const { name, hint, type } = game.settings.settings.get("polyglot.Languages");
70 | const value = Object.fromEntries(
71 | Object.entries(game.settings.get("polyglot", "Languages"))
72 | .sort()
73 | .filter(([key]) =>
74 | ![game.polyglot.omniglot, game.polyglot.comprehendLanguages, game.polyglot.truespeech].includes(key)
75 | )
76 | );
77 |
78 | const languages = {
79 | name,
80 | hint,
81 | value,
82 | fields: type.element.fields
83 | };
84 |
85 | const alphabets = prepSetting("Alphabets");
86 |
87 | return {
88 | data,
89 | languages,
90 | alphabets,
91 | rng: {
92 | default: "POLYGLOT.RandomizeRunesOptions.a",
93 | unique: "POLYGLOT.RandomizeRunesOptions.b",
94 | none: "POLYGLOT.RandomizeRunesOptions.c"
95 | }
96 | };
97 | }
98 |
99 | async activateListeners(html) {
100 | super.activateListeners(html);
101 | html.find(".polyglot-languageProvider").on("change", (event) => {
102 | const languagesList = html.find(".polyglot-languages-list")[0];
103 | const languagesWarning = html.find(".polyglot-languages-warn")[0];
104 | const shouldDisplayLanguages = this.languageProvider === event.target.value;
105 | languagesList.style.display = shouldDisplayLanguages ? "block" : "none";
106 | languagesWarning.style.display = shouldDisplayLanguages ? "none" : "block";
107 | });
108 | html.find(".polyglot-alphabet").each(function () {
109 | const font = this.previousSibling.previousSibling.children[0].value; // selectatr's value
110 | this.style.font = game.polyglot.languageProvider.fonts[font];
111 | });
112 | html.find(".selectatr").on("change", (event) => {
113 | const font = event.target.value;
114 | const parentElement = event.target.parentElement;
115 | const nextSibling = parentElement.nextSibling;
116 | if (nextSibling && nextSibling.nextSibling) {
117 | const elementToChange = nextSibling.nextSibling;
118 | const alphabet = game.polyglot.languageProvider.fonts[font];
119 | elementToChange.style.font = alphabet;
120 | }
121 | });
122 | html.find("button").on("click", async (event) => {
123 | if (event.currentTarget?.dataset?.action === "reset") {
124 | const current = game.settings.get("polyglot", "Languages");
125 | await game.settings.set("polyglot", "Languages", {});
126 | const defaultProvider = new game.polyglot.languageProvider.constructor();
127 | defaultProvider.getLanguages();
128 | const diff = foundry.utils.diffObject(defaultProvider.languages, current);
129 | await game.settings.set("polyglot", "Languages", defaultProvider.languages);
130 | if (Object.keys(diff).length) SettingsConfig.reloadConfirm({ world: true });
131 | this.close();
132 | }
133 | });
134 | }
135 |
136 | /**
137 | * Executes on form submission
138 | * @param {Event} ev - the form submission event
139 | * @param {Object} formData - the form data
140 | */
141 | async _updateObject(ev, formData) {
142 | const languageProvider = game.settings.get("polyglot", "languageProvider");
143 | if (languageProvider !== formData.languageProvider) {
144 | await game.settings.set("polyglot", "languageProvider", formData.languageProvider);
145 | game.polyglot.api.updateProvider();
146 | await game.settings.set("polyglot", "Alphabets", game.polyglot.languageProvider.fonts);
147 | await game.settings.set("polyglot", "Languages", game.polyglot.languageProvider.languages);
148 | } else {
149 | const languages = foundry.utils.expandObject(formData).languages;
150 | const current = game.settings.get("polyglot", "Languages");
151 | const diff = foundry.utils.diffObject(current, languages);
152 | if (!Object.keys(diff).length) return;
153 | game.polyglot.languageProvider.languages = languages;
154 | await game.settings.set("polyglot", "Languages", languages);
155 | }
156 | SettingsConfig.reloadConfirm({ world: true });
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/src/lang/es.json:
--------------------------------------------------------------------------------
1 | {
2 | "I18N": {
3 | "LANGUAGE": "Español",
4 | "MAINTAINERS": "@Viriato139ac#0342, Juanfrank"
5 | },
6 | "POLYGLOT": {
7 | "DefaultAlphabet": "Alfabeto por defecto",
8 | "FontSettings": "Ajustes de fuentes",
9 | "LanguageSettings": "Ajustes de idiomas",
10 | "ChatSettings": "Ajustes del chat",
11 | "Languages.title": "Idiomas",
12 | "Languages.hint": "Cambia el alfabeto de los idiomas.",
13 | "Font": "Fuente",
14 | "Fonts": "Fuentes",
15 | "FontSize": "Tamaño de fuente (%)",
16 | "AllowOOC.hint": "Determina qué usuarios tendrán sus mensajes codificados al utilizar el chat como jugador. OOC = Out of character (como jugador, o fuera del personaje).",
17 | "AllowOOC.title": "Codificar mensajes OOC del chat",
18 | "AllowOOCOptions": {
19 | "a": "Todos",
20 | "b": "Solo GM",
21 | "c": "Solo jugadores",
22 | "d": "Ninguno"
23 | },
24 | "ComprehendLanguages.hint": "Define un idioma que permite al hablante entender todos los idiomas, pero que no puede ser escrito ni hablado.",
25 | "ComprehendLanguages.title": "Hechizo Comprender Idiomas",
26 | "CustomLanguages.hint": "Define una lista de idiomas personalizados, separados mediante coma, para que sean añadidos al sistema.",
27 | "CustomLanguages.title": "Idiomas personalizados",
28 | "DefaultLanguage.hint": "Nombre del idioma que se selecciona por defecto. Dejar en blanco para utilizar el valor por defecto del sistema.",
29 | "DefaultLanguage.title": "Idioma por defecto",
30 | "DisplayTranslated.hint": "Para los idiomas que se traducen en el chat, muestra el texto original y a continuación la traducción.",
31 | "DisplayTranslated.title": "Mostrar traducciones",
32 | "enableAllFonts": {
33 | "choices": {
34 | "0": "Ninguno",
35 | "1": "Fuentes de Polyglot",
36 | "2": "Fuentes adicionales del programa Base",
37 | "3": "Ambos"
38 | },
39 | "hint": "Añade las fuentes de las opciones seleccionadas a los Ajustes de Fuente e Idioma.",
40 | "title": "Añadir fuentes a los ajustes de los módulos"
41 | },
42 | "ExportFonts.hint": "Añade las fuentes de Polyglot al menú de Fuentes Adicionales del programa Base. Si se desactiva esta opción, se eliminarán todas las fuentes de Polyglot del menú.",
43 | "ExportFonts.title": "Añade las fuentes de Polyglot al programa Base",
44 | "HideTranslation.hint": "Oculta el globo y el texto \"Traducido del\" en el chat a los jugadores. Útil para cuando no se quiere que los jugadores sepan qué idioma se está hablando. Requiere recargar la página.",
45 | "HideTranslation.title": "Ocultar a los jugadores los globos y el texto \"Traducido del\"",
46 | "IgnoreJournalFontSize": {
47 | "title": "Diario: Usar tamaño de fuente normal",
48 | "hint": "Ignora el tamaño de las fuentes de Polyglot en los diarios, haciendo que tengan el mismo tamaño que tendría el texto normal. Útil para ocasiones en las que el formato del diario es importante."
49 | },
50 | "JournalHighlight": {
51 | "hint": "Define la opacidad del resaltado de las fuentes en el diario.",
52 | "title": "Opacidad del resaltado en los diarios (%)"
53 | },
54 | "JournalHighlightColor": {
55 | "hint": "Define el color de resaltado de las fuentes en el diario.",
56 | "title": "Color de resaltado de los disarios"
57 | },
58 | "LanguageProvider": {
59 | "name": "Proveedor de ajustes de idioma",
60 | "hint": "Seleccione quien provee información de alfabetos e idiomas. Se pueden habilitar más proveedores instalando módulos y sistemas. Las opciones que aparecen más abajo dependerán del proveedor seleccionado. ⚠️ Si cambia el proveedor, deberá guardar los cambios y volver a abrir la ventana de configuración.",
61 | "choices": {
62 | "module": "[Módulo] {name}",
63 | "native": "Genérico",
64 | "system": "[Sistema] {name}"
65 | }
66 | },
67 | "languageDataPath": {
68 | "title": "Ruta de idioma",
69 | "hint": "Si el sistema tiene idiomas configurados en los datos de los actores que no se cargan bien, es posible que estén usando otra ruta. Introduzca la ruta en los datos al atributo correcto (p.e. actor.system.languages o actor.system.speak). Este ajuste tiene prioridad sobre los ajustes de RegEx de idioma. Requiere reinicio."
70 | },
71 | "literacyDataPath": {
72 | "title": "Ruta de alfabetización",
73 | "hint": "Lo mismo que el ajuste de la ruta de idioma, pero aplicado a la lectura de diarios. Se necesita rellenar el ajuste de ruta de idioma. Requiere reinicio."
74 | },
75 | "LanguageRegex": {
76 | "title": "RegEx de idioma",
77 | "hint": "Se puede usar para cambiar el término de búsqueda en los objetos de \"Idioma\" a otro diferente, como \"Lengua\"."
78 | },
79 | "logographicalFontToggle.hint": "Reduce a la mitad el tamaño de las frases que usen fuentes logográficas (p. ej. caracteres japoneses o chinos).",
80 | "logographicalFontToggle.title": "Fuentes logográficas",
81 | "RandomizeRunes.hint": "Determina el tipo de aleatoriedad (RNG) utilizada para generar una frase. ⚠️ La opción \"Ninguno\" solamente admite caracteres alfanuméricos (sin acentos).",
82 | "RandomizeRunes.title": "Aleatorizar las runas",
83 | "RandomizeRunesOptions": {
84 | "a": "Por defecto",
85 | "b": "Frases únicas",
86 | "c": "Ninguna ⚠️"
87 | },
88 | "ReplaceLanguages.hint": "Reemplaza el idioma por defecto del sistema por sus idiomas personalizados. El primer idioma personalizado de la lista se convertirá en el nuevo idioma por defecto.",
89 | "ReplaceLanguages.title": "Reemplazar idiomas del sistema",
90 | "RuneRegex": {
91 | "title": "Aleatorizar solo alfanuméricos",
92 | "hint": "Hace que la aleatoriedad ignore los caracteres no alfanuméricos (p. ej. !,.;:?#$\"'). Esto puede causar que algunos de estos caracteres se muestren como un cuadrado (□) en algunas fuentes."
93 | },
94 | "ScrambleGM.title": "Codificar para el GM",
95 | "ScrambleGM.hint": "No traducir el texto para el DJ (remítase al color del globo para ver la perspectiva del icono). Requiere recargar la página.",
96 | "Truespeech.title": "Hechizo Idiomas",
97 | "Truespeech.hint": "Define un idioma que permite al hablante entender todos los idiomas hablados (no puede leer Diarios), y que es entendido por todas las criaturas.",
98 | "Translation": "Traducción",
99 | "TranslatedFrom": "Traducido del ",
100 | "LanguageLabel": "Idioma",
101 | "AlphabetLabel": "Alfabeto",
102 | "LatinAlphabet": "Alfabeto latino",
103 | "ToggleRunes": "Activar/desactivar runas",
104 | "Runes": "Runas",
105 | "UESRPG.Language": "Idioma",
106 | "Generic": {
107 | "Language": "Idioma"
108 | },
109 | "COC7": {
110 | "LanguageOwn": "Lengua propia",
111 | "LanguageAny": "Otras lenguas",
112 | "LanguageOther": "Otras lenguas",
113 | "LanguageSpec": "Lengua"
114 | },
115 | "DND5E": {
116 | "SpecialLanguages.title": "Reemplazar idiomas especiales",
117 | "SpecialLanguages.hint": "Nombre del idioma que reemplazará \"idiomas\" tales como \"todos los idiomas que supo en vida\"."
118 | },
119 | "SWADE": {
120 | "LanguageSkills": "Idioma"
121 | },
122 | "WFRP4E": {
123 | "LanguageSkills": "Idioma"
124 | }
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/module/forms/GeneralSettings.js:
--------------------------------------------------------------------------------
1 | export class PolyglotGeneralSettings extends FormApplication {
2 | static get defaultOptions() {
3 | const classes = ["sheet", "polyglot", "polyglot-general-settings"];
4 | if (game.system.id === "wfrp4e") {
5 | classes.push(game.system.id);
6 | }
7 | return foundry.utils.mergeObject(super.defaultOptions, {
8 | id: "polyglot-general-form",
9 | title: "Polyglot General Settings",
10 | template: "./modules/polyglot/templates/GeneralSettings.hbs",
11 | classes,
12 | tabs: [{ navSelector: ".tabs", contentSelector: ".content", initial: "font" }],
13 | width: 600,
14 | height: "auto",
15 | closeOnSubmit: true,
16 | });
17 | }
18 |
19 | _prepSetting(key, flag = false) {
20 | const settingData = game.settings.settings.get(`polyglot.${key}`);
21 | if (!flag && settingData.polyglotHide) return;
22 |
23 | const { button, choices, default: def, hasTextarea, hint, isColor, name, range, type } = settingData;
24 | let select = [];
25 | if (choices !== undefined) {
26 | const type = foundry.utils.getType(choices);
27 | if (type === "Object") select = Object.entries(choices).map(([key, value]) => ({ key, value }));
28 | else if (type === "Array") select = choices;
29 | }
30 |
31 | let settingType = type.name;
32 | if (button) {
33 | settingType = "Button";
34 | } else if (range) {
35 | settingType = "Range";
36 | } else if (choices) {
37 | settingType = "Select";
38 | } else if (isColor) {
39 | settingType = "Color";
40 | } else if (hasTextarea) {
41 | settingType = "Textarea";
42 | }
43 |
44 | return {
45 | id: key,
46 | value: flag ? (game.user.flags?.polyglot?.[key] ?? def) : game.settings.get("polyglot", key),
47 | name,
48 | hint,
49 | type: settingType,
50 | range,
51 | select,
52 | };
53 | }
54 |
55 | _prepFlag(key) {
56 | return this._prepSetting(key, true);
57 | }
58 |
59 | async resetToDefault(key) {
60 | const defaultValue = game.settings.settings.get(`polyglot.${key}`).default;
61 | await game.settings.set("polyglot", key, defaultValue);
62 | }
63 |
64 | getData() {
65 | const isGM = game.user.isGM;
66 | let data = {};
67 | if (isGM) {
68 | data = {
69 | tabs: {
70 | font: {
71 | icon: "fas fa-cogs",
72 | name: "POLYGLOT.Fonts",
73 | },
74 | journal: {
75 | icon: "fas fa-book-open",
76 | name: "SIDEBAR.TabJournal",
77 | },
78 | languages: {
79 | icon: "fas fa-globe",
80 | name: "POLYGLOT.Languages.title",
81 | },
82 | chat: {
83 | icon: "fas fa-comments",
84 | name: "CHAT.Chat",
85 | },
86 | },
87 | settings: {
88 | font: {
89 | // Font Settings
90 | RuneRegex: this._prepSetting("RuneRegex"),
91 | enableAllFonts: this._prepSetting("enableAllFonts"),
92 | exportFonts: this._prepSetting("exportFonts"),
93 | },
94 | journal: {
95 | // Journal
96 | IgnoreJournalFontSize: this._prepSetting("IgnoreJournalFontSize"),
97 | JournalHighlightColor: this._prepSetting("JournalHighlightColor"),
98 | JournalHighlight: this._prepSetting("JournalHighlight"),
99 | },
100 | languages: {
101 | // Languages
102 | replaceLanguages: this._prepSetting("replaceLanguages"),
103 | defaultLanguage: this._prepSetting("defaultLanguage"),
104 | customLanguages: this._prepSetting("customLanguages"),
105 | omniglot: this._prepSetting("omniglot"),
106 | comprehendLanguages: this._prepSetting("comprehendLanguages"),
107 | truespeech: this._prepSetting("truespeech"),
108 | },
109 | chat: {
110 | // Chat
111 | enableChatFeatures: this._prepSetting("enableChatFeatures")
112 | },
113 | },
114 | };
115 | if (game.settings.get("polyglot", "enableChatFeatures")) {
116 | data.settings.chat = {
117 | ...data.settings.chat,
118 | "display-translated": this._prepSetting("display-translated"),
119 | hideTranslation: this._prepSetting("hideTranslation"),
120 | allowOOC: this._prepSetting("allowOOC"),
121 | runifyGM: this._prepSetting("runifyGM"),
122 | };
123 | }
124 | } else {
125 | data = {
126 | tabs: {
127 | languages: {
128 | icon: "fas fa-globe",
129 | name: "POLYGLOT.Languages.title",
130 | },
131 | },
132 | settings: {
133 | languages: {
134 | defaultLanguage: this._prepFlag("defaultLanguage"),
135 | },
136 | },
137 | };
138 | }
139 |
140 | for (const s in data.settings) {
141 | // eslint-disable-next-line no-unused-vars
142 | data.settings[s] = Object.fromEntries(
143 | Object.entries(data.settings[s]).filter(([key, value]) => value !== undefined),
144 | );
145 | }
146 |
147 | return data;
148 | }
149 |
150 | async activateListeners(html) {
151 | super.activateListeners(html);
152 | html.find("button").on("click", async (event) => {
153 | const dataset = event.currentTarget?.dataset;
154 | if (dataset?.action === "reset") {
155 | let keys = [
156 | "defaultLanguage"
157 | ];
158 | if (game.user.isGM) {
159 | keys = [
160 | "RuneRegex",
161 | "enableAllFonts",
162 | "exportFonts",
163 | "IgnoreJournalFontSize",
164 | "JournalHighlightColor",
165 | "JournalHighlight",
166 | "replaceLanguages",
167 | "defaultLanguage",
168 | "customLanguages",
169 | "omniglot",
170 | "comprehendLanguages",
171 | "truespeech",
172 | "enableChatFeatures",
173 | "display-translated",
174 | "hideTranslation",
175 | "allowOOC",
176 | "runifyGM",
177 | ];
178 | await Promise.all(
179 | keys.map(async (key) => {
180 | await this.resetToDefault(key);
181 | }),
182 | );
183 | } else {
184 | await Promise.all(
185 | keys.map(async (key) => {
186 | await game.user.unsetFlag("polyglot", key);
187 | }),
188 | );
189 | }
190 | this.close();
191 | } else if (dataset?.key) {
192 | const key = dataset.key;
193 | game.polyglot.languageProvider.settings?.[key].button?.(event);
194 | }
195 | });
196 | html.find(".form-group button[name]").on("click", async (event) => {
197 | const name = event.currentTarget.name;
198 | game.polyglot.languageProvider.settings?.[name].button?.(event);
199 | });
200 | }
201 |
202 | async _updateObject(event, formData) {
203 | let requiresClientReload = false;
204 | let requiresWorldReload = false;
205 | for (let [k, v] of Object.entries(foundry.utils.flattenObject(formData))) {
206 | let s = game.settings.settings.get(`polyglot.${k}`);
207 | let current = game.user.isGM ? game.settings.get(s.namespace, s.key) : game.user.getFlag("polyglot", k);
208 | if (v === current) continue;
209 | requiresClientReload ||= (s.scope !== CONST.SETTING_SCOPES.WORLD) && s.requiresReload;
210 | requiresWorldReload ||= (s.scope === CONST.SETTING_SCOPES.WORLD) && s.requiresReload;
211 | if (game.user.isGM) {
212 | await game.settings.set(s.namespace, s.key, v);
213 | } else {
214 | await game.user.setFlag("polyglot", k, v);
215 | }
216 | }
217 | if (requiresClientReload || requiresWorldReload) {
218 | SettingsConfig.reloadConfirm({ world: requiresWorldReload });
219 | }
220 | }
221 | }
222 |
--------------------------------------------------------------------------------
/src/module/providers/sw5e.js:
--------------------------------------------------------------------------------
1 | import LanguageProvider from "./templates/Base.js";
2 |
3 | export default class sw5eLanguageProvider extends LanguageProvider {
4 | languages = {
5 | basic: {
6 | font: "Celestial",
7 | },
8 | abyssin: {
9 | font: "Barazhad",
10 | },
11 | aleena: {
12 | font: "Jungle Slang",
13 | },
14 | antarian: {
15 | font: "Ar Ciela",
16 | },
17 | anzellan: {
18 | font: "Valmaric",
19 | },
20 | aqualish: {
21 | font: "Floki",
22 | },
23 | arconese: {
24 | font: "Ork Glyphs",
25 | },
26 | ardennian: {
27 | font: "Thorass",
28 | },
29 | arkanian: {
30 | font: "Celestial",
31 | },
32 | balosur: {
33 | font: "Ar Ciela",
34 | },
35 | barabel: {
36 | font: "Dark Eldar",
37 | },
38 | besalisk: {
39 | font: "Barazhad",
40 | },
41 | binary: {
42 | font: "Celestial",
43 | },
44 | bith: {
45 | font: "Skaven",
46 | },
47 | bocce: {
48 | font: "Tuzluca",
49 | },
50 | bothese: {
51 | font: "Infernal",
52 | },
53 | catharese: {
54 | font: "Espruar",
55 | },
56 | cerean: {
57 | font: "Olde Espruar",
58 | },
59 | "chadra-fan": {
60 | font: "Infernal",
61 | },
62 | chagri: {
63 | font: "Ophidian",
64 | },
65 | cheunh: {
66 | font: "Ar Ciela",
67 | },
68 | chevin: {
69 | font: "Eltharin",
70 | },
71 | chironan: {
72 | font: "Saurian",
73 | },
74 | clawdite: {
75 | font: "Reanaarian",
76 | },
77 | codruese: {
78 | font: "Meroitic Demotic",
79 | },
80 | colicoid: {
81 | font: "Thassilonian",
82 | },
83 | dashadi: {
84 | font: "Iokharic",
85 | },
86 | defel: {
87 | font: "Dark Eldar",
88 | },
89 | devaronese: {
90 | font: "Iokharic",
91 | },
92 | dosh: {
93 | font: "Iokharic",
94 | },
95 | draethos: {
96 | font: "Pulsian",
97 | },
98 | durese: {
99 | font: "Reanaarian",
100 | },
101 | dug: {
102 | font: "Qijomi",
103 | },
104 | ewokese: {
105 | font: "Skaven",
106 | },
107 | falleen: {
108 | font: "Tengwar",
109 | },
110 | felucianese: {
111 | font: "Skaven",
112 | },
113 | gamorrese: {
114 | font: "Highschool Runes",
115 | },
116 | gand: {
117 | font: "Reanaarian",
118 | },
119 | geonosian: {
120 | font: "Maras Eye",
121 | },
122 | givin: {
123 | font: "High Drowic",
124 | },
125 | gran: {
126 | font: "Qijomi",
127 | },
128 | gungan: {
129 | font: "Highschool Runes",
130 | },
131 | hapan: {
132 | font: "Valmaric",
133 | },
134 | harchese: {
135 | font: "Thassilonian",
136 | },
137 | herglese: {
138 | font: "Ophidian",
139 | },
140 | honoghran: {
141 | font: "Tuzluca",
142 | },
143 | huttese: {
144 | font: "Thassilonian",
145 | },
146 | iktotchese: {
147 | font: "Iokharic",
148 | },
149 | ithorese: {
150 | font: "Dethek",
151 | },
152 | jawaese: {
153 | font: "Valmaric",
154 | },
155 | kaleesh: {
156 | font: "Infernal",
157 | },
158 | kaminoan: {
159 | font: "Ar Ciela",
160 | },
161 | karkaran: {
162 | font: "Ophidian",
163 | },
164 | keldor: {
165 | font: "Meroitic Demotic",
166 | },
167 | kharan: {
168 | font: "Ar Ciela",
169 | },
170 | killik: {
171 | font: "Thassilonian",
172 | },
173 | klatooinian: {
174 | font: "Thassilonian",
175 | },
176 | kubazian: {
177 | font: "Olde Thorass",
178 | },
179 | kushiban: {
180 | font: "Thorass",
181 | },
182 | kyuzo: {
183 | font: "Barazhad",
184 | },
185 | lannik: {
186 | font: "Semphari",
187 | },
188 | lasat: {
189 | font: "Floki",
190 | },
191 | lowickese: {
192 | font: "Qijomi",
193 | },
194 | lurmese: {
195 | font: "Jungle Slang",
196 | },
197 | mandoa: {
198 | font: "Kargi",
199 | },
200 | miralukese: {
201 | font: "Miroslav Normal",
202 | },
203 | mirialan: {
204 | font: "Miroslav Normal",
205 | },
206 | moncal: {
207 | font: "Dark Eldar",
208 | },
209 | mustafarian: {
210 | font: "Ork Glyphs",
211 | },
212 | muun: {
213 | font: "Tengwar",
214 | },
215 | nautila: {
216 | font: "Ophidian",
217 | },
218 | ortolan: {
219 | font: "Thorass",
220 | },
221 | pakpak: {
222 | font: "Olde Thorass",
223 | },
224 | pyke: {
225 | font: "Meroitic Demotic",
226 | },
227 | quarrenese: {
228 | font: "Ophidian",
229 | },
230 | rakata: {
231 | font: "Iokharic",
232 | },
233 | rattataki: {
234 | font: "Infernal",
235 | },
236 | rishii: {
237 | font: "Maras Eye",
238 | },
239 | rodese: {
240 | font: "Meroitic Demotic",
241 | },
242 | ryn: {
243 | font: "Espruar",
244 | },
245 | selkatha: {
246 | font: "Ophidian",
247 | },
248 | semblan: {
249 | font: "Finger Alphabet",
250 | },
251 | shistavanen: {
252 | font: "Pulsian",
253 | },
254 | shyriiwook: {
255 | font: "Olde Espruar",
256 | },
257 | sith: {
258 | font: "High Drowic",
259 | },
260 | squibbian: {
261 | font: "Valmaric",
262 | },
263 | sriluurian: {
264 | font: "Jungle Slang",
265 | },
266 | "ssi-ruuvi": {
267 | font: "Maras Eye",
268 | },
269 | sullustese: {
270 | font: "Highschool Runes",
271 | },
272 | talzzi: {
273 | font: "Olde Thorass",
274 | },
275 | tarasinese: {
276 | font: "Olde Espruar",
277 | },
278 | thisspiasian: {
279 | font: "Ar Ciela",
280 | },
281 | togorese: {
282 | font: "Floki",
283 | },
284 | togruti: {
285 | font: "Pulsian",
286 | },
287 | toydarian: {
288 | font: "Espruar",
289 | },
290 | tusken: {
291 | font: "Semphari",
292 | },
293 | "twi'leki": {
294 | font: "Tuzluca",
295 | },
296 | ugnaught: {
297 | font: "Floki",
298 | },
299 | umbaran: {
300 | font: "Jungle Slang",
301 | },
302 | utapese: {
303 | font: "Eltharin",
304 | },
305 | verpine: {
306 | font: "Thassilonian",
307 | },
308 | vong: {
309 | font: "Valmaric",
310 | },
311 | voss: {
312 | font: "Iokharic",
313 | },
314 | yevethan: {
315 | font: "High Drowic",
316 | },
317 | zabraki: {
318 | font: "Maras Eye",
319 | },
320 | zygerrian: {
321 | font: "Floki",
322 | },
323 | };
324 |
325 | languageRarities = ["standard", "exotic"];
326 |
327 | async getLanguages() {
328 | const languagesSetting = game.settings.get("polyglot", "Languages");
329 | const langs = {};
330 | if (this.replaceLanguages) {
331 | CONFIG.SW5E.languages = {};
332 | }
333 | const systemLanguages = CONFIG.SW5E.languages;
334 | const getLang = (key, target) => {
335 | const processLanguage = (label) => {
336 | if (label) {
337 | langs[key] = {
338 | label,
339 | font: languagesSetting[key]?.font || this.languages[key]?.font || this.defaultFont,
340 | rng: languagesSetting[key]?.rng ?? "default",
341 | };
342 | }
343 | };
344 |
345 | if (target[key].children) {
346 | Object.keys(target[key].children).forEach((kkey) => {
347 | getLang(kkey, target[key].children);
348 | });
349 | } else {
350 | processLanguage(game.i18n.localize(target[key]));
351 | }
352 | };
353 | Object.keys(systemLanguages).forEach((key) => {
354 | if (this.languageRarities.includes(key)) {
355 | Object.keys(systemLanguages[key].children).forEach((kkey) => {
356 | getLang(kkey, systemLanguages[key].children);
357 | });
358 | } else {
359 | getLang(key, systemLanguages);
360 | }
361 | });
362 | this.languages = langs;
363 | }
364 |
365 | getSystemDefaultLanguage() {
366 | return "basic";
367 | }
368 | }
369 |
--------------------------------------------------------------------------------
/src/lang/fi.json:
--------------------------------------------------------------------------------
1 | {
2 | "POLYGLOT": {
3 | "LanguageSettings": "Kielten asetukset",
4 | "ChatSettings": "Keskusteluasetukset",
5 | "CustomLanguages.title": "Mukautetut kielet",
6 | "ComprehendLanguages.title": "Kaikkitietävä kieli",
7 | "ComprehendLanguages.hint": "Aseta kieli, jonka puhuja ymmärtää kaikkia muita kieliä, mutta jota ei voi puhua eikä kirjoittaa.",
8 | "directory": {
9 | "name": "Mukautettu fonttikansio",
10 | ".hint": "Valitse fonttitiedostoja sisältävä kansio, joka ei ole modules-kansiossa."
11 | },
12 | "source": {
13 | "s3": "S3",
14 | "forgevtt": "Forge"
15 | },
16 | "Truespeech.title": "Kaikkipuheen kieli",
17 | "JournalHighlight.title": "Korostuksen peitto (%)",
18 | "JournalHighlight.hint": "Määrittää muistiinpanon fonttien päälle tulevan korostuksen peiton.",
19 | "logographicalFontToggle.title": "Logografiset fontit",
20 | "logographicalFontToggle.hint": "Puolittaa logografisia fontteja (esim. japanilaiset, kiinalaiset merkit) käyttävien lauseiden pituuden.",
21 | "DefaultLanguage.title": "Oletuskieli",
22 | "DefaultLanguage.hint": "Valittavan oletuskielen nimi. Pidä tyhjänä, jos haluat käyttää järjestelmän oletusarvoa.",
23 | "ReplaceLanguages.title": "Korvaa järjestelmän kielet",
24 | "ScrambleGM.title": "PJ näkee sekoitetut viestit",
25 | "ScrambleGM.hint": "Älä käännä tekstiä PJ:lle (katso maapallon väristä, mitä pelinappula ymmärtää). Vaatii uudelleenlataamisen.",
26 | "Generic": {
27 | "Language": "Kieli"
28 | },
29 | "enableAllFonts": {
30 | "choices": {
31 | "0": "Ei mitään",
32 | "2": "Ytimen ylimääräiset fontit",
33 | "3": "Molemmat",
34 | "1": "Polyglot fontit"
35 | },
36 | "title": "Lisää Foundryn fontteja {settingMenuLabel} asetuksiin",
37 | "hint": "Lisää Foundryn fontteja kohtiin {setting1} ja {setting2}."
38 | },
39 | "RandomizeRunesOptions": {
40 | "a": "Oletus",
41 | "b": "Uniikit fraasit",
42 | "c": "Ei mitään ⚠️"
43 | },
44 | "ExportFonts.title": "Lisää Polyglotin fontit ytimeen",
45 | "ExportFonts.hint": "Lisää Polyglotin fontit ytimen {settingMenuLabel} -valikkoon. Kytke asetus pois päältä poistaaksesi kaikki Polyglotin fontit valikosta.",
46 | "DisplayTranslated.title": "Näytön käännökset",
47 | "DefaultAlphabet": "Oletusaakkosto",
48 | "FontSettings": "Fonttien asetukset",
49 | "Languages.title": "Kielet",
50 | "Font": "Fontti",
51 | "Fonts": "Fontit",
52 | "FontSize": "Fonttikoko (%)",
53 | "CustomLanguages.hint": "Kirjoita luettelo järjestelmään lisättävistä mukautetuista kielistä. Ne on erotettava toisistaan pilkuilla tai puolipisteillä.",
54 | "Truespeech.hint": "Aseta kieli, jonka puhuja ymmärtää kaikkia puhuttuja kieliä (ei voi lukea muistiinpanoja) ja jota kaikki olennot ymmärtävät.",
55 | "UESRPG.Language": "Kieli",
56 | "ReplaceLanguages.hint": "Korvaa järjestelmän oletuskielet mukauttamallasi kielillä. Luettelon ensimmäisestä kielestä tulee uusi oletuskieli.",
57 | "RandomizeRunes.hint": "Tämä määrittää, minkä tyyppistä satunnaislukugeneraattoria käytetään fraasin luomiseen. ⚠️ Vaihtoehto \"Ei mitään\" tukee vain aakkosnumeerisia merkkejä (ei aksentteja).",
58 | "SWADE": {
59 | "LanguageSkills": "Kieli",
60 | "AdditionalLanguageStat": {
61 | "hint": "On mahdollista kohdistaa lisäominaisuuteen (joka asetetaan SWADE Settings Configuratorissa). Sinun on syötettävä Stat-avain (merkkikokoriippuvainen). Huomaa, että tämä asetus ohittaa asetuksen {setting}.",
62 | "title": "Kielen Stat-avain"
63 | },
64 | "AdditionalLiterateStat": {
65 | "title": "Lukutaidon Stat-avain",
66 | "hint": "Muistiinpanoja on mahdollista rajoittaa lisäämällä lisäominaisuus. Sinun on kirjoitettava Stat-avain (merkkikokoriippuvainen). Tämä asetus on ei riipu asetuksesta {setting}."
67 | }
68 | },
69 | "WFRP4E": {
70 | "LanguageSkills": "Kieli"
71 | },
72 | "DND5E": {
73 | "SpecialLanguages.title": "Korvaa erikoiset kielet",
74 | "SpecialLanguages.hint": "Kielen nimi, joka korvaa \"kielet\" kuten \"kaikki kielet, jotka se osasi elämässään\"."
75 | },
76 | "COC7": {
77 | "LanguageSpec": "Kieli",
78 | "LanguageOwn": "Kieli",
79 | "LanguageAny": "Kieli",
80 | "LanguageOther": "Kieli"
81 | },
82 | "DisplayTranslated.hint": "Näytä alkuperäinen teksti ja käännös sen alapuolella keskusteluikkunassa käännetyille kielille.",
83 | "HideTranslation.title": "Piilota ilmaisimet pelaajilta",
84 | "AllowOOCOptions": {
85 | "b": "Vain PJ",
86 | "c": "Vain pelaajat",
87 | "d": "Ei mitään",
88 | "a": "Kaikki"
89 | },
90 | "LanguageProvider": {
91 | "choices": {
92 | "module": "[Moduuli] {name}",
93 | "native": "Yleinen",
94 | "system": "[Järjestelmä] {name}"
95 | },
96 | "name": "Kieliasetusten tarjoaja",
97 | "hint": "Valitse, kuka tarjoaa kielitietoja aakkosista ja kielistä. Pelijärjestelmät ja asennetut moduulit voivat tarjota lisää kielipalvelujen tarjoajia. Alla olevat vaihtoehdot riippuvat tässä valitusta kielipalveluntarjoajasta. ⚠️ Jos vaihdat palveluntarjoajaa, sinun on tallennettava ja avattava nämä asetukset uudelleen."
98 | },
99 | "LanguageRegex": {
100 | "title": "Kielen RegEx",
101 | "hint": "Tällä voit vaihtaa esineissä käytetyn termin \"Kieli\" joksikin muuksi, kuten \"Puhe\"."
102 | },
103 | "LanguageLabel": "Kieli",
104 | "AlphabetLabel": "Aakkosto",
105 | "LatinAlphabet": "Latinalaiset aakkoset",
106 | "HideTranslation.hint": "Piilottaa maapallon ja Käännetty kielestä -tekstin pelaajille lähetetyistä keskusteluviesteistä. Hyödyllinen silloin, kun et halua näyttää pelaajille, mitä kieltä puhut. Vaatii uudelleenlatauksen.",
107 | "Languages.hint": "Muuttaa kielissä käytettävää aakkostoa.",
108 | "TranslatedFrom": "Käännetty kielestä ",
109 | "Translation": "Käännös",
110 | "AllowOOC.hint": "Valitse, minkä käyttäjien viestit salataan. PUP = pelin ulkopuolinen puhe.",
111 | "AllowOOC.title": "Salaa PUP-viestit",
112 | "GeneralSettings": "Yleiset asetukset",
113 | "languageDataPath": {
114 | "hint": "Jos järjestelmässäsi on asetettuja kieliä hahmojen tietoihin ja niitä ei ladata oikein, se saattaa käyttää toista resurssipolkua. Syötä resurssipolku oikeaan attribuuttiin (esim. actor.system.languages tai actor.system.speak). Tämä asetus on ensisijainen {setting}-asetukseen nähden. Vaatii uudelleenlatauksen.",
115 | "title": "Kielen resurssipolku"
116 | },
117 | "RuneRegex": {
118 | "hint": "Jättää muut kuin aakkosnumeeriset merkit (esim. !,.;:?#$\"') huomioimatta satunnaistamisessa. Tämä saattaa aiheuttaa sen, että jotkin näistä merkeistä näkyvät neliönä (□) joissakin fonteissa.",
119 | "title": "Satunnaista vain aakkosnumeeriset merkit"
120 | },
121 | "General": "Yleinen",
122 | "Omniglot": {
123 | "title": "Kaikkikielen kieli",
124 | "hint": "Aseta kieli, jonka puhuja ymmärtää ja puhuu kaikkia muita kieliä."
125 | },
126 | "IgnoreJournalFontSize": {
127 | "hint": "Jättää huomiotta Polyglotin fonttien koon muistiinpanoissa, jolloin niiden koko on sama kuin normaalin tekstin. Hyödyllinen silloin, kun muistiinpanon muotoilulla on merkitystä.",
128 | "title": "Käytä tavallista fonttikokoa"
129 | },
130 | "JournalHighlightColor": {
131 | "hint": "Määrittää muistiinpanon fonttien päälle tulevan korostuksen peiton.",
132 | "title": "Korostusväri"
133 | },
134 | "literacyDataPath": {
135 | "title": "Lukutaidon resurssipolku",
136 | "hint": "Sama kuin asetus {setting}, mutta muistiinpanojen lukemista varten. Tämä asetus edellyttää asetusta {setting}. Vaatii uudelleenlatauksen."
137 | },
138 | "RandomizeRunes.title": "Satunnaista riimut",
139 | "ToggleRunes": "Vaihda riimut päälle/pois",
140 | "Runes": "Riimut",
141 | "AlphabeticOnly": "Vain aakkoselliset",
142 | "Logographical": "Logografinen"
143 | }
144 | }
145 |
--------------------------------------------------------------------------------