@cabin-icarus/tooltip_generator 1.7.0

package/localizationCompiler.ts

@@ -0,0 +1,362 @@
+import * as fs from 'fs';
+import * as path from 'path'
+import { KVObject, serialize } from 'valve-kv'
+import { LocalizationData, AbilityLocalization, ModifierLocalization, StandardLocalization } from "./localizationInterfaces";
+import { Language } from "~resource/languages"
+
+export class LocalizationCompiler
+{
+	addon_filepath: string = path.join("node_modules/~resource", "addon_");
+	filepath_format: string = ".txt";
+	currentWrites: Set<string> = new Set();
+	writeTimeout?: NodeJS.Timeout;
+
+	// Helper functions
+	TransformForLocalization(text: string, modifier: boolean): string
+	{
+		if (modifier)
+		{
+			text = text.replace(/\{([^f]\w+)\}($|[^%])/g, "%d$1%$2")
+			text = text.replace(/\{([^f]\w+)\}%/g, "%d$1%%%")
+			text = text.replace(/\{f(\w+)\}($|[^%])/g, "%f$1%$2")
+			text = text.replace(/\{f(\w+)\}%/g, "%f$1%%%");
+			text = text.replace(/%\{([^f]\w+)\}/g, "%%%d$1%")
+			text = text.replace(/%\{f(\w+)\}/g, "%%%f$1%");
+
+			return text;
+		}
+		else
+		{
+			text = text.replace(/\{(\w*)}($|[^%])/g, "%$1%$2")
+			text = text.replace(/\{(\w*)}%/g, "%$1%%%");
+			text = text.replace(/%\{(\w*)}/g, "%%%$1%");
+			
+			return text;
+		}
+	}
+
+	OnLocalizationDataChanged(allData: {[path: string]: LocalizationData})
+	{
+		// console.log("Localization event fired");
+		let Abilities: Array<AbilityLocalization> = new Array<AbilityLocalization>();
+		let Modifiers: Array<ModifierLocalization> = new Array<ModifierLocalization>();
+		let StandardTooltips: Array<StandardLocalization> = new Array<StandardLocalization>();
+		//let Talents: Array<HeroTalents> = new Array<HeroTalents>();
+
+		const localization_info: LocalizationData =
+		{
+			AbilityArray: Abilities,
+			ModifierArray: Modifiers,
+			StandardArray: StandardTooltips,
+			// TalentArray: Talents,
+		};
+
+		for (const [key, data] of Object.entries(allData)) {
+			if (data.AbilityArray) {
+				Array.prototype.push.apply(Abilities, data.AbilityArray);
+			}
+			if (data.ModifierArray) {
+				Array.prototype.push.apply(Modifiers, data.ModifierArray);
+			}
+			if (data.StandardArray) {
+				Array.prototype.push.apply(StandardTooltips, data.StandardArray);
+			}
+		}
+
+		// Generate information for every language
+		const languages = Object.values(Language).filter(v => typeof v !== "number");
+		for (const language of languages)
+		{            
+			if (language !== Language.None)
+			{
+				const tokens: KVObject = this.GenerateContentStringForLanguage(language, localization_info);
+				this.WriteContentToAddonFile(language, tokens);
+			}
+		}
+	}
+
+	GenerateContentStringForLanguage(language: string, localized_data: LocalizationData): KVObject
+	{
+		let tokens: KVObject = {}
+
+		// Go over standard tooltips
+		if (localized_data.StandardArray) {
+			for (const standardLocalization of localized_data.StandardArray)
+			{
+				// Check for name override for the language we're checking
+				let standard_tooltip_string = standardLocalization.name;
+
+				if (standardLocalization.language_overrides && standardLocalization.language_overrides.length > 0)
+				{
+					for (const language_override of standardLocalization.language_overrides)
+					{
+						if (language_override.language === language)
+						{
+							standard_tooltip_string = language_override.name_override;
+						}
+					}
+				}
+
+				tokens[standardLocalization.classname] = standard_tooltip_string;                
+			}
+		}
+
+		// Go over abilities for this language
+		if (localized_data.AbilityArray) {
+			for (const ability of localized_data.AbilityArray)
+			{
+				// Class name is identical for all languages, so we would always use it
+				const ability_string = `DOTA_Tooltip_Ability_${ability.ability_classname}`;
+
+				// Name
+				let ability_name = ability.name;
+				let ability_description = ability.description;
+				//let reimagined_effects = ability.reimagined_effects;
+				let ability_lore = ability.lore;
+				let ability_notes = ability.notes;
+				let scepter_description = ability.scepter_description;
+				let shard_description = ability.shard_description;
+				let ability_specials = ability.ability_specials;
+
+				if (ability.language_overrides)
+				{
+					for (const language_override of ability.language_overrides)
+					{
+						if (language_override.language === language)
+						{
+							// Check for name override
+							if (language_override.name_override)
+							{
+								ability_name = language_override.name_override;
+							}
+
+							// Check for description overrides
+							if (language_override.description_override)
+							{
+								ability_description = language_override.description_override;
+							}
+
+							// Check for reimagined effect overrides
+							//if (language_override.reimagined_effects_override)
+							//{
+								//reimagined_effects = language_override.reimagined_effects_override;
+							//}
+
+							// Check for lore override
+							if (language_override.lore_override)
+							{
+								ability_lore = language_override.lore_override;
+							}
+
+							// Check for note override
+							if (language_override.notes_override)
+							{
+								ability_notes = language_override.notes_override;
+							}
+
+							// Check for scepter override
+							if (language_override.scepter_description_override)
+							{
+								scepter_description = language_override.scepter_description_override;
+							}
+
+							// Check for shard override
+							if (language_override.shard_description_override)
+							{
+								shard_description = language_override.shard_description_override;
+							}
+
+							// Check for ability specials override, if any
+							if (language_override.ability_specials_override)
+							{
+								ability_specials = language_override.ability_specials_override;
+							}
+						}
+					}
+				}
+
+				// Add name localization
+				if (ability_name)
+				{
+					tokens[ability_string] = ability_name;
+				}                
+
+				// Add description localization
+				if (ability_description)
+				{
+					ability_description = this.TransformForLocalization(ability_description, false);
+					tokens[`${ability_string}_description`] = ability_description;
+				}                
+
+				// Lore, if any
+				if (ability_lore)
+				{
+					const transformed_lore = this.TransformForLocalization(ability_lore, false);
+					tokens[`${ability_string}_Lore`] = transformed_lore;                    
+				}
+
+				// Notes, if any
+				if (ability_notes)
+				{
+					let counter = 0;
+					for (const note of ability_notes)
+					{
+						const transformed_note = this.TransformForLocalization(note, false);
+						tokens[`${ability_string}_Note${counter}`] = transformed_note;                        
+
+						counter++;
+					}
+				}
+
+				// Scepter, if any
+				if (scepter_description)
+				{
+					const ability_scepter_description = this.TransformForLocalization(scepter_description, false);
+					tokens[`${ability_string}_scepter_description`] = ability_scepter_description;                    
+				}
+
+				// Shard, if any
+				if (shard_description)
+				{
+					const ability_shard_description = this.TransformForLocalization(shard_description, false);
+					tokens[`${ability_string}_shard_description`] = ability_shard_description;                    
+				}
+
+				// Ability specials, if any
+				if (ability_specials)
+				{
+					for (const ability_special of ability_specials)
+					{
+						// Construct the ability special
+						let ability_special_text = "";
+
+						if (ability_special.percentage)
+						{
+							ability_special_text = "%";
+						}
+						else if (ability_special.item_stat)
+						{
+							ability_special_text = "+$"
+						}
+
+						ability_special_text += ability_special.text;
+
+						tokens[`${ability_string}_${ability_special.ability_special}`] = ability_special_text;                        
+					}
+				}
+			}
+		}
+
+		// Go over modifiers
+		if (localized_data.ModifierArray) {
+			for (const modifier of localized_data.ModifierArray)
+			{
+				const modifier_string = `DOTA_Tooltip_${modifier.modifier_classname}`;
+
+				// Name
+				let modifier_name = modifier.name;
+				let modifier_description = modifier.description;
+
+				if (modifier.language_overrides)
+				{
+					for (const language_override of modifier.language_overrides)
+					{
+						if (language_override.language === language)
+						{
+							// Name overrides for a specific language, if necessary
+							if (language_override.name_override)
+							{
+								modifier_name = language_override.name_override;
+							}
+
+							// Description overrides for a specific language, if necessary
+							if (language_override.description_override)
+							{
+								modifier_description = language_override.description_override;
+							}
+						}
+					}
+				}
+
+				// Add name to localization string
+				if (modifier_name)
+				{
+					tokens[modifier_string] = modifier_name;
+				}                
+
+				// Add description to localization string
+				if (modifier_description)
+				{
+					modifier_description = this.TransformForLocalization(modifier_description, true);
+					tokens[`${modifier_string}_description`] = modifier_description;
+				}                
+			}
+		}
+
+		return tokens;
+	}
+
+	WriteContentToAddonFile(language: string, tokens: KVObject)
+	{
+		// Set based on language
+		const filepath = this.addon_filepath + language.toString() + this.filepath_format;
+
+		// Add the opening tokens        
+		const kv = {lang: { Language: language, Tokens: tokens}}
+
+		// Serialize!        
+		let write_string = serialize(kv);
+
+		// Try writing if the output is not busy
+		this.TryWriting(filepath, write_string, () => {
+
+			// Prepare the output
+			this.currentWrites.add(language);
+			if (this.writeTimeout) {
+				clearTimeout(this.writeTimeout);
+			}
+			this.writeTimeout = setTimeout(() => this.FinishWrite(), 500);
+		});
+	}
+
+	TryWriting(filepath: string, write_string: string, success: () => void, tries: number = 0) {
+		if (tries > 5) {
+			console.log("\x1b[31m%s\x1b[0m", "Tried too many times to write without success!");
+			return;
+		}
+		try {
+			// Remove file contents, or create a fresh one if it doesn't exists yet.
+			const fd = fs.openSync(filepath, 'w');
+			fs.closeSync(fd);
+
+			// Write to the file
+			fs.writeFileSync(filepath, write_string);
+		} catch {
+			// try again after a short time
+			setTimeout(() => this.TryWriting(filepath, write_string, success, tries + 1), 1000);
+			return;
+		}
+		success();
+	}
+
+	// Print the output
+	FinishWrite() {
+		if (this.currentWrites.size === 0) return;
+		let languages: string[] = [];
+		for (const language of this.currentWrites.values()) {
+			languages.push(language);
+		}
+		this.currentWrites.clear();
+		let languageText = languages[0];
+		if (languages.length > 1) {
+			let lastLang = languages.splice(-1)[0];
+			let otherLangs = languages.join(", ");
+			if (otherLangs !== "") {
+				languageText = otherLangs;
+			}
+			languageText += " and " + lastLang;
+		}
+		console.log(`Finished writing tooltips for ${languageText}`);
+		console.log("");
+	}
+}

