sekai-calculator 0.8.4 → 0.9.0

package/dist/index.cjs

@@ -170,9 +170,9 @@ class CardDetailMap {
     min = Number.MAX_SAFE_INTEGER;
     max = Number.MIN_SAFE_INTEGER;
     values = new Map();
-    set(unit, unitMember, attrMember, value) {
-        this.min = Math.min(this.min, value);
-        this.max = Math.max(this.max, value);
+    set(unit, unitMember, attrMember, cmpValue, value) {
+        this.min = Math.min(this.min, cmpValue);
+        this.max = Math.max(this.max, cmpValue);
         this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
     }
     get(unit, unitMember, attrMember) {
@@ -209,15 +209,26 @@ class CardPowerCalculator {
         const basePower = await this.getCardBasePowers(userCard, card);
         const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
         for (const unit of cardUnits) {
-            ret.set(unit, 5, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true));
-            ret.set(unit, 5, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false));
-            ret.set(unit, 1, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true));
-            ret.set(unit, 1, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false));
+            let power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true);
+            ret.set(unit, 5, 5, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false);
+            ret.set(unit, 5, 1, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true);
+            ret.set(unit, 1, 5, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false);
+            ret.set(unit, 1, 1, power.total, power);
         }
         return ret;
     }
     async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
-        return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+        const base = basePower.reduce((v, it) => v + it, 0);
+        const areaItemBonus = await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+        return {
+            base,
+            areaItemBonus,
+            characterBonus,
+            total: base + characterBonus + areaItemBonus
+        };
     }
     async getCardBasePowers(userCard, card) {
         const p = await Promise.all([
@@ -272,7 +283,7 @@ class CardPowerCalculator {
                 Math.fround(allMatch ? areaItem.power3AllMatchBonusRate : areaItem.power3BonusRate));
         }
         return basePower
-            .reduce((v, it, i) => v + Math.floor(Math.fround(it * areaItemBonus[i] / 100)), 0);
+            .reduce((v, it, i) => v + Math.floor(Math.fround(it * Math.fround(areaItemBonus[i] / 100))), 0);
     }
     async getCharacterBonusPower(basePower, characterId) {
         const characterRanks = await this.dataProvider.getMasterData('characterRanks');
@@ -296,16 +307,22 @@ class CardSkillCalculator {
         this.dataProvider = dataProvider;
     }
     async getCardSkill(userCard, card) {
-        const scoreUpMap = new CardDetailMap();
+        const skillMap = new CardDetailMap();
         const detail = await this.getSkillDetail(userCard, card);
         if (detail.scoreUpEnhance !== undefined) {
             for (let i = 1; i <= 5; ++i) {
                 const scoreUp = detail.scoreUp + (i === 5 ? 5 : (i - 1)) * detail.scoreUpEnhance.value;
-                scoreUpMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp);
+                skillMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp, {
+                    scoreUp,
+                    lifeRecovery: detail.lifeRecovery
+                });
             }
         }
-        scoreUpMap.set('any', 1, 1, detail.scoreUp);
-        return { scoreUp: scoreUpMap, lifeRecovery: detail.lifeRecovery };
+        skillMap.set('any', 1, 1, detail.scoreUp, {
+            scoreUp: detail.scoreUp,
+            lifeRecovery: detail.lifeRecovery
+        });
+        return skillMap;
     }
     async getSkillDetail(userCard, card) {
         const skills = await this.dataProvider.getMasterData('skills');
@@ -439,8 +456,7 @@ class CardCalculator {
             units,
             attr: card.attr,
             power,
-            scoreSkill: skill.scoreUp,
-            lifeSkill: skill.lifeRecovery,
+            skill,
             eventBonus
         };
     }
@@ -452,7 +468,7 @@ class CardCalculator {
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
-            cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
+            cardDetail0.skill.isCertainlyLessThen(cardDetail1.skill) &&
             (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
                 cardDetail0.eventBonus <= cardDetail1.eventBonus);
     }
