sekai-calculator 0.6.3 → 0.6.5

package/dist/index.cjs

@@ -438,8 +438,8 @@ class LiveCalculator {
             ? skillDetails
             : (liveType === exports.LiveType.MULTI
                 ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
-                : [...[...deckDetail.skill].sort((a, b) => a.scoreUp - b.scoreUp),
-                    deckDetail.skill[0]]);
+                : [...[...deckDetail.cards].sort((a, b) => a.scoreUp - b.scoreUp),
+                    deckDetail.cards[0]]);
         const baseRate = LiveCalculator.getBaseScore(musicMeta, liveType);
         const skillScores = [...LiveCalculator.getSkillScore(musicMeta, liveType)];
         const skillRate = skillDetails === undefined
@@ -457,9 +457,11 @@ class LiveCalculator {
         };
     }
     static getMultiLiveSkill(deckDetail) {
-        const scoreUp = deckDetail.skill.reduce((v, it, i) => v + (i === 0 ? it.scoreUp : (it.scoreUp / 5)), 0);
-        const lifeRecovery = deckDetail.skill[0].lifeRecovery;
+        const scoreUp = deckDetail.cards.reduce((v, it, i) => v + (i === 0 ? it.scoreUp : (it.scoreUp / 5)), 0);
+        const lifeRecovery = deckDetail.cards[0].lifeRecovery;
         return {
+            cardId: 0,
+            power: 0,
             scoreUp,
             lifeRecovery
         };
@@ -471,6 +473,8 @@ class LiveCalculator {
         const ret = [];
         for (let i = 0; i < 6; ++i) {
             ret.push({
+                cardId: 0,
+                power: 0,
                 scoreUp: 0,
                 lifeRecovery: 0
             });
@@ -485,7 +489,7 @@ class LiveCalculator {
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === exports.LiveType.MULTI
             ? undefined
-            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.cards);
         return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
     static getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType) {
@@ -567,19 +571,31 @@ class DeckCalculator {
         const map = new Map();
         for (const cardDetail of cardDetails) {
             computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
-            cardDetail.units.forEach(key => { computeWithDefault(map, key, 0, it => it + 1); });
+            cardDetail.units.forEach(key => {
+                computeWithDefault(map, key, 0, it => it + 1);
+            });
         }
-        const power = cardDetails.reduce((v, cardDetail) => v + cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0), 0) + honorBonus;
-        const skill = cardDetails.map(cardDetail => {
+        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));
+        });
+        const power = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId), 0) + honorBonus;
+        const cards = cardDetails.map(cardDetail => {
             const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
             return {
                 cardId: cardDetail.cardId,
+                power: getOrThrow(cardPower, cardDetail.cardId),
+                eventBonus: cardDetail.eventBonus,
                 scoreUp,
                 lifeRecovery: cardDetail.lifeSkill
             };
         });
         const eventBonus = EventCalculator.getDeckBonus(cardDetails);
-        return { power, eventBonus, skill };
+        return {
+            power,
+            eventBonus,
+            cards
+        };
     }
     async getDeckDetail(deckCards) {
         return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
@@ -628,7 +644,7 @@ class BaseDeckRecommend {
                     score,
                     power: deckDetail.power,
                     eventBonus: deckDetail.eventBonus,
-                    deckCards
+                    deckCards: deckDetail.cards
                 }];
         }
         let ans = [];

package/dist/index.d.ts

@@ -117,16 +117,37 @@ interface CardConfig {
     skillMax?: boolean;
 }
 
