sekai-calculator 0.4.3 → 0.5.0

package/dist/index.cjs

@@ -78,15 +78,15 @@ class DeckService {
             .map(async (id) => await this.getUserCard(id === null ? 0 : id)));
     }
     static toUserChallengeLiveSoloDeck(userCards, characterId) {
-        if (userCards.length !== 5)
-            throw new Error('deck card should be 5');
+        if (userCards.length < 2)
+            throw new Error('deck card should more than 1');
         return {
             characterId,
             leader: userCards[0].cardId,
             support1: userCards[1].cardId,
-            support2: userCards[2].cardId,
-            support3: userCards[3].cardId,
-            support4: userCards[4].cardId
+            support2: userCards.length < 3 ? null : userCards[2].cardId,
+            support3: userCards.length < 4 ? null : userCards[3].cardId,
+            support4: userCards.length < 5 ? null : userCards[4].cardId
         };
     }
 }
@@ -300,13 +300,40 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels, eventId = 0) {
+    async applyCardConfig(userCard, card, { rankMax = false, episodeRead = false, masterMax = false, skillMax = false }) {
+        if (!rankMax && !episodeRead && !masterMax && !skillMax)
+            return userCard;
+        const cardRarities = await this.dataProvider.getMasterData('cardRarities');
+        const cardRarity = findOrThrow(cardRarities, it => it.cardRarityType === card.cardRarityType);
+        const ret = JSON.parse(JSON.stringify(userCard));
+        if (rankMax) {
+            if (cardRarity.trainingMaxLevel !== undefined) {
+                ret.level = cardRarity.trainingMaxLevel;
+                ret.specialTrainingStatus = 'done';
+            }
+            else {
+                ret.level = cardRarity.maxLevel;
+            }
+        }
+        if (episodeRead) {
+            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+        }
+        if (masterMax) {
+            ret.masterRank = 5;
+        }
+        if (skillMax) {
+            ret.skillLevel = cardRarity.maxSkillLevel;
+        }
+        return ret;
+    }
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, eventId = 0) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const units = await this.getCardUnits(card);
-        const skill = await this.skillCalculator.getCardSkill(userCard, card);
-        const power = await this.powerCalculator.getCardPower(userCard, card, units, userAreaItemLevels);
-        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard, eventId);
+        const userCard0 = await this.applyCardConfig(userCard, card, config);
+        const skill = await this.skillCalculator.getCardSkill(userCard0, card);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
         return {
             cardId: card.id,
             characterId: card.characterId,
@@ -318,11 +345,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, eventId = 0) {
+    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, eventId)));
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -545,7 +572,7 @@ class BaseDeckRecommend {
     }
     static filterCard(cardDetails) {
         let afterFilter = cardDetails;
-        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+        for (const minBonus of [55, 50, 45, 40, 30, 25, 15, 5, 0]) {
             const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
             if (this.canMakeEventDeck(bonusFilter)) {
                 afterFilter = bonusFilter;
@@ -593,8 +620,8 @@ class BaseDeckRecommend {
             throw new Error(`Cannot find deck in ${cardDetails.length} cards`);
         return ans;
     }
-    async recommendHighScoreDeck(userCards, musicMeta, scoreFunc, limit = 1, eventId = 0, isChallengeLive = false, member = 5) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, eventId);
+    async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
         let cardDetails = (isChallengeLive || eventId === 0) ? cards : BaseDeckRecommend.filterCard(cards);
         cardDetails = cardDetails.sort((a, b) => a.cardId - b.cardId);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
@@ -615,12 +642,12 @@ class ChallengeLiveDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendChallengeLiveDeck(characterId, musicMeta, limit = 1, member = 5) {
+    async recommendChallengeLiveDeck(characterId, config) {
         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, musicMeta, BaseDeckRecommend.getLiveScoreFunction(exports.LiveType.SOLO), limit, 0, true, member);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, BaseDeckRecommend.getLiveScoreFunction(exports.LiveType.SOLO), config, 0, true);
         return recommend.map(it => {
             return {
                 score: it.score,
@@ -638,9 +665,9 @@ class EventDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendEventDeck(eventId, musicMeta, liveType, limit = 1) {
+    async recommendEventDeck(eventId, liveType, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicMeta, BaseDeckRecommend.getEventPointFunction(liveType), limit, eventId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, BaseDeckRecommend.getEventPointFunction(liveType), config, eventId);
         return recommend.map(it => {
             return {
                 point: it.score,

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 interface DataProvider {
     getMasterData: (key: string) => Promise<any>;
+    getUserDataAll: () => Promise<any>;
     getUserData: (key: string) => Promise<any>;
     getMusicMeta: () => Promise<any>;
 }
@@ -81,8 +82,9 @@ declare class CardCalculator {
     private readonly eventCalculator;
     constructor(dataProvider: DataProvider);
     private getCardUnits;
-    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], eventId?: number): Promise<CardDetail>;
-    batchGetCardDetail(userCards: UserCard[], eventId?: number): Promise<CardDetail[]>;
+    private applyCardConfig;
+    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], config?: CardConfig, eventId?: number): Promise<CardDetail>;
+    batchGetCardDetail(userCards: UserCard[], config?: CardConfig, eventId?: number): Promise<CardDetail[]>;
     static isCertainlyLessThan(cardDetail0: CardDetail, cardDetail1: CardDetail): boolean;
 }
 interface CardDetail {
@@ -95,6 +97,12 @@ interface CardDetail {
     lifeSkill: number;
     eventBonus?: number;
 }
+interface CardConfig {
+    rankMax?: boolean;
+    episodeRead?: boolean;
+    masterMax?: boolean;
+    skillMax?: boolean;
+}
 
 declare class DeckService {
     private readonly dataProvider;
@@ -250,11 +258,18 @@ declare class EventCalculator {
     static getDeckEventPoint(deckCards: CardDetail[], honorBonus: number, musicMeta: MusicMeta, liveType: LiveType): number;
 }
 
+interface DeckRecommendConfig {
+    musicMeta: MusicMeta;
+    limit?: number;
+    member?: number;
+    cardConfig?: CardConfig;
+}
+
 declare class ChallengeLiveDeckRecommend {
     private readonly dataProvider;
     private readonly baseRecommend;
     constructor(dataProvider: DataProvider);
-    recommendChallengeLiveDeck(characterId: number, musicMeta: MusicMeta, limit?: number, member?: number): Promise<Array<{
+    recommendChallengeLiveDeck(characterId: number, config: DeckRecommendConfig): Promise<Array<{
         score: number;
         power: number;
         deck: UserChallengeLiveSoloDeck;
@@ -265,7 +280,7 @@ declare class EventDeckRecommend {
     private readonly dataProvider;
     private readonly baseRecommend;
     constructor(dataProvider: DataProvider);
-    recommendEventDeck(eventId: number, musicMeta: MusicMeta, liveType: LiveType, limit?: number): Promise<Array<{
+    recommendEventDeck(eventId: number, liveType: LiveType, config: DeckRecommendConfig): Promise<Array<{
         point: number;
         power: number;
         eventBonus?: number;
@@ -303,6 +318,14 @@ interface CardEpisode {
     cardEpisodePartType: string;
 }
 
+interface CardRarity {
+    cardRarityType: string;
+    seq: number;
+    maxLevel: number;
+    trainingMaxLevel?: number;
+    maxSkillLevel: number;
+}
+
 interface CharacterRank {
     id: number;
     characterId: number;
@@ -345,9 +368,9 @@ interface GameCharacter {
     id: number;
     seq: number;
     resourceId: number;
-    firstName: string;
+    firstName?: string;
     givenName: string;
-    firstNameRuby: string;
+    firstNameRuby?: string;
     givenNameRuby: string;
     gender: string;
     height: number;
@@ -492,4 +515,4 @@ interface UserHonor {
     level: number;
 }
 
-export { AreaItemLevel, Card, CardCalculator, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, MusicMeta, MusicRecommend, Skill, SkillDetail, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };
+export { AreaItemLevel, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, MusicMeta, MusicRecommend, Skill, SkillDetail, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };

package/dist/index.mjs

@@ -76,15 +76,15 @@ class DeckService {
             .map(async (id) => await this.getUserCard(id === null ? 0 : id)));
     }
     static toUserChallengeLiveSoloDeck(userCards, characterId) {
-        if (userCards.length !== 5)
-            throw new Error('deck card should be 5');
+        if (userCards.length < 2)
+            throw new Error('deck card should more than 1');
         return {
             characterId,
             leader: userCards[0].cardId,
             support1: userCards[1].cardId,
-            support2: userCards[2].cardId,
-            support3: userCards[3].cardId,
-            support4: userCards[4].cardId
+            support2: userCards.length < 3 ? null : userCards[2].cardId,
+            support3: userCards.length < 4 ? null : userCards[3].cardId,
+            support4: userCards.length < 5 ? null : userCards[4].cardId
         };
     }
 }
@@ -298,13 +298,40 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels, eventId = 0) {
+    async applyCardConfig(userCard, card, { rankMax = false, episodeRead = false, masterMax = false, skillMax = false }) {
+        if (!rankMax && !episodeRead && !masterMax && !skillMax)
+            return userCard;
+        const cardRarities = await this.dataProvider.getMasterData('cardRarities');
+        const cardRarity = findOrThrow(cardRarities, it => it.cardRarityType === card.cardRarityType);
+        const ret = JSON.parse(JSON.stringify(userCard));
+        if (rankMax) {
+            if (cardRarity.trainingMaxLevel !== undefined) {
+                ret.level = cardRarity.trainingMaxLevel;
+                ret.specialTrainingStatus = 'done';
+            }
+            else {
+                ret.level = cardRarity.maxLevel;
+            }
+        }
+        if (episodeRead) {
+            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+        }
+        if (masterMax) {
+            ret.masterRank = 5;
+        }
+        if (skillMax) {
+            ret.skillLevel = cardRarity.maxSkillLevel;
+        }
+        return ret;
+    }
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, eventId = 0) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const units = await this.getCardUnits(card);
-        const skill = await this.skillCalculator.getCardSkill(userCard, card);
-        const power = await this.powerCalculator.getCardPower(userCard, card, units, userAreaItemLevels);
-        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard, eventId);
+        const userCard0 = await this.applyCardConfig(userCard, card, config);
+        const skill = await this.skillCalculator.getCardSkill(userCard0, card);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
         return {
             cardId: card.id,
             characterId: card.characterId,
@@ -316,11 +343,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, eventId = 0) {
+    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, eventId)));
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -543,7 +570,7 @@ class BaseDeckRecommend {
     }
     static filterCard(cardDetails) {
         let afterFilter = cardDetails;
-        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+        for (const minBonus of [55, 50, 45, 40, 30, 25, 15, 5, 0]) {
             const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
             if (this.canMakeEventDeck(bonusFilter)) {
                 afterFilter = bonusFilter;
@@ -591,8 +618,8 @@ class BaseDeckRecommend {
             throw new Error(`Cannot find deck in ${cardDetails.length} cards`);
         return ans;
     }
-    async recommendHighScoreDeck(userCards, musicMeta, scoreFunc, limit = 1, eventId = 0, isChallengeLive = false, member = 5) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, eventId);
+    async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
         let cardDetails = (isChallengeLive || eventId === 0) ? cards : BaseDeckRecommend.filterCard(cards);
         cardDetails = cardDetails.sort((a, b) => a.cardId - b.cardId);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
@@ -613,12 +640,12 @@ class ChallengeLiveDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendChallengeLiveDeck(characterId, musicMeta, limit = 1, member = 5) {
+    async recommendChallengeLiveDeck(characterId, config) {
         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, musicMeta, BaseDeckRecommend.getLiveScoreFunction(LiveType.SOLO), limit, 0, true, member);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, BaseDeckRecommend.getLiveScoreFunction(LiveType.SOLO), config, 0, true);
         return recommend.map(it => {
             return {
                 score: it.score,
@@ -636,9 +663,9 @@ class EventDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendEventDeck(eventId, musicMeta, liveType, limit = 1) {
+    async recommendEventDeck(eventId, liveType, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicMeta, BaseDeckRecommend.getEventPointFunction(liveType), limit, eventId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, BaseDeckRecommend.getEventPointFunction(liveType), config, eventId);
         return recommend.map(it => {
             return {
                 point: it.score,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekai-calculator",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",
@@ -30,22 +30,22 @@
   },
   "license": "LGPL-2.1-or-later",
   "devDependencies": {
-    "@rollup/plugin-typescript": "^11.0.0",
-    "@types/jest": "^29.4.1",
-    "@types/node": "^18.15.3",
-    "@typescript-eslint/eslint-plugin": "^5.55.0",
-    "eslint": "^8.36.0",
-    "eslint-config-standard-with-typescript": "^34.0.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "@typescript-eslint/eslint-plugin": "^5.57.1",
+    "eslint": "^8.37.0",
+    "eslint-config-standard-with-typescript": "^34.0.1",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.6.1",
+    "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-promise": "^6.1.1",
     "jest": "^29.5.0",
-    "rollup": "^3.19.1",
-    "rollup-plugin-dts": "^5.2.0",
-    "ts-jest": "^29.0.5",
+    "rollup": "^3.20.2",
+    "rollup-plugin-dts": "^5.3.0",
+    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.3"
   },
   "scripts": {
     "build": "rollup -c --configPlugin typescript",