@@ -534,10 +550,10 @@ class LiveCalculator {
         const rate = baseRate + skills.details
             .reduce((v, it, i) => v + it.scoreUp * skillRate[i] / 100, 0);
         const life = skills.details.reduce((v, it) => v + it.lifeRecovery, 0);
-        const powerSum = multiPowerSum === 0 ? 5 * deckDetail.power : multiPowerSum;
+        const powerSum = multiPowerSum === 0 ? 5 * deckDetail.power.total : multiPowerSum;
         const activeBonus = liveType === exports.LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
         return {
-            score: Math.floor(rate * deckDetail.power * 4 + activeBonus),
+            score: Math.floor(rate * deckDetail.power.total * 4 + activeBonus),
             time: musicMeta.music_time,
             life: Math.min(2000, life + 1000),
             tap: musicMeta.tap_count
@@ -664,11 +680,27 @@ class DeckCalculator {
         }
         const cardPower = new Map();
         cardDetails.forEach(cardDetail => {
-            cardPower.set(cardDetail.cardId, cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0));
+            cardPower.set(cardDetail.cardId, cardDetail.units.reduce((vv, unit) => {
+                const current = cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr));
+                return current.total > vv.total ? current : vv;
+            }, cardDetail.power.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), getOrThrow(map, cardDetail.attr))));
         });
-        const power = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId), 0) + honorBonus;
+        const base = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).base, 0);
+        const areaItemBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).areaItemBonus, 0);
+        const characterBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).characterBonus, 0);
+        const total = base + areaItemBonus + characterBonus + honorBonus;
+        const power = {
+            base,
+            areaItemBonus,
+            characterBonus,
+            honorBonus,
+            total
+        };
         const cards = cardDetails.map(cardDetail => {
-            const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
+            const skill = cardDetail.units.reduce((vv, unit) => {
+                const current = cardDetail.skill.get(unit, getOrThrow(map, unit), 1);
+                return current.scoreUp > vv.scoreUp ? current : vv;
+            }, cardDetail.skill.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), 1));
             return {
                 cardId: cardDetail.cardId,
                 level: cardDetail.level,
@@ -676,10 +708,7 @@ class DeckCalculator {
                 masterRank: cardDetail.masterRank,
                 power: getOrThrow(cardPower, cardDetail.cardId),
                 eventBonus: cardDetail.eventBonus,
-                skill: {
-                    scoreUp,
-                    lifeRecovery: cardDetail.lifeSkill
-                }
+                skill
             };
         });
         const eventBonus = EventCalculator.getDeckBonus(cardDetails);
@@ -735,7 +764,7 @@ class AreaItemRecommend {
                 ...currentAreaItemLevels.filter(it => it.areaItemId !== areaItem.id), newAreaItemLevel
             ];
             const { power: newPower } = await this.deckCalculator.getDeckDetail(userCards, 0, newAreaItemLevels);
-            return await this.getRecommendAreaItem(areaItem, newAreaItemLevel, newPower - currentPower);
+            return await this.getRecommendAreaItem(areaItem, newAreaItemLevel, newPower.total - currentPower.total);
         }));
         return recommend.filter(it => it.power > 0)
             .sort((a, b) => b.power / b.cost.coin - a.power / a.cost.coin);
