sekai-calculator 0.8.0 → 0.8.3

package/dist/index.cjs

@@ -77,6 +77,37 @@ class CachedDataProvider {
     async getUserDataAll() {
         return await this.getData(this.instanceCache, 'userData', async () => await this.dataProvider.getUserDataAll());
     }
+    async preloadMasterData(keys) {
+        return await Promise.all(keys.map(async (it) => await this.getMasterData(it)));
+    }
+}
+
+class AreaItemService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getAreaItemLevels() {
+        const userAreas = await this.dataProvider.getUserData('userAreas');
+        return await Promise.all(userAreas.flatMap(it => it.areaItems)
+            .map(async (it) => await this.getAreaItemLevel(it.areaItemId, it.level)));
+    }
+    async getAreaItemLevel(areaItemId, level) {
+        const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
+        return findOrThrow(areaItemLevels, it => it.areaItemId === areaItemId && it.level === level);
+    }
+    async getAreaItemNextLevel(areaItem, areaItemLevel) {
+        const level = areaItemLevel === undefined ? 1 : (areaItemLevel.level === 15 ? 15 : areaItemLevel.level + 1);
+        return await this.getAreaItemLevel(areaItem.id, level);
+    }
+    async getShopItem(areaItemLevel) {
+        const shopItems = await this.dataProvider.getMasterData('shopItems');
+        const idOffset = areaItemLevel.level <= 10
+            ? (1000 + (areaItemLevel.areaItemId - 1) * 10)
+            : (1550 - 10 + (areaItemLevel.areaItemId - 1) * 5);
+        const id = idOffset + areaItemLevel.level;
+        return findOrThrow(shopItems, it => it.id === id);
+    }
 }
 
 class DeckService {
@@ -189,8 +220,12 @@ class CardPowerCalculator {
         return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
     }
     async getCardBasePowers(userCard, card) {
-        const cardEpisodes = await this.dataProvider.getMasterData('cardEpisodes');
-        const masterLessons = await this.dataProvider.getMasterData('masterLessons');
+        const p = await Promise.all([
+            await this.dataProvider.getMasterData('cardEpisodes'),
+            await this.dataProvider.getMasterData('masterLessons')
+        ]);
+        const cardEpisodes = p[0];
+        const masterLessons = p[1];
         const ret = [0, 0, 0];
         const cardParameters = card.cardParameters.filter(it => it.cardLevel === userCard.level);
         const params = ['param1', 'param2', 'param3'];
@@ -330,11 +365,13 @@ class CardCalculator {
     powerCalculator;
     skillCalculator;
     eventCalculator;
+    areaItemService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
         this.skillCalculator = new CardSkillCalculator(dataProvider);
         this.eventCalculator = new CardEventCalculator(dataProvider);
+        this.areaItemService = new AreaItemService(dataProvider);
     }
     async getCardUnits(card) {
         const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
@@ -360,7 +397,9 @@ class CardCalculator {
             }
         }
         if (episodeRead && ret.episodes !== undefined) {
-            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+            ret.episodes.forEach(it => {
+                it.scenarioStatus = 'already_read';
+            });
         }
         if (masterMax) {
             ret.masterRank = 5;
@@ -393,11 +432,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, config = {}, eventId = 0) {
-        const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
-        const userAreas = await this.dataProvider.getUserData('userAreas');
-        const userItemLevels = userAreas.flatMap(it => it.areaItems).map(areaItem => findOrThrow(areaItemLevels, it => it.areaItemId === areaItem.areaItemId && it.level === areaItem.level));
-        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
+    async batchGetCardDetail(userCards, config = {}, eventId = 0, areaItemLevels) {
+        const areaItemLevels0 = areaItemLevels === undefined
+            ? await this.areaItemService.getAreaItemLevels()
+            : areaItemLevels;
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -442,21 +481,47 @@ class LiveCalculator {
                 return musicMeta.skill_score_auto;
         }
     }
+    static getSortedSkillDetails(deckDetail, liveType, skillDetails = undefined) {
+        if (skillDetails !== undefined && skillDetails.length === 6 && skillDetails[5].scoreUp > 0) {
+            return {
+                details: skillDetails,
+                sorted: false
+            };
+        }
+        if (liveType === exports.LiveType.MULTI) {
+            return {
+                details: duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6),
+                sorted: false
+            };
+        }
+        const sortedSkill = [...deckDetail.cards].map(it => it.skill)
+            .sort((a, b) => a.scoreUp - b.scoreUp);
+        const emptySkill = duplicateObj({
+            scoreUp: 0,
+            lifeRecovery: 0
+        }, 5 - sortedSkill.length);
+        return {
+            details: [...sortedSkill, ...emptySkill, deckDetail.cards[0].skill],
+            sorted: true
+        };
+    }
+    static getSortedSkillRate(sorted, cardLength, skillScores) {
+        if (!sorted) {
+            return skillScores;
+        }
+        return [
+            ...skillScores.slice(0, cardLength).sort((a, b) => a - b),
+            ...skillScores.slice(cardLength)
+        ];
+    }
     static getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
-        const skills = skillDetails !== undefined
-            ? skillDetails
-            : (liveType === exports.LiveType.MULTI
-                ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
-                : [...[...deckDetail.cards].map(it => it.skill)
-                        .sort((a, b) => a.scoreUp - b.scoreUp),
-                    deckDetail.cards[0].skill]);
+        const skills = this.getSortedSkillDetails(deckDetail, liveType, skillDetails);
         const baseRate = LiveCalculator.getBaseScore(musicMeta, liveType);
         const skillScores = [...LiveCalculator.getSkillScore(musicMeta, liveType)];
-        const skillRate = skillDetails === undefined
-            ? [...skillScores.slice(0, 5).sort((a, b) => a - b), skillScores[5]]
-            : skillScores;
-        const rate = baseRate + skills.reduce((v, it, i) => v + it.scoreUp * skillRate[i] / 100, 0);
-        const life = skills.reduce((v, it) => v + it.lifeRecovery, 0);
+        const skillRate = LiveCalculator.getSortedSkillRate(skills.sorted, deckDetail.cards.length, skillScores);
+        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 activeBonus = liveType === exports.LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
         return {
@@ -612,8 +677,56 @@ class DeckCalculator {
             cards
         };
     }
-    async getDeckDetail(deckCards) {
-        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
+    async getDeckDetail(deckCards, eventId = 0, areaItemLevels) {
+        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards, {}, eventId, areaItemLevels), await this.getHonorBonusPower());
+    }
+}
+
+class AreaItemRecommend {
+    dataProvider;
+    areaItemService;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.areaItemService = new AreaItemService(dataProvider);
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    static findCost(shopItem, resourceType, resourceId) {
+        const cost = shopItem.costs.map(it => it.cost)
+            .find(it => it.resourceType === resourceType && it.resourceId === resourceId);
+        return cost === undefined ? 0 : cost.quantity;
+    }
+    async getRecommendAreaItem(areaItem, areaItemLevel, power) {
+        const areas = await this.dataProvider.getMasterData('areas');
+        const area = findOrThrow(areas, it => it.id === areaItem.areaId);
+        const shopItem = await this.areaItemService.getShopItem(areaItemLevel);
+        return {
+            area,
+            areaItem,
+            areaItemLevel,
+            shopItem,
+            cost: {
+                coin: AreaItemRecommend.findCost(shopItem, 'coin', 0),
+                seed: AreaItemRecommend.findCost(shopItem, 'material', 17),
+                szk: AreaItemRecommend.findCost(shopItem, 'material', 57)
+            },
+            power
+        };
+    }
+    async recommendAreaItem(userCards) {
+        const areaItems = await this.dataProvider.getMasterData('areaItems');
+        const currentAreaItemLevels = await this.areaItemService.getAreaItemLevels();
+        const { power: currentPower } = await this.deckCalculator.getDeckDetail(userCards, 0, currentAreaItemLevels);
+        const recommend = await Promise.all(areaItems.map(async (areaItem) => {
+            const newAreaItemLevel = await this.areaItemService.getAreaItemNextLevel(areaItem, currentAreaItemLevels.find(it => it.areaItemId === areaItem.id));
+            const newAreaItemLevels = [
+                ...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 recommend.filter(it => it.power > 0)
+            .sort((a, b) => b.power / b.cost.coin - a.power / a.cost.coin);
     }
 }
 
@@ -763,12 +876,17 @@ class BaseDeckRecommend {
     dataProvider;
     cardCalculator;
     deckCalculator;
+    areaItemService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.cardCalculator = new CardCalculator(dataProvider);
         this.deckCalculator = new DeckCalculator(dataProvider);
+        this.areaItemService = new AreaItemService(dataProvider);
     }
     static findBestCards(cardDetails, scoreFunc, limit = 1, isChallengeLive = false, member = 5, honorBonus = 0, deckCards = [], deckCharacters = []) {
+        if (isChallengeLive) {
+            member = Math.min(member, cardDetails.length);
+        }
         if (deckCards.length === member) {
             const score = scoreFunc(deckCards);
             const deckDetail = DeckCalculator.getDeckDetailByCards(deckCards, honorBonus);
@@ -823,7 +941,8 @@ class BaseDeckRecommend {
         return ans;
     }
     async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
+        const areaItemLevels = await this.areaItemService.getAreaItemLevels();
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId, areaItemLevels);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
         let priority = (isChallengeLive || eventId === 0) ? 10 : 0;
         while (priority < 10) {
@@ -909,6 +1028,8 @@ class MusicRecommend {
     }
 }
 
+exports.AreaItemRecommend = AreaItemRecommend;
+exports.AreaItemService = AreaItemService;
 exports.BaseDeckRecommend = BaseDeckRecommend;
 exports.CachedDataProvider = CachedDataProvider;
 exports.CardCalculator = CardCalculator;

package/dist/index.d.ts

@@ -1,8 +1,23 @@
+interface MusicMeta {
+    music_id: number;
+    difficulty: string;
+    music_time: number;
+    event_rate: number;
+    base_score: number;
+    base_score_auto: number;
+    skill_score_solo: number[];
+    skill_score_auto: number[];
+    skill_score_multi: number[];
+    fever_score: number;
+    fever_end_time: number;
+    tap_count: number;
+}
+
 interface DataProvider {
-    getMasterData: (key: string) => Promise<any>;
-    getUserDataAll: () => Promise<any>;
-    getUserData: (key: string) => Promise<any>;
-    getMusicMeta: () => Promise<any>;
+    getMasterData: <T>(key: string) => Promise<T[]>;
+    getUserDataAll: () => Promise<Record<string, any>>;
+    getUserData: <T>(key: string) => Promise<T>;
+    getMusicMeta: () => Promise<MusicMeta[]>;
 }
 
 declare class CachedDataProvider implements DataProvider {
@@ -12,10 +27,64 @@ declare class CachedDataProvider implements DataProvider {
     private readonly instanceCache;
     private static readonly runningPromise;
     private getData;
-    getMasterData(key: string): Promise<any>;
-    getMusicMeta(): Promise<any>;
-    getUserData(key: string): Promise<any>;
-    getUserDataAll(): Promise<any>;
+    getMasterData<T>(key: string): Promise<T[]>;
+    getMusicMeta(): Promise<MusicMeta[]>;
+    getUserData<T>(key: string): Promise<T>;
+    getUserDataAll(): Promise<Record<string, any>>;
+    preloadMasterData(keys: string[]): Promise<any[]>;
+}
+
+interface AreaItemLevel {
+    areaItemId: number;
+    level: number;
+    targetUnit: string;
+    targetCardAttr: string;
+    targetGameCharacterId?: number;
+    power1BonusRate: number;
+    power1AllMatchBonusRate: number;
+    power2BonusRate: number;
+    power2AllMatchBonusRate: number;
+    power3BonusRate: number;
+    power3AllMatchBonusRate: number;
+    sentence: string;
+}
+
+interface AreaItem {
+    id: number;
+    areaId: number;
+    name: string;
+    flavorText: string;
+    spawnPoint: string;
+    assetbundleName: string;
+}
+
+interface CommonResource {
+    resourceId?: number;
+    resourceType: string;
+    resourceLevel?: number;
+    quantity: number;
+}
+
+interface ShopItem {
+    id: number;
+    shopId: number;
+    seq: number;
+    releaseConditionId: number;
+    resourceBoxId: number;
+    costs: Array<{
+        shopItemId: number;
+        seq: number;
+        cost: CommonResource;
+    }>;
+}
+
+declare class AreaItemService {
+    private readonly dataProvider;
+    constructor(dataProvider: DataProvider);
+    getAreaItemLevels(): Promise<AreaItemLevel[]>;
+    getAreaItemLevel(areaItemId: number, level: number): Promise<AreaItemLevel>;
+    getAreaItemNextLevel(areaItem: AreaItem, areaItemLevel?: AreaItemLevel): Promise<AreaItemLevel>;
+    getShopItem(areaItemLevel: AreaItemLevel): Promise<ShopItem>;
 }
 
 interface UserDeck {
@@ -62,21 +131,6 @@ interface UserChallengeLiveSoloDeck {
     support4: number | null;
 }
 
-interface AreaItemLevel {
-    areaItemId: number;
-    level: number;
-    targetUnit: string;
-    targetCardAttr: string;
-    targetGameCharacterId?: number;
-    power1BonusRate: number;
-    power1AllMatchBonusRate: number;
-    power2BonusRate: number;
-    power2AllMatchBonusRate: number;
-    power3BonusRate: number;
-    power3AllMatchBonusRate: number;
-    sentence: string;
-}
-
 declare class CardDetailMap {
     min: number;
     max: number;
@@ -93,11 +147,12 @@ declare class CardCalculator {
     private readonly powerCalculator;
     private readonly skillCalculator;
     private readonly eventCalculator;
+    private readonly areaItemService;
     constructor(dataProvider: DataProvider);
     private getCardUnits;
     private applyCardConfig;
     getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], config?: Record<string, CardConfig>, eventId?: number): Promise<CardDetail>;
-    batchGetCardDetail(userCards: UserCard[], config?: Record<string, CardConfig>, eventId?: number): Promise<CardDetail[]>;
+    batchGetCardDetail(userCards: UserCard[], config?: Record<string, CardConfig>, eventId?: number, areaItemLevels?: AreaItemLevel[]): Promise<CardDetail[]>;
     static isCertainlyLessThan(cardDetail0: CardDetail, cardDetail1: CardDetail): boolean;
 }
 interface CardDetail {
@@ -127,7 +182,7 @@ declare class DeckCalculator {
     constructor(dataProvider: DataProvider);
     getHonorBonusPower(): Promise<number>;
     static getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): DeckDetail;
-    getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
+    getDeckDetail(deckCards: UserCard[], eventId?: number, areaItemLevels?: AreaItemLevel[]): Promise<DeckDetail>;
 }
 interface DeckDetail {
     power: number;
@@ -160,13 +215,6 @@ declare class DeckService {
     static toUserChallengeLiveSoloDeck(userCards: DeckCardDetail[], characterId: number): UserChallengeLiveSoloDeck;
 }
 
-interface CommonResource {
-    resourceId?: number;
-    resourceType: string;
-    resourceLevel?: number;
-    quantity: number;
-}
-
 interface Card {
     id: number;
     seq: number;
@@ -227,21 +275,6 @@ declare class CardEventCalculator {
     getCardEventBonus(userCard: UserCard, eventId: number): Promise<number>;
 }
 
-interface MusicMeta {
-    music_id: number;
-    difficulty: string;
-    music_time: number;
-    event_rate: number;
-    base_score: number;
-    base_score_auto: number;
-    skill_score_solo: number[];
-    skill_score_auto: number[];
-    skill_score_multi: number[];
-    fever_score: number;
-    fever_end_time: number;
-    tap_count: number;
-}
-
 declare class LiveCalculator {
     private readonly dataProvider;
     private readonly deckCalculator;
@@ -249,6 +282,8 @@ declare class LiveCalculator {
     getMusicMeta(musicId: number, musicDiff: string): Promise<MusicMeta>;
     private static getBaseScore;
     private static getSkillScore;
+    private static getSortedSkillDetails;
+    private static getSortedSkillRate;
     static getLiveDetailByDeck(deckDetail: DeckDetail, musicMeta: MusicMeta, liveType: LiveType, skillDetails?: DeckCardSkillDetail[] | undefined, multiPowerSum?: number): LiveDetail;
     private static getMultiLiveSkill;
     private static getSoloLiveSkill;
@@ -283,10 +318,42 @@ declare class EventCalculator {
     static getDeckEventPoint(deckCards: CardDetail[], honorBonus: number, musicMeta: MusicMeta, liveType: LiveType): number;
 }
 
+interface Area {
+    id: number;
+    assetbundleName: string;
+    areaType: string;
+    viewType: string;
+    name: string;
+    releaseConditionId: number;
+}
+
+declare class AreaItemRecommend {
+    private readonly dataProvider;
+    private readonly areaItemService;
+    private readonly deckCalculator;
+    constructor(dataProvider: DataProvider);
+    private static findCost;
+    private getRecommendAreaItem;
+    recommendAreaItem(userCards: UserCard[]): Promise<RecommendAreaItem[]>;
+}
+interface RecommendAreaItem {
+    area: Area;
+    areaItem: AreaItem;
+    areaItemLevel: AreaItemLevel;
+    shopItem: ShopItem;
+    cost: {
+        coin: number;
+        seed: number;
+        szk: number;
+    };
+    power: number;
+}
+
 declare class BaseDeckRecommend {
     private readonly dataProvider;
     private readonly cardCalculator;
     private readonly deckCalculator;
+    private readonly areaItemService;
     constructor(dataProvider: DataProvider);
     private static findBestCards;
     recommendHighScoreDeck(userCards: UserCard[], scoreFunc: ScoreFunction, { musicMeta, limit, member, cardConfig }: DeckRecommendConfig, eventId?: number, isChallengeLive?: boolean): Promise<RecommendDeck[]>;
@@ -635,4 +702,4 @@ interface UserHonor {
     level: number;
 }
 
-export { AreaItemLevel, 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, RecommendDeck, ScoreFunction, 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, 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 };

package/dist/index.mjs

@@ -75,6 +75,37 @@ class CachedDataProvider {
     async getUserDataAll() {
         return await this.getData(this.instanceCache, 'userData', async () => await this.dataProvider.getUserDataAll());
     }
+    async preloadMasterData(keys) {
+        return await Promise.all(keys.map(async (it) => await this.getMasterData(it)));
+    }
+}
+
+class AreaItemService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getAreaItemLevels() {
+        const userAreas = await this.dataProvider.getUserData('userAreas');
+        return await Promise.all(userAreas.flatMap(it => it.areaItems)
+            .map(async (it) => await this.getAreaItemLevel(it.areaItemId, it.level)));
+    }
+    async getAreaItemLevel(areaItemId, level) {
+        const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
+        return findOrThrow(areaItemLevels, it => it.areaItemId === areaItemId && it.level === level);
+    }
+    async getAreaItemNextLevel(areaItem, areaItemLevel) {
+        const level = areaItemLevel === undefined ? 1 : (areaItemLevel.level === 15 ? 15 : areaItemLevel.level + 1);
+        return await this.getAreaItemLevel(areaItem.id, level);
+    }
+    async getShopItem(areaItemLevel) {
+        const shopItems = await this.dataProvider.getMasterData('shopItems');
+        const idOffset = areaItemLevel.level <= 10
+            ? (1000 + (areaItemLevel.areaItemId - 1) * 10)
+            : (1550 - 10 + (areaItemLevel.areaItemId - 1) * 5);
+        const id = idOffset + areaItemLevel.level;
+        return findOrThrow(shopItems, it => it.id === id);
+    }
 }
 
 class DeckService {
@@ -187,8 +218,12 @@ class CardPowerCalculator {
         return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
     }
     async getCardBasePowers(userCard, card) {
-        const cardEpisodes = await this.dataProvider.getMasterData('cardEpisodes');
-        const masterLessons = await this.dataProvider.getMasterData('masterLessons');
+        const p = await Promise.all([
+            await this.dataProvider.getMasterData('cardEpisodes'),
+            await this.dataProvider.getMasterData('masterLessons')
+        ]);
+        const cardEpisodes = p[0];
+        const masterLessons = p[1];
         const ret = [0, 0, 0];
         const cardParameters = card.cardParameters.filter(it => it.cardLevel === userCard.level);
         const params = ['param1', 'param2', 'param3'];
@@ -328,11 +363,13 @@ class CardCalculator {
     powerCalculator;
     skillCalculator;
     eventCalculator;
+    areaItemService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
         this.skillCalculator = new CardSkillCalculator(dataProvider);
         this.eventCalculator = new CardEventCalculator(dataProvider);
+        this.areaItemService = new AreaItemService(dataProvider);
     }
     async getCardUnits(card) {
         const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
@@ -358,7 +395,9 @@ class CardCalculator {
             }
         }
         if (episodeRead && ret.episodes !== undefined) {
-            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+            ret.episodes.forEach(it => {
+                it.scenarioStatus = 'already_read';
+            });
         }
         if (masterMax) {
             ret.masterRank = 5;
@@ -391,11 +430,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, config = {}, eventId = 0) {
-        const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
-        const userAreas = await this.dataProvider.getUserData('userAreas');
-        const userItemLevels = userAreas.flatMap(it => it.areaItems).map(areaItem => findOrThrow(areaItemLevels, it => it.areaItemId === areaItem.areaItemId && it.level === areaItem.level));
-        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
+    async batchGetCardDetail(userCards, config = {}, eventId = 0, areaItemLevels) {
+        const areaItemLevels0 = areaItemLevels === undefined
+            ? await this.areaItemService.getAreaItemLevels()
+            : areaItemLevels;
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -440,21 +479,47 @@ class LiveCalculator {
                 return musicMeta.skill_score_auto;
         }
     }
+    static getSortedSkillDetails(deckDetail, liveType, skillDetails = undefined) {
+        if (skillDetails !== undefined && skillDetails.length === 6 && skillDetails[5].scoreUp > 0) {
+            return {
+                details: skillDetails,
+                sorted: false
+            };
+        }
+        if (liveType === LiveType.MULTI) {
+            return {
+                details: duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6),
+                sorted: false
+            };
+        }
+        const sortedSkill = [...deckDetail.cards].map(it => it.skill)
+            .sort((a, b) => a.scoreUp - b.scoreUp);
+        const emptySkill = duplicateObj({
+            scoreUp: 0,
+            lifeRecovery: 0
+        }, 5 - sortedSkill.length);
+        return {
+            details: [...sortedSkill, ...emptySkill, deckDetail.cards[0].skill],
+            sorted: true
+        };
+    }
+    static getSortedSkillRate(sorted, cardLength, skillScores) {
+        if (!sorted) {
+            return skillScores;
+        }
+        return [
+            ...skillScores.slice(0, cardLength).sort((a, b) => a - b),
+            ...skillScores.slice(cardLength)
+        ];
+    }
     static getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
-        const skills = skillDetails !== undefined
-            ? skillDetails
-            : (liveType === LiveType.MULTI
-                ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
-                : [...[...deckDetail.cards].map(it => it.skill)
-                        .sort((a, b) => a.scoreUp - b.scoreUp),
-                    deckDetail.cards[0].skill]);
+        const skills = this.getSortedSkillDetails(deckDetail, liveType, skillDetails);
         const baseRate = LiveCalculator.getBaseScore(musicMeta, liveType);
         const skillScores = [...LiveCalculator.getSkillScore(musicMeta, liveType)];
-        const skillRate = skillDetails === undefined
-            ? [...skillScores.slice(0, 5).sort((a, b) => a - b), skillScores[5]]
-            : skillScores;
-        const rate = baseRate + skills.reduce((v, it, i) => v + it.scoreUp * skillRate[i] / 100, 0);
-        const life = skills.reduce((v, it) => v + it.lifeRecovery, 0);
+        const skillRate = LiveCalculator.getSortedSkillRate(skills.sorted, deckDetail.cards.length, skillScores);
+        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 activeBonus = liveType === LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
         return {
@@ -610,8 +675,56 @@ class DeckCalculator {
             cards
         };
     }
-    async getDeckDetail(deckCards) {
-        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
+    async getDeckDetail(deckCards, eventId = 0, areaItemLevels) {
+        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards, {}, eventId, areaItemLevels), await this.getHonorBonusPower());
+    }
+}
+
+class AreaItemRecommend {
+    dataProvider;
+    areaItemService;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.areaItemService = new AreaItemService(dataProvider);
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    static findCost(shopItem, resourceType, resourceId) {
+        const cost = shopItem.costs.map(it => it.cost)
+            .find(it => it.resourceType === resourceType && it.resourceId === resourceId);
+        return cost === undefined ? 0 : cost.quantity;
+    }
+    async getRecommendAreaItem(areaItem, areaItemLevel, power) {
+        const areas = await this.dataProvider.getMasterData('areas');
+        const area = findOrThrow(areas, it => it.id === areaItem.areaId);
+        const shopItem = await this.areaItemService.getShopItem(areaItemLevel);
+        return {
+            area,
+            areaItem,
+            areaItemLevel,
+            shopItem,
+            cost: {
+                coin: AreaItemRecommend.findCost(shopItem, 'coin', 0),
+                seed: AreaItemRecommend.findCost(shopItem, 'material', 17),
+                szk: AreaItemRecommend.findCost(shopItem, 'material', 57)
+            },
+            power
+        };
+    }
+    async recommendAreaItem(userCards) {
+        const areaItems = await this.dataProvider.getMasterData('areaItems');
+        const currentAreaItemLevels = await this.areaItemService.getAreaItemLevels();
+        const { power: currentPower } = await this.deckCalculator.getDeckDetail(userCards, 0, currentAreaItemLevels);
+        const recommend = await Promise.all(areaItems.map(async (areaItem) => {
+            const newAreaItemLevel = await this.areaItemService.getAreaItemNextLevel(areaItem, currentAreaItemLevels.find(it => it.areaItemId === areaItem.id));
+            const newAreaItemLevels = [
+                ...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 recommend.filter(it => it.power > 0)
+            .sort((a, b) => b.power / b.cost.coin - a.power / a.cost.coin);
     }
 }
 
@@ -761,12 +874,17 @@ class BaseDeckRecommend {
     dataProvider;
     cardCalculator;
     deckCalculator;
+    areaItemService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.cardCalculator = new CardCalculator(dataProvider);
         this.deckCalculator = new DeckCalculator(dataProvider);
+        this.areaItemService = new AreaItemService(dataProvider);
     }
     static findBestCards(cardDetails, scoreFunc, limit = 1, isChallengeLive = false, member = 5, honorBonus = 0, deckCards = [], deckCharacters = []) {
+        if (isChallengeLive) {
+            member = Math.min(member, cardDetails.length);
+        }
         if (deckCards.length === member) {
             const score = scoreFunc(deckCards);
             const deckDetail = DeckCalculator.getDeckDetailByCards(deckCards, honorBonus);
@@ -821,7 +939,8 @@ class BaseDeckRecommend {
         return ans;
     }
     async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
+        const areaItemLevels = await this.areaItemService.getAreaItemLevels();
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId, areaItemLevels);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
         let priority = (isChallengeLive || eventId === 0) ? 10 : 0;
         while (priority < 10) {
@@ -907,4 +1026,4 @@ class MusicRecommend {
     }
 }
 
-export { BaseDeckRecommend, CachedDataProvider, CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DeckCalculator, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveType, MusicRecommend };
+export { AreaItemRecommend, AreaItemService, BaseDeckRecommend, CachedDataProvider, CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DeckCalculator, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveType, MusicRecommend };

package/package.json

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