sekai-calculator 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -27,6 +27,13 @@ function duplicateObj(obj, times) {
         ret.push(obj);
     return ret;
 }
+function containsAny(collection, contains) {
+    for (const c of contains) {
+        if (collection.includes(c))
+            return true;
+    }
+    return false;
+}
 
 class DeckService {
     dataProvider;
@@ -151,8 +158,10 @@ class CardPowerCalculator {
             ret[1] += card.specialTrainingPower2BonusFixed;
             ret[2] += card.specialTrainingPower3BonusFixed;
         }
-        const episodes = userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
-            .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
+        const episodes = userCard.episodes === undefined
+            ? []
+            : userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
+                .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
         for (const episode of episodes) {
             ret[0] += episode.power1BonusFixed;
             ret[1] += episode.power2BonusFixed;
@@ -319,7 +328,7 @@ class CardCalculator {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
             cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
             (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
-                cardDetail0.eventBonus < cardDetail1.eventBonus);
+                cardDetail0.eventBonus <= cardDetail1.eventBonus);
     }
 }
 
@@ -362,42 +371,6 @@ class DeckCalculator {
     }
 }
 
-class EventCalculator {
-    dataProvider;
-    cardEventCalculator;
-    constructor(dataProvider) {
-        this.dataProvider = dataProvider;
-        this.cardEventCalculator = new CardEventCalculator(dataProvider);
-    }
-    async getDeckEventBonus(deckCards, eventId) {
-        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
-    }
-    static getEventPoint(type, selfScore, musicRate = 100, deckBonus = 0, boostRate = 1, otherScore = 0, life = 1000) {
-        const musicRate0 = musicRate / 100;
-        const deckRate = deckBonus / 100 + 1;
-        switch (type) {
-            case exports.EventLiveType.SOLO:
-                return Math.floor((100 + Math.floor(selfScore / 20000)) * musicRate0 * deckRate) * boostRate;
-            case exports.EventLiveType.CHALLENGE:
-                return (100 + Math.floor(selfScore / 20000)) * 120;
-            case exports.EventLiveType.MULTI:
-                return Math.floor((110 + Math.floor(selfScore / 17000) +
-                    Math.floor(Math.min(otherScore, 5200000) / 400000)) * musicRate0 * deckRate) * boostRate;
-            case exports.EventLiveType.CHEERFUL:
-                return Math.floor((114 + Math.floor(selfScore / 12500) +
-                    Math.floor(Math.min(otherScore, 4400000) / 400000) + Math.floor(Math.min(life, 1000) / 25)) *
-                    musicRate0 * deckRate) * boostRate;
-        }
-    }
-}
-exports.EventLiveType = void 0;
-(function (EventLiveType) {
-    EventLiveType["SOLO"] = "solo";
-    EventLiveType["CHALLENGE"] = "challenge";
-    EventLiveType["MULTI"] = "multi";
-    EventLiveType["CHEERFUL"] = "cheerful";
-})(exports.EventLiveType || (exports.EventLiveType = {}));
-
 class LiveCalculator {
     dataProvider;
     deckCalculator;
@@ -405,11 +378,17 @@ class LiveCalculator {
         this.dataProvider = dataProvider;
         this.deckCalculator = new DeckCalculator(dataProvider);
     }
+    async getMusicMeta(musicId, musicDiff) {
+        const musicMetas = await this.dataProvider.getMusicMeta();
+        return findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+    }
     static getBaseScore(musicMeta, liveType) {
         switch (liveType) {
             case exports.LiveType.SOLO:
+            case exports.LiveType.CHALLENGE:
                 return musicMeta.base_score;
             case exports.LiveType.MULTI:
+            case exports.LiveType.CHEERFUL:
                 return musicMeta.base_score + musicMeta.fever_score;
             case exports.LiveType.AUTO:
                 return musicMeta.base_score_auto;
@@ -418,8 +397,10 @@ class LiveCalculator {
     static getSkillScore(musicMeta, liveType) {
         switch (liveType) {
             case exports.LiveType.SOLO:
+            case exports.LiveType.CHALLENGE:
                 return musicMeta.skill_score_solo;
             case exports.LiveType.MULTI:
+            case exports.LiveType.CHEERFUL:
                 return musicMeta.skill_score_multi;
             case exports.LiveType.AUTO:
                 return musicMeta.skill_score_auto;
@@ -473,28 +454,176 @@ class LiveCalculator {
         ret[5] = skills[skills.length - 1];
         return ret;
     }
-    async getLiveDetail(deckCards, musicId, musicDiff, liveType, liveSkills = undefined) {
-        const musicMetas = await this.dataProvider.getMusicMeta();
-        const musicMeta = findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+    async getLiveDetail(deckCards, musicMeta, liveType, liveSkills = undefined) {
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === exports.LiveType.MULTI
             ? undefined
             : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
         return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
+    static getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType) {
+        return LiveCalculator.getLiveDetailByDeck(DeckCalculator.getDeckDetailByCards(deckCards, honorBonus), musicMeta, liveType).score;
+    }
 }
 exports.LiveType = void 0;
 (function (LiveType) {
     LiveType["SOLO"] = "solo";
-    LiveType["MULTI"] = "multi";
     LiveType["AUTO"] = "auto";
+    LiveType["CHALLENGE"] = "challenge";
+    LiveType["MULTI"] = "multi";
+    LiveType["CHEERFUL"] = "cheerful";
 })(exports.LiveType || (exports.LiveType = {}));
 
+class EventCalculator {
+    dataProvider;
+    cardEventCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardEventCalculator = new CardEventCalculator(dataProvider);
+    }
+    async getDeckEventBonus(deckCards, eventId) {
+        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
+    }
+    static getEventPoint(type, selfScore, musicRate = 100, deckBonus = 0, boostRate = 1, otherScore = 0, life = 1000) {
+        const musicRate0 = musicRate / 100;
+        const deckRate = deckBonus / 100 + 1;
+        const otherScore0 = otherScore === 0 ? 4 * selfScore : otherScore;
+        switch (type) {
+            case exports.LiveType.SOLO:
+            case exports.LiveType.AUTO:
+                return Math.floor((100 + Math.floor(selfScore / 20000)) * musicRate0 * deckRate) * boostRate;
+            case exports.LiveType.CHALLENGE:
+                return (100 + Math.floor(selfScore / 20000)) * 120;
+            case exports.LiveType.MULTI:
+                return Math.floor((110 + Math.floor(selfScore / 17000) +
+                    Math.floor(Math.min(otherScore0, 5200000) / 400000)) * musicRate0 * deckRate) * boostRate;
+            case exports.LiveType.CHEERFUL:
+                return Math.floor((114 + Math.floor(selfScore / 12500) +
+                    Math.floor(Math.min(otherScore0, 4400000) / 400000) + Math.floor(Math.min(life, 1000) / 25)) *
+                    musicRate0 * deckRate) * boostRate;
+        }
+    }
+    static getDeckEventPoint(deckCards, honorBonus, musicMeta, liveType) {
+        const deckBonus = deckCards.reduce((v, it) => v + (it.eventBonus === undefined ? 0 : it.eventBonus), 0);
+        const score = LiveCalculator.getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType);
+        return EventCalculator.getEventPoint(liveType, score, musicMeta.event_rate, deckBonus);
+    }
+}
+
+class BaseDeckRecommend {
+    dataProvider;
+    cardCalculator;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardCalculator = new CardCalculator(dataProvider);
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    static filterCard(cardDetails) {
+        let afterFilter = cardDetails;
+        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+            const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
+            if (bonusFilter.length >= 5) {
+                afterFilter = bonusFilter;
+                break;
+            }
+        }
+        return afterFilter;
+    }
+    static findBestCards(cardDetails, scoreFunc, isChallengeLive = false, member = 5, deckCards = [], deckCharacters = []) {
+        if (deckCards.length === member) {
+            return {
+                score: scoreFunc(deckCards),
+                deckCards
+            };
+        }
+        let ans = {
+            score: 0,
+            deckCards: cardDetails
+        };
+        let preCard = cardDetails[0];
+        for (const card of cardDetails) {
+            if (deckCards.includes(card))
+                continue;
+            if (!isChallengeLive && deckCharacters.includes(card.characterId))
+                continue;
+            if (deckCards.length >= 1 && deckCards[0].scoreSkill.isCertainlyLessThen(card.scoreSkill))
+                continue;
+            if (deckCards.length >= 1 && card.attr !== deckCards[0].attr && !containsAny(deckCards[0].units, card.units)) {
+                continue;
+            }
+            if (CardCalculator.isCertainlyLessThan(card, preCard))
+                continue;
+            preCard = card;
+            const result = BaseDeckRecommend.findBestCards(cardDetails, scoreFunc, isChallengeLive, member, [...deckCards, card], [...deckCharacters, card.characterId]);
+            if (result.score > ans.score)
+                ans = result;
+        }
+        return ans;
+    }
+    async recommendHighScoreDeck(userCards, musicId, musicDiff, scoreFunc, eventId = 0, isChallengeLive = false, member = 5) {
+        const musicMetas = await this.dataProvider.getMusicMeta();
+        const musicMeta = findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+        const cardDetails = BaseDeckRecommend.filterCard(await this.cardCalculator.batchGetCardDetail(userCards, eventId));
+        const honorBonus = await this.deckCalculator.getHonorBonusPower();
+        const best = BaseDeckRecommend.findBestCards(cardDetails, deckCards => scoreFunc(musicMeta, honorBonus, deckCards), isChallengeLive, member);
+        return {
+            score: best.score,
+            deckCards: best.deckCards.map(deckCard => findOrThrow(userCards, it => it.cardId === deckCard.cardId))
+        };
+    }
+    static getLiveScoreFunction(liveType) {
+        return (musicMeta, honorBonus, deckCards) => LiveCalculator.getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType);
+    }
+    static getEventPointFunction(liveType) {
+        return (musicMeta, honorBonus, deckCards) => EventCalculator.getDeckEventPoint(deckCards, honorBonus, musicMeta, liveType);
+    }
+}
+
+class ChallengeLiveDeckRecommend {
+    dataProvider;
+    baseRecommend;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.baseRecommend = new BaseDeckRecommend(dataProvider);
+    }
+    async recommendChallengeLiveDeck(characterId, musicId, musicDiff, member = 5) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const cards = await this.dataProvider.getMasterData('cards');
+        const characterCards = userCards
+            .filter(userCard => findOrThrow(cards, it => it.id === userCard.cardId).characterId === characterId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, musicId, musicDiff, BaseDeckRecommend.getLiveScoreFunction(exports.LiveType.SOLO), 0, true, member);
+        return {
+            score: recommend.score,
+            deck: DeckService.toUserChallengeLiveSoloDeck(recommend.deckCards, characterId)
+        };
+    }
+}
+
+class EventDeckRecommend {
+    dataProvider;
+    baseRecommend;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.baseRecommend = new BaseDeckRecommend(dataProvider);
+    }
+    async recommendEventDeck(eventId, musicId, musicDiff, liveType) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicId, musicDiff, BaseDeckRecommend.getEventPointFunction(liveType), eventId);
+        return {
+            point: recommend.score,
+            deck: DeckService.toUserDeck(recommend.deckCards)
+        };
+    }
+}
+
 exports.CardCalculator = CardCalculator;
 exports.CardEventCalculator = CardEventCalculator;
 exports.CardPowerCalculator = CardPowerCalculator;
 exports.CardSkillCalculator = CardSkillCalculator;