@@ -865,7 +894,7 @@ function compareDeck(deck1, deck2) {
     if (deck1.score !== deck2.score)
         return deck2.score - deck1.score;
     if (deck1.power !== deck2.power)
-        return deck2.power - deck1.power;
+        return deck2.power.total - deck1.power.total;
     return deck1.deckCards[0].cardId - deck2.deckCards[0].cardId;
 }
 function removeSameDeck(it, i, arr) {
@@ -929,7 +958,7 @@ class BaseDeckRecommend {
                 continue;
             if (!isChallengeLive && deckCharacters.includes(card.characterId))
                 continue;
-            if (deckCards.length >= 1 && deckCards[0].scoreSkill.isCertainlyLessThen(card.scoreSkill))
+            if (deckCards.length >= 1 && deckCards[0].skill.isCertainlyLessThen(card.skill))
                 continue;
             if (deckCards.length >= 1 && card.attr !== deckCards[0].attr && !containsAny(deckCards[0].units, card.units)) {
                 continue;

package/dist/index.d.ts

@@ -131,15 +131,15 @@ interface UserChallengeLiveSoloDeck {
     support4: number | null;
 }
 
-declare class CardDetailMap {
+declare class CardDetailMap<T> {
     min: number;
     max: number;
-    values: Map<string, number>;
-    set(unit: string, unitMember: number, attrMember: number, value: number): void;
-    get(unit: string, unitMember: number, attrMember: number): number;
+    values: Map<string, T>;
+    set(unit: string, unitMember: number, attrMember: number, cmpValue: number, value: T): void;
+    get(unit: string, unitMember: number, attrMember: number): T;
     private getInternal;
     static getKey(unit: string, unitMember: number, attrMember: number): string;
-    isCertainlyLessThen(another: CardDetailMap): boolean;
+    isCertainlyLessThen(another: CardDetailMap<T>): boolean;
 }
 
 declare class CardCalculator {
@@ -164,9 +164,8 @@ interface CardDetail {
     characterId: number;
     units: string[];
     attr: string;
-    power: CardDetailMap;
-    scoreSkill: CardDetailMap;
-    lifeSkill: number;
+    power: CardDetailMap<DeckCardPowerDetail>;
+    skill: CardDetailMap<DeckCardSkillDetail>;
     eventBonus?: number;
 }
 interface CardConfig {
@@ -185,7 +184,7 @@ declare class DeckCalculator {
     getDeckDetail(deckCards: UserCard[], eventId?: number, areaItemLevels?: AreaItemLevel[]): Promise<DeckDetail>;
 }
 interface DeckDetail {
-    power: number;
+    power: DeckPowerDetail;
     eventBonus?: number;
     cards: DeckCardDetail[];
 }
@@ -194,10 +193,23 @@ interface DeckCardDetail {
     level: number;
     skillLevel: number;
     masterRank: number;
-    power: number;
+    power: DeckCardPowerDetail;
     eventBonus?: number;
     skill: DeckCardSkillDetail;
 }
+interface DeckPowerDetail {
+    base: number;
+    areaItemBonus: number;
+    characterBonus: number;
+    honorBonus: number;
+    total: number;
+}
+interface DeckCardPowerDetail {
+    base: number;
+    areaItemBonus: number;
+    characterBonus: number;
+    total: number;
+}
 interface DeckCardSkillDetail {
     scoreUp: number;
     lifeRecovery: number;
@@ -251,7 +263,7 @@ interface Card {
 declare class CardPowerCalculator {
     private readonly dataProvider;
     constructor(dataProvider: DataProvider);
-    getCardPower(userCard: UserCard, card: Card, cardUnits: string[], userAreaItemLevels: AreaItemLevel[]): Promise<CardDetailMap>;
+    getCardPower(userCard: UserCard, card: Card, cardUnits: string[], userAreaItemLevels: AreaItemLevel[]): Promise<CardDetailMap<DeckCardPowerDetail>>;
     private getPower;
     private getCardBasePowers;
     private getAreaItemBonusPower;
@@ -261,10 +273,7 @@ declare class CardPowerCalculator {
 declare class CardSkillCalculator {
     private readonly dataProvider;
     constructor(dataProvider: DataProvider);
-    getCardSkill(userCard: UserCard, card: Card): Promise<{
-        scoreUp: CardDetailMap;
-        lifeRecovery: number;
-    }>;
+    getCardSkill(userCard: UserCard, card: Card): Promise<CardDetailMap<DeckCardSkillDetail>>;
     private getSkillDetail;
 }
 
@@ -363,7 +372,7 @@ declare class BaseDeckRecommend {
 type ScoreFunction = (musicMeta: MusicMeta, honorBonus: number, deckCards: CardDetail[]) => number;
 interface RecommendDeck {
     score: number;
-    power: number;
+    power: DeckPowerDetail;
     eventBonus?: number;
     deckCards: DeckCardDetail[];
 }
@@ -702,4 +711,4 @@ interface UserHonor {
     level: number;
 }
 
-export { Area, AreaItem, AreaItemLevel, AreaItemRecommend, AreaItemService, BaseDeckRecommend, CachedDataProvider, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckCardDetail, DeckCardSkillDetail, DeckDetail, DeckRecommendConfig, DeckService, Event, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventExchange, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, Music, MusicDifficulty, MusicMeta, MusicRecommend, MusicVocal, RecommendAreaItem, RecommendDeck, ScoreFunction, ShopItem, Skill, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };
+export { Area, AreaItem, AreaItemLevel, AreaItemRecommend, AreaItemService, BaseDeckRecommend, CachedDataProvider, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckCardDetail, DeckCardPowerDetail, DeckCardSkillDetail, DeckDetail, DeckPowerDetail, DeckRecommendConfig, DeckService, Event, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventExchange, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, Music, MusicDifficulty, MusicMeta, MusicRecommend, MusicVocal, RecommendAreaItem, RecommendDeck, ScoreFunction, ShopItem, Skill, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };

package/dist/index.mjs

@@ -168,9 +168,9 @@ class CardDetailMap {
     min = Number.MAX_SAFE_INTEGER;
     max = Number.MIN_SAFE_INTEGER;
     values = new Map();
-    set(unit, unitMember, attrMember, value) {
-        this.min = Math.min(this.min, value);
-        this.max = Math.max(this.max, value);
+    set(unit, unitMember, attrMember, cmpValue, value) {
+        this.min = Math.min(this.min, cmpValue);
+        this.max = Math.max(this.max, cmpValue);
         this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
     }
     get(unit, unitMember, attrMember) {
@@ -207,15 +207,26 @@ class CardPowerCalculator {
         const basePower = await this.getCardBasePowers(userCard, card);
         const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
         for (const unit of cardUnits) {
-            ret.set(unit, 5, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true));
-            ret.set(unit, 5, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false));
-            ret.set(unit, 1, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true));
-            ret.set(unit, 1, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false));
+            let power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true);
+            ret.set(unit, 5, 5, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false);
+            ret.set(unit, 5, 1, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true);
+            ret.set(unit, 1, 5, power.total, power);
+            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false);
+            ret.set(unit, 1, 1, power.total, power);
         }
         return ret;
     }
     async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
-        return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+        const base = basePower.reduce((v, it) => v + it, 0);
+        const areaItemBonus = await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+        return {
+            base,
+            areaItemBonus,
+            characterBonus,
+            total: base + characterBonus + areaItemBonus
+        };
     }
     async getCardBasePowers(userCard, card) {
         const p = await Promise.all([
@@ -270,7 +281,7 @@ class CardPowerCalculator {
                 Math.fround(allMatch ? areaItem.power3AllMatchBonusRate : areaItem.power3BonusRate));
         }
         return basePower
-            .reduce((v, it, i) => v + Math.floor(Math.fround(it * areaItemBonus[i] / 100)), 0);
+            .reduce((v, it, i) => v + Math.floor(Math.fround(it * Math.fround(areaItemBonus[i] / 100))), 0);
     }
     async getCharacterBonusPower(basePower, characterId) {
         const characterRanks = await this.dataProvider.getMasterData('characterRanks');
@@ -294,16 +305,22 @@ class CardSkillCalculator {
         this.dataProvider = dataProvider;
     }
     async getCardSkill(userCard, card) {
-        const scoreUpMap = new CardDetailMap();
+        const skillMap = new CardDetailMap();
         const detail = await this.getSkillDetail(userCard, card);
         if (detail.scoreUpEnhance !== undefined) {
             for (let i = 1; i <= 5; ++i) {
                 const scoreUp = detail.scoreUp + (i === 5 ? 5 : (i - 1)) * detail.scoreUpEnhance.value;
-                scoreUpMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp);
+                skillMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp, {
+                    scoreUp,
+                    lifeRecovery: detail.lifeRecovery
+                });
             }
         }
-        scoreUpMap.set('any', 1, 1, detail.scoreUp);
-        return { scoreUp: scoreUpMap, lifeRecovery: detail.lifeRecovery };
+        skillMap.set('any', 1, 1, detail.scoreUp, {
+            scoreUp: detail.scoreUp,
+            lifeRecovery: detail.lifeRecovery
+        });
+        return skillMap;
     }
     async getSkillDetail(userCard, card) {
         const skills = await this.dataProvider.getMasterData('skills');
@@ -437,8 +454,7 @@ class CardCalculator {
             units,
             attr: card.attr,
             power,
-            scoreSkill: skill.scoreUp,
-            lifeSkill: skill.lifeRecovery,
+            skill,
             eventBonus
         };
     }
@@ -450,7 +466,7 @@ class CardCalculator {
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
-            cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
+            cardDetail0.skill.isCertainlyLessThen(cardDetail1.skill) &&
             (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
                 cardDetail0.eventBonus <= cardDetail1.eventBonus);
     }
@@ -532,10 +548,10 @@ class LiveCalculator {
         const rate = baseRate + skills.details
             .reduce((v, it, i) => v + it.scoreUp * skillRate[i] / 100, 0);
         const life = skills.details.reduce((v, it) => v + it.lifeRecovery, 0);
-        const powerSum = multiPowerSum === 0 ? 5 * deckDetail.power : multiPowerSum;
+        const powerSum = multiPowerSum === 0 ? 5 * deckDetail.power.total : multiPowerSum;
         const activeBonus = liveType === LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
         return {
-            score: Math.floor(rate * deckDetail.power * 4 + activeBonus),
+            score: Math.floor(rate * deckDetail.power.total * 4 + activeBonus),
             time: musicMeta.music_time,
             life: Math.min(2000, life + 1000),
             tap: musicMeta.tap_count
@@ -662,11 +678,27 @@ class DeckCalculator {
         }
         const cardPower = new Map();
         cardDetails.forEach(cardDetail => {
-            cardPower.set(cardDetail.cardId, cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0));
+            cardPower.set(cardDetail.cardId, cardDetail.units.reduce((vv, unit) => {
+                const current = cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr));
+                return current.total > vv.total ? current : vv;
+            }, cardDetail.power.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), getOrThrow(map, cardDetail.attr))));
         });
-        const power = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId), 0) + honorBonus;
+        const base = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).base, 0);
+        const areaItemBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).areaItemBonus, 0);
+        const characterBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).characterBonus, 0);
+        const total = base + areaItemBonus + characterBonus + honorBonus;
+        const power = {
+            base,
+            areaItemBonus,
+            characterBonus,
+            honorBonus,
+            total
+        };
         const cards = cardDetails.map(cardDetail => {
-            const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
+            const skill = cardDetail.units.reduce((vv, unit) => {
+                const current = cardDetail.skill.get(unit, getOrThrow(map, unit), 1);
+                return current.scoreUp > vv.scoreUp ? current : vv;
+            }, cardDetail.skill.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), 1));
             return {
                 cardId: cardDetail.cardId,
                 level: cardDetail.level,
@@ -674,10 +706,7 @@ class DeckCalculator {
                 masterRank: cardDetail.masterRank,
                 power: getOrThrow(cardPower, cardDetail.cardId),
                 eventBonus: cardDetail.eventBonus,
-                skill: {
-                    scoreUp,
-                    lifeRecovery: cardDetail.lifeSkill
-                }
+                skill
             };
         });
         const eventBonus = EventCalculator.getDeckBonus(cardDetails);
