@dchighs/dc-core 0.2.0 → 0.4.0

package/dist/calculators/calculate-breeding-results.d.ts

@@ -0,0 +1,60 @@
+export type CalculateBreedingResultsParentConfig = {
+    id: number;
+    elements: string[];
+    level: number;
+    empowerLevel?: number;
+};
+export type CalculateBreedingResultsConfigOptions = {
+    breeding: Array<{
+        element_one: string;
+        element_two: string;
+        dragon_id_1: number;
+        empower_1: number;
+        dragon_id_2: number;
+        empower_2: number;
+        dragon_id_3: number;
+        empower_3: number;
+        dragon_id_4?: number;
+        empower_4?: number;
+        dragon_id_5?: number;
+        empower_5?: number;
+        dragon_id_6?: number;
+        empower_6?: number;
+        dragon_id_7?: number;
+        empower_7?: number;
+    }>;
+    incompatibilities?: Array<{
+        element_one: string;
+        element_two: string;
+    }>;
+    soulmates?: Array<{
+        parent_1_id: number;
+        parent_2_id: number;
+        dragon_id: number;
+        chance: number;
+        level_parents: number;
+    }>;
+    specialBreeding?: Array<{
+        condition1: {
+            id: number[];
+        };
+        condition2: {
+            id: number[];
+        };
+        result: number;
+    }>;
+    sanctuaryUnlockedDragons?: number[];
+};
+export type CalculateBreedingResultsOptions = {
+    parent1: CalculateBreedingResultsParentConfig;
+    parent2: CalculateBreedingResultsParentConfig;
+    config: CalculateBreedingResultsConfigOptions;
+};
+export type BreedingSource = "soulmate" | "special" | "sanctuary" | "regular";
+export type BreedingResultItem = {
+    dragonId: number;
+    sources: BreedingSource[];
+    requiredEmpower?: number;
+    chance?: number;
+};
+export declare function calculateBreedingResults({ parent1, parent2, config }: CalculateBreedingResultsOptions): BreedingResultItem[];