+exports.ChallengeLiveDeckRecommend = ChallengeLiveDeckRecommend;
 exports.DeckCalculator = DeckCalculator;
 exports.DeckService = DeckService;
 exports.EventCalculator = EventCalculator;
+exports.EventDeckRecommend = EventDeckRecommend;
 exports.LiveCalculator = LiveCalculator;

package/dist/index.d.ts

@@ -193,20 +193,6 @@ declare class CardEventCalculator {
     getCardEventBonus(userCard: UserCard, eventId: number): Promise<number>;
 }
 
-declare class EventCalculator {
-    private readonly dataProvider;
-    private readonly cardEventCalculator;
-    constructor(dataProvider: DataProvider);
-    getDeckEventBonus(deckCards: UserCard[], eventId: number): Promise<number>;
-    static getEventPoint(type: EventLiveType, selfScore: number, musicRate?: number, deckBonus?: number, boostRate?: number, otherScore?: number, life?: number): number;
-}
-declare enum EventLiveType {
-    SOLO = "solo",
-    CHALLENGE = "challenge",
-    MULTI = "multi",
-    CHEERFUL = "cheerful"
-}
-
 interface MusicMeta {
     music_id: number;
     difficulty: string;
@@ -226,12 +212,14 @@ declare class LiveCalculator {
     private readonly dataProvider;
     private readonly deckCalculator;
     constructor(dataProvider: DataProvider);
+    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;
     private static getMultiLiveSkill;
     private static getSoloLiveSkill;
-    getLiveDetail(deckCards: UserCard[], musicId: number, musicDiff: string, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
+    getLiveDetail(deckCards: UserCard[], musicMeta: MusicMeta, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
+    static getLiveScoreByDeck(deckCards: CardDetail[], honorBonus: number, musicMeta: MusicMeta, liveType: LiveType): number;
 }
 interface LiveDetail {
     score: number;
@@ -245,8 +233,39 @@ interface LiveSkill {
 }
 declare enum LiveType {
     SOLO = "solo",
+    AUTO = "auto",
+    CHALLENGE = "challenge",
     MULTI = "multi",
-    AUTO = "auto"
+    CHEERFUL = "cheerful"
+}
+
+declare class EventCalculator {
+    private readonly dataProvider;
+    private readonly cardEventCalculator;
+    constructor(dataProvider: DataProvider);
+    getDeckEventBonus(deckCards: UserCard[], eventId: number): Promise<number>;
+    static getEventPoint(type: LiveType, selfScore: number, musicRate?: number, deckBonus?: number, boostRate?: number, otherScore?: number, life?: number): number;
+    static getDeckEventPoint(deckCards: CardDetail[], honorBonus: number, musicMeta: MusicMeta, liveType: LiveType): number;
+}
+
+declare class ChallengeLiveDeckRecommend {
+    private readonly dataProvider;
+    private readonly baseRecommend;
+    constructor(dataProvider: DataProvider);
+    recommendChallengeLiveDeck(characterId: number, musicId: number, musicDiff: string, member?: number): Promise<{
+        score: number;
+        deck: UserChallengeLiveSoloDeck;
+    }>;
+}
+
+declare class EventDeckRecommend {
+    private readonly dataProvider;
+    private readonly baseRecommend;
+    constructor(dataProvider: DataProvider);
+    recommendEventDeck(eventId: number, musicId: number, musicDiff: string, liveType: LiveType): Promise<{
+        point: number;
+        deck: UserDeck;
+    }>;
 }
 
-export { CardCalculator, CardDetail, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };
+export { CardCalculator, CardDetail, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };

package/dist/index.mjs

@@ -25,6 +25,13 @@ function duplicateObj(obj, times) {
         ret.push(obj);
     return ret;
 }
+function containsAny(collection, contains) {
+    for (const c of contains) {
+        if (collection.includes(c))
+            return true;
+    }
+    return false;
+}
 
 class DeckService {
     dataProvider;
@@ -149,8 +156,10 @@ class CardPowerCalculator {
             ret[1] += card.specialTrainingPower2BonusFixed;
             ret[2] += card.specialTrainingPower3BonusFixed;
         }
-        const episodes = userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
-            .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
+        const episodes = userCard.episodes === undefined
+            ? []
+            : userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
+                .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
         for (const episode of episodes) {
             ret[0] += episode.power1BonusFixed;
             ret[1] += episode.power2BonusFixed;
@@ -317,7 +326,7 @@ class CardCalculator {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
             cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
             (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
-                cardDetail0.eventBonus < cardDetail1.eventBonus);
+                cardDetail0.eventBonus <= cardDetail1.eventBonus);
     }
 }
 
@@ -360,42 +369,6 @@ class DeckCalculator {
     }
 }
 
-class EventCalculator {
-    dataProvider;
-    cardEventCalculator;
-    constructor(dataProvider) {
-        this.dataProvider = dataProvider;
-        this.cardEventCalculator = new CardEventCalculator(dataProvider);
-    }
-    async getDeckEventBonus(deckCards, eventId) {
-        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
-    }
-    static getEventPoint(type, selfScore, musicRate = 100, deckBonus = 0, boostRate = 1, otherScore = 0, life = 1000) {
-        const musicRate0 = musicRate / 100;
-        const deckRate = deckBonus / 100 + 1;
-        switch (type) {
-            case EventLiveType.SOLO:
-                return Math.floor((100 + Math.floor(selfScore / 20000)) * musicRate0 * deckRate) * boostRate;
-            case EventLiveType.CHALLENGE:
-                return (100 + Math.floor(selfScore / 20000)) * 120;
-            case EventLiveType.MULTI:
-                return Math.floor((110 + Math.floor(selfScore / 17000) +
-                    Math.floor(Math.min(otherScore, 5200000) / 400000)) * musicRate0 * deckRate) * boostRate;
-            case EventLiveType.CHEERFUL:
-                return Math.floor((114 + Math.floor(selfScore / 12500) +
-                    Math.floor(Math.min(otherScore, 4400000) / 400000) + Math.floor(Math.min(life, 1000) / 25)) *
-                    musicRate0 * deckRate) * boostRate;
-        }
-    }
-}
-var EventLiveType;
-(function (EventLiveType) {
-    EventLiveType["SOLO"] = "solo";
-    EventLiveType["CHALLENGE"] = "challenge";
-    EventLiveType["MULTI"] = "multi";
-    EventLiveType["CHEERFUL"] = "cheerful";
-})(EventLiveType || (EventLiveType = {}));
-
 class LiveCalculator {
     dataProvider;
     deckCalculator;
@@ -403,11 +376,17 @@ class LiveCalculator {
         this.dataProvider = dataProvider;
         this.deckCalculator = new DeckCalculator(dataProvider);
     }
+    async getMusicMeta(musicId, musicDiff) {
+        const musicMetas = await this.dataProvider.getMusicMeta();
+        return findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+    }
     static getBaseScore(musicMeta, liveType) {
         switch (liveType) {
             case LiveType.SOLO:
+            case LiveType.CHALLENGE:
                 return musicMeta.base_score;
             case LiveType.MULTI:
+            case LiveType.CHEERFUL:
                 return musicMeta.base_score + musicMeta.fever_score;
             case LiveType.AUTO:
                 return musicMeta.base_score_auto;
@@ -416,8 +395,10 @@ class LiveCalculator {
     static getSkillScore(musicMeta, liveType) {
         switch (liveType) {
             case LiveType.SOLO:
+            case LiveType.CHALLENGE:
                 return musicMeta.skill_score_solo;
             case LiveType.MULTI:
+            case LiveType.CHEERFUL:
                 return musicMeta.skill_score_multi;
             case LiveType.AUTO:
                 return musicMeta.skill_score_auto;
@@ -471,21 +452,167 @@ class LiveCalculator {
         ret[5] = skills[skills.length - 1];
         return ret;
     }
-    async getLiveDetail(deckCards, musicId, musicDiff, liveType, liveSkills = undefined) {
-        const musicMetas = await this.dataProvider.getMusicMeta();
-        const musicMeta = findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+    async getLiveDetail(deckCards, musicMeta, liveType, liveSkills = undefined) {
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === LiveType.MULTI
             ? undefined
             : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
         return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
+    static getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType) {
+        return LiveCalculator.getLiveDetailByDeck(DeckCalculator.getDeckDetailByCards(deckCards, honorBonus), musicMeta, liveType).score;
+    }
 }
 var LiveType;
 (function (LiveType) {
     LiveType["SOLO"] = "solo";
-    LiveType["MULTI"] = "multi";
     LiveType["AUTO"] = "auto";
+    LiveType["CHALLENGE"] = "challenge";
+    LiveType["MULTI"] = "multi";
+    LiveType["CHEERFUL"] = "cheerful";
 })(LiveType || (LiveType = {}));
 
-export { CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DeckCalculator, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveType };
+class EventCalculator {
+    dataProvider;
+    cardEventCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardEventCalculator = new CardEventCalculator(dataProvider);
+    }
+    async getDeckEventBonus(deckCards, eventId) {
+        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
+    }
+    static getEventPoint(type, selfScore, musicRate = 100, deckBonus = 0, boostRate = 1, otherScore = 0, life = 1000) {
+        const musicRate0 = musicRate / 100;
+        const deckRate = deckBonus / 100 + 1;
+        const otherScore0 = otherScore === 0 ? 4 * selfScore : otherScore;
+        switch (type) {
+            case LiveType.SOLO:
+            case LiveType.AUTO:
+                return Math.floor((100 + Math.floor(selfScore / 20000)) * musicRate0 * deckRate) * boostRate;
+            case LiveType.CHALLENGE:
+                return (100 + Math.floor(selfScore / 20000)) * 120;
+            case LiveType.MULTI:
+                return Math.floor((110 + Math.floor(selfScore / 17000) +
+                    Math.floor(Math.min(otherScore0, 5200000) / 400000)) * musicRate0 * deckRate) * boostRate;
+            case LiveType.CHEERFUL:
+                return Math.floor((114 + Math.floor(selfScore / 12500) +
+                    Math.floor(Math.min(otherScore0, 4400000) / 400000) + Math.floor(Math.min(life, 1000) / 25)) *
+                    musicRate0 * deckRate) * boostRate;
+        }
+    }
+    static getDeckEventPoint(deckCards, honorBonus, musicMeta, liveType) {
+        const deckBonus = deckCards.reduce((v, it) => v + (it.eventBonus === undefined ? 0 : it.eventBonus), 0);
+        const score = LiveCalculator.getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType);
+        return EventCalculator.getEventPoint(liveType, score, musicMeta.event_rate, deckBonus);
+    }
+}
+
+class BaseDeckRecommend {
+    dataProvider;
+    cardCalculator;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardCalculator = new CardCalculator(dataProvider);
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    static filterCard(cardDetails) {
+        let afterFilter = cardDetails;
+        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+            const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
+            if (bonusFilter.length >= 5) {
+                afterFilter = bonusFilter;
+                break;
+            }
+        }
+        return afterFilter;
+    }
+    static findBestCards(cardDetails, scoreFunc, isChallengeLive = false, member = 5, deckCards = [], deckCharacters = []) {
+        if (deckCards.length === member) {
+            return {
+                score: scoreFunc(deckCards),
+                deckCards
+            };
+        }
+        let ans = {
+            score: 0,
+            deckCards: cardDetails
+        };
+        let preCard = cardDetails[0];
+        for (const card of cardDetails) {
+            if (deckCards.includes(card))
+                continue;
+            if (!isChallengeLive && deckCharacters.includes(card.characterId))
+                continue;
+            if (deckCards.length >= 1 && deckCards[0].scoreSkill.isCertainlyLessThen(card.scoreSkill))
+                continue;
+            if (deckCards.length >= 1 && card.attr !== deckCards[0].attr && !containsAny(deckCards[0].units, card.units)) {
+                continue;
+            }
+            if (CardCalculator.isCertainlyLessThan(card, preCard))
+                continue;
+            preCard = card;
+            const result = BaseDeckRecommend.findBestCards(cardDetails, scoreFunc, isChallengeLive, member, [...deckCards, card], [...deckCharacters, card.characterId]);
+            if (result.score > ans.score)
+                ans = result;
+        }
+        return ans;
+    }
+    async recommendHighScoreDeck(userCards, musicId, musicDiff, scoreFunc, eventId = 0, isChallengeLive = false, member = 5) {
+        const musicMetas = await this.dataProvider.getMusicMeta();
+        const musicMeta = findOrThrow(musicMetas, it => it.music_id === musicId && it.difficulty === musicDiff);
+        const cardDetails = BaseDeckRecommend.filterCard(await this.cardCalculator.batchGetCardDetail(userCards, eventId));
+        const honorBonus = await this.deckCalculator.getHonorBonusPower();
+        const best = BaseDeckRecommend.findBestCards(cardDetails, deckCards => scoreFunc(musicMeta, honorBonus, deckCards), isChallengeLive, member);
+        return {
+            score: best.score,
+            deckCards: best.deckCards.map(deckCard => findOrThrow(userCards, it => it.cardId === deckCard.cardId))
+        };
+    }
+    static getLiveScoreFunction(liveType) {
+        return (musicMeta, honorBonus, deckCards) => LiveCalculator.getLiveScoreByDeck(deckCards, honorBonus, musicMeta, liveType);
+    }
+    static getEventPointFunction(liveType) {
+        return (musicMeta, honorBonus, deckCards) => EventCalculator.getDeckEventPoint(deckCards, honorBonus, musicMeta, liveType);
+    }
+}
+
+class ChallengeLiveDeckRecommend {
+    dataProvider;
+    baseRecommend;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.baseRecommend = new BaseDeckRecommend(dataProvider);
+    }
+    async recommendChallengeLiveDeck(characterId, musicId, musicDiff, member = 5) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const cards = await this.dataProvider.getMasterData('cards');
+        const characterCards = userCards
+            .filter(userCard => findOrThrow(cards, it => it.id === userCard.cardId).characterId === characterId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, musicId, musicDiff, BaseDeckRecommend.getLiveScoreFunction(LiveType.SOLO), 0, true, member);
+        return {
+            score: recommend.score,
+            deck: DeckService.toUserChallengeLiveSoloDeck(recommend.deckCards, characterId)
+        };
+    }
+}
+
+class EventDeckRecommend {
+    dataProvider;
+    baseRecommend;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.baseRecommend = new BaseDeckRecommend(dataProvider);
+    }
+    async recommendEventDeck(eventId, musicId, musicDiff, liveType) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicId, musicDiff, BaseDeckRecommend.getEventPointFunction(liveType), eventId);
+        return {
+            point: recommend.score,
+            deck: DeckService.toUserDeck(recommend.deckCards)
+        };
+    }
+}
+
+export { CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DeckCalculator, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveType };

package/package.json

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