@@ -733,7 +762,7 @@ class AreaItemRecommend {
                 ...currentAreaItemLevels.filter(it => it.areaItemId !== areaItem.id), newAreaItemLevel
             ];
             const { power: newPower } = await this.deckCalculator.getDeckDetail(userCards, 0, newAreaItemLevels);
-            return await this.getRecommendAreaItem(areaItem, newAreaItemLevel, newPower - currentPower);
+            return await this.getRecommendAreaItem(areaItem, newAreaItemLevel, newPower.total - currentPower.total);
         }));
         return recommend.filter(it => it.power > 0)
             .sort((a, b) => b.power / b.cost.coin - a.power / a.cost.coin);
@@ -863,7 +892,7 @@ function compareDeck(deck1, deck2) {
     if (deck1.score !== deck2.score)
         return deck2.score - deck1.score;
     if (deck1.power !== deck2.power)
-        return deck2.power - deck1.power;
+        return deck2.power.total - deck1.power.total;
     return deck1.deckCards[0].cardId - deck2.deckCards[0].cardId;
 }
 function removeSameDeck(it, i, arr) {
@@ -927,7 +956,7 @@ class BaseDeckRecommend {
                 continue;
             if (!isChallengeLive && deckCharacters.includes(card.characterId))
                 continue;
-            if (deckCards.length >= 1 && deckCards[0].scoreSkill.isCertainlyLessThen(card.scoreSkill))
+            if (deckCards.length >= 1 && deckCards[0].skill.isCertainlyLessThen(card.skill))
                 continue;
             if (deckCards.length >= 1 && card.attr !== deckCards[0].attr && !containsAny(deckCards[0].units, card.units)) {
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekai-calculator",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",