+declare class DeckCalculator {
+    private readonly dataProvider;
+    private readonly cardCalculator;
+    constructor(dataProvider: DataProvider);
+    getHonorBonusPower(): Promise<number>;
+    static getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): DeckDetail;
+    getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
+}
+interface DeckDetail {
+    power: number;
+    eventBonus?: number;
+    cards: DeckCardDetail[];
+}
+interface DeckCardDetail {
+    cardId: number;
+    power: number;
+    eventBonus?: number;
+    scoreUp: number;
+    lifeRecovery: number;
+}
+
 declare class DeckService {
     private readonly dataProvider;
     constructor(dataProvider: DataProvider);
     getUserCard(cardId: number): Promise<UserCard>;
     getDeck(deckId: number): Promise<UserDeck>;
     getDeckCards(userDeck: UserDeck): Promise<UserCard[]>;
-    static toUserDeck(userCards: CardDetail[], userId?: number, deckId?: number, name?: string): UserDeck;
+    static toUserDeck(userCards: DeckCardDetail[], userId?: number, deckId?: number, name?: string): UserDeck;
     getChallengeLiveSoloDeck(characterId: number): Promise<UserChallengeLiveSoloDeck>;
     getChallengeLiveSoloDeckCards(deck: UserChallengeLiveSoloDeck): Promise<UserCard[]>;
-    static toUserChallengeLiveSoloDeck(userCards: CardDetail[], characterId: number): UserChallengeLiveSoloDeck;
+    static toUserChallengeLiveSoloDeck(userCards: DeckCardDetail[], characterId: number): UserChallengeLiveSoloDeck;
 }
 
 interface CommonResource {
@@ -189,25 +210,6 @@ declare class CardSkillCalculator {
     private getSkillDetail;
 }
 
-declare class DeckCalculator {
-    private readonly dataProvider;
-    private readonly cardCalculator;
-    constructor(dataProvider: DataProvider);
-    getHonorBonusPower(): Promise<number>;
-    static getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): DeckDetail;
-    getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
-}
-interface DeckDetail {
-    power: number;
-    eventBonus?: number;
-    skill: SkillDetail[];
-}
-interface SkillDetail {
-    cardId?: number;
-    scoreUp: number;
-    lifeRecovery: number;
-}
-
 declare class CardEventCalculator {
     private readonly dataProvider;
     constructor(dataProvider: DataProvider);
@@ -237,7 +239,7 @@ declare class LiveCalculator {
     getMusicMeta(musicId: number, musicDiff: string): Promise<MusicMeta>;
     private static getBaseScore;
     private static getSkillScore;
-    static getLiveDetailByDeck(deckDetail: DeckDetail, musicMeta: MusicMeta, liveType: LiveType, skillDetails?: SkillDetail[] | undefined, multiPowerSum?: number): LiveDetail;
+    static getLiveDetailByDeck(deckDetail: DeckDetail, musicMeta: MusicMeta, liveType: LiveType, skillDetails?: DeckCardDetail[] | undefined, multiPowerSum?: number): LiveDetail;
     private static getMultiLiveSkill;
     private static getSoloLiveSkill;
     getLiveDetail(deckCards: UserCard[], musicMeta: MusicMeta, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
@@ -288,7 +290,7 @@ interface RecommendDeck {
     score: number;
     power: number;
     eventBonus?: number;
-    deckCards: CardDetail[];
+    deckCards: DeckCardDetail[];
 }
 interface DeckRecommendConfig {
     musicMeta: MusicMeta;
@@ -567,4 +569,4 @@ interface UserHonor {
     level: number;
 }
 
-export { AreaItemLevel, BaseDeckRecommend, CachedDataProvider, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckDetail, DeckRecommendConfig, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, Music, MusicDifficulty, MusicMeta, MusicRecommend, RecommendDeck, ScoreFunction, Skill, SkillDetail, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };
+export { AreaItemLevel, BaseDeckRecommend, CachedDataProvider, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckCardDetail, DeckDetail, DeckRecommendConfig, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, Music, MusicDifficulty, MusicMeta, MusicRecommend, RecommendDeck, ScoreFunction, Skill, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };

package/dist/index.mjs

@@ -436,8 +436,8 @@ class LiveCalculator {
             ? skillDetails
             : (liveType === LiveType.MULTI
                 ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
-                : [...[...deckDetail.skill].sort((a, b) => a.scoreUp - b.scoreUp),
-                    deckDetail.skill[0]]);
+                : [...[...deckDetail.cards].sort((a, b) => a.scoreUp - b.scoreUp),
+                    deckDetail.cards[0]]);
         const baseRate = LiveCalculator.getBaseScore(musicMeta, liveType);
         const skillScores = [...LiveCalculator.getSkillScore(musicMeta, liveType)];
         const skillRate = skillDetails === undefined
@@ -455,9 +455,11 @@ class LiveCalculator {
         };
     }
     static getMultiLiveSkill(deckDetail) {
-        const scoreUp = deckDetail.skill.reduce((v, it, i) => v + (i === 0 ? it.scoreUp : (it.scoreUp / 5)), 0);
-        const lifeRecovery = deckDetail.skill[0].lifeRecovery;
+        const scoreUp = deckDetail.cards.reduce((v, it, i) => v + (i === 0 ? it.scoreUp : (it.scoreUp / 5)), 0);
+        const lifeRecovery = deckDetail.cards[0].lifeRecovery;
         return {
+            cardId: 0,
+            power: 0,
             scoreUp,
             lifeRecovery
         };
@@ -469,6 +471,8 @@ class LiveCalculator {
         const ret = [];
         for (let i = 0; i < 6; ++i) {
             ret.push({
+                cardId: 0,
+                power: 0,
                 scoreUp: 0,
                 lifeRecovery: 0
             });
@@ -483,7 +487,7 @@ class LiveCalculator {
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === LiveType.MULTI
             ? undefined
-            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.cards);
         return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
     static getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType) {
@@ -565,19 +569,31 @@ class DeckCalculator {
         const map = new Map();
         for (const cardDetail of cardDetails) {
             computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
-            cardDetail.units.forEach(key => { computeWithDefault(map, key, 0, it => it + 1); });
+            cardDetail.units.forEach(key => {
+                computeWithDefault(map, key, 0, it => it + 1);
+            });
         }
-        const power = cardDetails.reduce((v, cardDetail) => v + cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0), 0) + honorBonus;
-        const skill = cardDetails.map(cardDetail => {
+        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));
+        });
+        const power = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId), 0) + honorBonus;
+        const cards = cardDetails.map(cardDetail => {
             const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
             return {
                 cardId: cardDetail.cardId,
+                power: getOrThrow(cardPower, cardDetail.cardId),
+                eventBonus: cardDetail.eventBonus,
                 scoreUp,
                 lifeRecovery: cardDetail.lifeSkill
             };
         });
         const eventBonus = EventCalculator.getDeckBonus(cardDetails);
-        return { power, eventBonus, skill };
+        return {
+            power,
+            eventBonus,
+            cards
+        };
     }
     async getDeckDetail(deckCards) {
         return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
@@ -626,7 +642,7 @@ class BaseDeckRecommend {
                     score,
                     power: deckDetail.power,
                     eventBonus: deckDetail.eventBonus,
-                    deckCards
+                    deckCards: deckDetail.cards
                 }];
         }
         let ans = [];

package/package.json

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