package/localizationInterfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/localizationInterfaces.ts

@@ -0,0 +1,100 @@
+import { Language } from "./languages";
+
+export interface AbilityLocalization
+{
+    ability_classname: string;
+    name?: string;
+    description?: string;
+    scepter_description?: string;
+    shard_description?: string;
+    lore?: string;
+    notes?: Array<string>;
+    //reimagined_effects?: Array<ReimaginedEffect>;
+    ability_specials?: Array<AbilitySpecialLocalization>;
+    language_overrides?: Array<AbilityLocalizationContent>;
+}
+
+export interface AbilityLocalizationContent
+{
+    language: Language;
+    name_override?: string;
+    description_override?: string;
+    scepter_description_override?: string;
+    shard_description_override?: string;
+    lore_override?: string;
+    notes_override?: Array<string>;
+    //reimagined_effects_override?: Array<ReimaginedEffect>;
+    ability_specials_override?: Array<AbilitySpecialLocalization>;
+}
+
+export interface ModifierLocalization
+{
+    modifier_classname: string;
+    name?: string;
+    description?: string;
+    language_overrides?: Array<ModifierLocalizationContent>;
+}
+
+export interface ModifierLocalizationContent
+{
+    language: Language;
+    name_override?: string
+    description_override?: string;
+}
+
+export interface StandardLocalization
+{
+    classname: string;
+    name: string;
+    language_overrides?: StandardLocalizationNameOverride[]
+}
+
+export interface StandardLocalizationNameOverride
+{
+    language: Language;
+    name_override: string
+}
+
+// export interface ReimaginedEffect
+// {
+//     title: string;
+//     description: string;
+// }
+
+export interface AbilitySpecialLocalization
+{
+    ability_special: string;
+    text: string;
+    percentage?: boolean; // false by default if omitted
+    item_stat?: boolean // false by default if omitted
+}
+
+// export interface HeroTalents
+// {
+//     talent_classname: string;
+//     talents: Array<HeroTalentLocalization>;
+// }
+
+// export interface HeroTalentLocalization
+// {
+//     name: string;
+//     description: string;
+//     lore: string;
+//     language_overrides?: Array<TalentLocalizationOverrides>
+// }
+
+// export interface TalentLocalizationOverrides
+// {
+//     language: Language;
+//     name_override?: string;
+//     description_override?: string;
+//     lore_override?: string;
+// }
+
+export interface LocalizationData
+{
+    AbilityArray?: Array<AbilityLocalization>;
+    ModifierArray?: Array<ModifierLocalization>;
+    StandardArray?: Array<StandardLocalization>;
+    //TalentArray?: Array<HeroTalents>;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "author": {
+    "name": "Shush"
+  },
+  "bugs": {
+    "url": "https://github.com/CabinIkaros/tooltip_generator/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "link-module-alias": "^1.2.0",
+    "node-watch": "^0.7.1",
+    "npm-run-all": "^4.1.5",
+    "typescript": "^4.1.3",
+    "valve-kv": "^1.1.0"
+  },
+  "deprecated": false,
+  "description": "Code generator that makes creating tooltips for Dota 2 custom games much easier.",
+  "devDependencies": {
+    "@types/node": "^14.14.22",
+    "fs-extra": "^9.1.0",
+    "ts-node": "^10.9.2",
+    "node-xlsx": "^0.23.0"
+  },
+  "homepage": "https://github.com/CabinIkaros/tooltip_generator#readme",
+  "keywords": [
+    "Dota",
+    "Custom",
+    "Game",
+    "Tooltip",
+    "Generator"
+  ],
+  "license": "ISC",
+  "name": "@cabin-icarus/tooltip_generator",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CabinIkaros/tooltip_generator.git"
+  },
+  "_moduleAliases": {
+    "~resource": "resource",
+    "~generator": "node_modules/@cabin-icarus/tooltip_generator"
+  },
+  "scripts": {
+    "postinstall": "ts-node install.ts",
+    "dev": "run-p dev:*",
+    "dev:runlocalizationWatcher": "ts-node node_modules/~generator/fsWatcher.ts",
+    "init": "link-module-alias && ts-node node_modules/~generator/init.ts"
+  },
+  "version": "1.7.0"
+}

package/tsconfig.json

@@ -0,0 +1,72 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "types": [
+        "@types/node"
+    ]
+  },
+}