package/dist/calculators/calculate-breeding-results.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBreedingResults = calculateBreedingResults;
+function calculateBreedingResults({ parent1, parent2, config }) {
+    var _a;
+    const resultsMap = new Map();
+    function addResult(dragonId, source, empower, chance) {
+        if (!dragonId)
+            return;
+        const existing = resultsMap.get(dragonId);
+        if (existing) {
+            if (!existing.sources.includes(source)) {
+                existing.sources.push(source);
+            }
+            if (empower !== undefined) {
+                existing.requiredEmpower = existing.requiredEmpower !== undefined ? Math.min(existing.requiredEmpower, empower) : empower;
+            }
+            if (chance !== undefined) {
+                existing.chance = Math.max(existing.chance || 0, chance);
+            }
+        }
+        else {
+            resultsMap.set(dragonId, {
+                dragonId,
+                sources: [source],
+                requiredEmpower: empower,
+                chance
+            });
+        }
+    }
+    if (config.specialBreeding) {
+        for (const special of config.specialBreeding) {
+            const matchesP1Cond1 = special.condition1.id.includes(parent1.id);
+            const matchesP2Cond2 = special.condition2.id.includes(parent2.id);
+            const matchesP1Cond2 = special.condition2.id.includes(parent1.id);
+            const matchesP2Cond1 = special.condition1.id.includes(parent2.id);
+            if ((matchesP1Cond1 && matchesP2Cond2) || (matchesP1Cond2 && matchesP2Cond1)) {
+                addResult(special.result, "special");
+            }
+        }
+    }
+    if (config.soulmates) {
+        for (const soulmate of config.soulmates) {
+            const matches = (soulmate.parent_1_id === parent1.id && soulmate.parent_2_id === parent2.id) ||
+                (soulmate.parent_1_id === parent2.id && soulmate.parent_2_id === parent1.id);
+            const levelsMatch = parent1.level >= soulmate.level_parents && parent2.level >= soulmate.level_parents;
+            if (matches && levelsMatch) {
+                addResult(soulmate.dragon_id, "soulmate", undefined, soulmate.chance);
+            }
+        }
+    }
+    const incompatibilities = config.incompatibilities || [];
+    const isIncompatible = (e1, e2) => {
+        return incompatibilities.some(inc => (inc.element_one === e1 && inc.element_two === e2) ||
+            (inc.element_one === e2 && inc.element_two === e1));
+    };
+    for (const e1 of parent1.elements) {
+        for (const e2 of parent2.elements) {
+            if (isIncompatible(e1, e2)) {
+                continue;
+            }
+            const breedingRule = config.breeding.find(b => (b.element_one === e1 && b.element_two === e2) ||
+                (b.element_one === e2 && b.element_two === e1));
+            if (breedingRule) {
+                const pairs = [
+                    { id: breedingRule.dragon_id_1, emp: breedingRule.empower_1 },
+                    { id: breedingRule.dragon_id_2, emp: breedingRule.empower_2 },
+                    { id: breedingRule.dragon_id_3, emp: breedingRule.empower_3 },
+                    { id: breedingRule.dragon_id_4, emp: breedingRule.empower_4 },
+                    { id: breedingRule.dragon_id_5, emp: breedingRule.empower_5 },
+                    { id: breedingRule.dragon_id_6, emp: breedingRule.empower_6 },
+                    { id: breedingRule.dragon_id_7, emp: breedingRule.empower_7 },
+                ];
+                for (const pair of pairs) {
+                    if (pair.id) {
+                        const isSanctuary = (_a = config.sanctuaryUnlockedDragons) === null || _a === void 0 ? void 0 : _a.includes(pair.id);
+                        addResult(pair.id, isSanctuary ? "sanctuary" : "regular", pair.emp || 0);
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(resultsMap.values());
+}

package/dist/calculators/calculate-element-resistances.d.ts

@@ -0,0 +1,2 @@
+import { DragonElement } from "../enums";
+export declare function calculateElementResistances(element: string): DragonElement[];

package/dist/calculators/calculate-element-resistances.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateElementResistances = calculateElementResistances;
+const validate_element_name_1 = require("../tools/validate-element-name");
+const elements_1 = require("../settings/elements");
+function calculateElementResistances(element) {
+    (0, validate_element_name_1.validateElementName)(element, { throwOnError: true });
+    const elementKey = element;
+    const elementSetting = elements_1.elementSettings[elementKey];
+    const elementWeaknesses = elementSetting.weaknesses;
+    return elementWeaknesses;
+}

package/dist/calculators/calculate-element-strengths.d.ts

@@ -1 +1,2 @@
-export declare function calculateElementStrengths(element: string): import("..").DragonElement[] | never[];
+import { DragonElement } from "../enums";
+export declare function calculateElementStrengths(element: string): DragonElement[];

package/dist/calculators/calculate-element-weaknesses.d.ts

@@ -1 +1,2 @@
-export declare function calculateElementWeaknesses(element: string): import("..").DragonElement[] | never[];
+import { DragonElement } from "../enums";
+export declare function calculateElementWeaknesses(element: string): DragonElement[];

package/dist/calculators/calculate-element-weaknesses.js

@@ -5,8 +5,11 @@ const validate_element_name_1 = require("../tools/validate-element-name");
 const elements_1 = require("../settings/elements");
 function calculateElementWeaknesses(element) {
     (0, validate_element_name_1.validateElementName)(element, { throwOnError: true });
-    const elementKey = element;
-    const elementSetting = elements_1.elementSettings[elementKey];
-    const elementWeaknesses = elementSetting.weaknesses;
-    return elementWeaknesses;
+    const weaknesses = [];
+    for (const key in elements_1.elementSettings) {
+        if (elements_1.elementSettings[key].strengths.includes(element)) {
+            weaknesses.push(key);
+        }
+    }
+    return weaknesses;
 }

package/dist/calculators/index.d.ts

@@ -4,4 +4,7 @@ import { calculateElementStrengths } from "./calculate-element-strengths";
 import { calculateDragonFeedCost } from "./calculate-dragon-feed-cost";
 import { calculateOrbRecallGain } from "./calculate-orb-recall-gain";
 import { calculateAttackDamage } from "./calculate-attack-damage";
-export { calculateOrbRecallGain, calculateAttackDamage, calculateDragonFeedCost, calculateElementsStrengths, calculateElementWeaknesses, calculateElementStrengths };
+import { calculateBreedingResults } from "./calculate-breeding-results";
+export * from "./calculate-breeding-results";
+import { calculateElementResistances } from "./calculate-element-resistances";
+export { calculateElementResistances, calculateOrbRecallGain, calculateAttackDamage, calculateDragonFeedCost, calculateElementsStrengths, calculateElementWeaknesses, calculateElementStrengths, calculateBreedingResults };

package/dist/calculators/index.js

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateElementStrengths = exports.calculateElementWeaknesses = exports.calculateElementsStrengths = exports.calculateDragonFeedCost = exports.calculateAttackDamage = exports.calculateOrbRecallGain = void 0;
+exports.calculateBreedingResults = exports.calculateElementStrengths = exports.calculateElementWeaknesses = exports.calculateElementsStrengths = exports.calculateDragonFeedCost = exports.calculateAttackDamage = exports.calculateOrbRecallGain = exports.calculateElementResistances = void 0;
 const calculate_elements_strengths_1 = require("./calculate-elements-strengths");
 Object.defineProperty(exports, "calculateElementsStrengths", { enumerable: true, get: function () { return calculate_elements_strengths_1.calculateElementsStrengths; } });
 const calculate_element_weaknesses_1 = require("./calculate-element-weaknesses");
@@ -13,3 +27,8 @@ const calculate_orb_recall_gain_1 = require("./calculate-orb-recall-gain");
 Object.defineProperty(exports, "calculateOrbRecallGain", { enumerable: true, get: function () { return calculate_orb_recall_gain_1.calculateOrbRecallGain; } });
 const calculate_attack_damage_1 = require("./calculate-attack-damage");
 Object.defineProperty(exports, "calculateAttackDamage", { enumerable: true, get: function () { return calculate_attack_damage_1.calculateAttackDamage; } });
+const calculate_breeding_results_1 = require("./calculate-breeding-results");
+Object.defineProperty(exports, "calculateBreedingResults", { enumerable: true, get: function () { return calculate_breeding_results_1.calculateBreedingResults; } });
+__exportStar(require("./calculate-breeding-results"), exports);
+const calculate_element_resistances_1 = require("./calculate-element-resistances");
+Object.defineProperty(exports, "calculateElementResistances", { enumerable: true, get: function () { return calculate_element_resistances_1.calculateElementResistances; } });

package/dist/tools/dragon-static-file-url-parser.d.ts

@@ -0,0 +1,38 @@
+import { DragonPhase, DragonSpriteQuality, StaticFileUrlPlatformPrefix } from "../enums";
+export declare class DragonStaticFileUrlParser {
+    static getPlatformPrefix(url: string): StaticFileUrlPlatformPrefix | null;
+    static getImageName(url: string): string | null;
+    static getId(url: string): number | null;
+    static getPhase(url: string): DragonPhase | null;
+    static getSkin(url: string): string | null;
+    static getImageQuality(url: string): DragonSpriteQuality;
+    static parseFromSprite(url: string): {
+        platformPrefix: StaticFileUrlPlatformPrefix | null;
+        id: number | null;
+        imageName: string | null;
+        phase: DragonPhase | null;
+        skin: string | null;
+        imageQuality: DragonSpriteQuality;
+    };
+    static parseFromThumbnail(url: string): {
+        platformPrefix: StaticFileUrlPlatformPrefix | null;
+        id: number | null;
+        image_name: string | null;
+        phase: DragonPhase | null;
+        skin: string | null;
+    };
+    static parseFromFlashAnimation(url: string): {
+        platformPrefix: StaticFileUrlPlatformPrefix | null;
+        id: number | null;
+        imageName: string | null;
+        phase: DragonPhase | null;
+        skin: string | null;
+    };
+    static parseFromSpineAnimation(url: string): {
+        platformPrefix: StaticFileUrlPlatformPrefix | null;
+        id: number | null;
+        imageName: string | null;
+        phase: DragonPhase | null;
+        skin: string | null;
+    };
+}

package/dist/tools/dragon-static-file-url-parser.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonStaticFileUrlParser = void 0;
+const enums_1 = require("../enums");
+class DragonStaticFileUrlParser {
+    static getPlatformPrefix(url) {
+        const match = url.match(/https?:\/\/([a-z]+)-static/i);
+        if (!match) {
+            return null;
+        }
+        const prefix = match[1];
+        return prefix;
+    }
+    static getImageName(url) {
+        const match = url.match(/\/(basic_|thumb_|ui_)?(\d+)_([\w_]+)/);
+        if (match) {
+            const id = match[2];
+            const imageNameWithoutId = match[3];
+            const rawImageName = `${id}_${imageNameWithoutId}`;
+            let imageNameWithSkin = rawImageName.replace(/_\d+/, "");
+            let imageNameWithoutSkin = imageNameWithSkin.replace(/_skin\d+/, "");
+            return imageNameWithoutSkin;
+        }
+        return null;
+    }
+    static getId(url) {
+        const match = url.match(/\/(basic_|thumb_|ui_)?(\d+)_/);
+        if (match) {
+            return Number(match[2]);
+        }
+        return null;
+    }
+    static getPhase(url) {
+        const match = url.match(/(\d+)@2x\.(png|swf)|(\d+)\.(png|swf)|(\d+)_HD_tweened_dxt5\.zip|(\d+)_HD_spine-3-8-59_dxt5\.zip/);
+        if (match) {
+            const phase = match[1] ||
+                match[3] ||
+                match[5] ||
+                match[6];
+            return phase ? Number(phase) : null;
+        }
+        return null;
+    }
+    static getSkin(url) {
+        const match = url.match(/_skin\d+/);
+        if (match) {
+            return match[0];
+        }
+        return null;
+    }
+    static getImageQuality(url) {
+        const match = url.match(/@\d+x/);
+        if (match) {
+            return match[0];
+        }
+        return enums_1.DragonSpriteQuality.Default;
+    }
+    static parseFromSprite(url) {
+        return {
+            platformPrefix: this.getPlatformPrefix(url),
+            id: this.getId(url),
+            imageName: this.getImageName(url),
+            phase: this.getPhase(url),
+            skin: this.getSkin(url),
+            imageQuality: this.getImageQuality(url),
+        };
+    }
+    static parseFromThumbnail(url) {
+        return {
+            platformPrefix: this.getPlatformPrefix(url),
+            id: this.getId(url),
+            image_name: this.getImageName(url),
+            phase: this.getPhase(url),
+            skin: this.getSkin(url),
+        };
+    }
+    static parseFromFlashAnimation(url) {
+        return {
+            platformPrefix: this.getPlatformPrefix(url),
+            id: this.getId(url),
+            imageName: this.getImageName(url),
+            phase: this.getPhase(url),
+            skin: this.getSkin(url),
+        };
+    }
+    static parseFromSpineAnimation(url) {
+        return {
+            platformPrefix: this.getPlatformPrefix(url),
+            id: this.getId(url),
+            imageName: this.getImageName(url),
+            phase: this.getPhase(url),
+            skin: this.getSkin(url),
+        };
+    }
+}
+exports.DragonStaticFileUrlParser = DragonStaticFileUrlParser;

package/dist/tools/index.d.ts

@@ -6,4 +6,5 @@ import { validateDragonStars } from "./validate-dragon-stars";
 import { validateElementName } from "./validate-element-name";
 import { validateDragonLevel } from "./validate-dragon-level";
 import { validateDragonRank } from "./validate-dragon-rank";
-export { validateDragonLevelCompatibilityWithStars, validateDragonCategory, getMusicKeyNameFromTag, validateDragonRarity, validateDragonStars, validateElementName, validateDragonLevel, validateDragonRank, };
+import { DragonStaticFileUrlParser } from "./dragon-static-file-url-parser";
+export { validateDragonLevelCompatibilityWithStars, validateDragonCategory, getMusicKeyNameFromTag, validateDragonRarity, validateDragonStars, validateElementName, validateDragonLevel, validateDragonRank, DragonStaticFileUrlParser, };

package/dist/tools/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDragonRank = exports.validateDragonLevel = exports.validateElementName = exports.validateDragonStars = exports.validateDragonRarity = exports.getMusicKeyNameFromTag = exports.validateDragonCategory = exports.validateDragonLevelCompatibilityWithStars = void 0;
+exports.DragonStaticFileUrlParser = exports.validateDragonRank = exports.validateDragonLevel = exports.validateElementName = exports.validateDragonStars = exports.validateDragonRarity = exports.getMusicKeyNameFromTag = exports.validateDragonCategory = exports.validateDragonLevelCompatibilityWithStars = void 0;
 const validate_dragon_level_compatibility_with_stars_1 = require("./validate-dragon-level-compatibility-with-stars");
 Object.defineProperty(exports, "validateDragonLevelCompatibilityWithStars", { enumerable: true, get: function () { return validate_dragon_level_compatibility_with_stars_1.validateDragonLevelCompatibilityWithStars; } });
 const validate_dragon_category_1 = require("./validate-dragon-category");
@@ -17,3 +17,5 @@ const validate_dragon_level_1 = require("./validate-dragon-level");
 Object.defineProperty(exports, "validateDragonLevel", { enumerable: true, get: function () { return validate_dragon_level_1.validateDragonLevel; } });
 const validate_dragon_rank_1 = require("./validate-dragon-rank");
 Object.defineProperty(exports, "validateDragonRank", { enumerable: true, get: function () { return validate_dragon_rank_1.validateDragonRank; } });
+const dragon_static_file_url_parser_1 = require("./dragon-static-file-url-parser");
+Object.defineProperty(exports, "DragonStaticFileUrlParser", { enumerable: true, get: function () { return dragon_static_file_url_parser_1.DragonStaticFileUrlParser; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dchighs/dc-core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A library focused on simulating some of the logic of the game Dragon City.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -11,6 +11,7 @@
   ],
   "scripts": {
     "test": "jest",
+    "test:coverage": "jest --coverage",
     "build": "tsc"
   },
   "keywords": [