sekai-calculator 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -27,10 +27,61 @@ function duplicateObj(obj, times) {
         ret.push(obj);
     return ret;
 }
-function mapOrUndefined(arr, fun) {
-    if (arr === undefined)
-        return undefined;
-    return arr.map(fun);
+
+class DeckService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getUserCard(cardId) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        return findOrThrow(userCards, it => it.cardId === cardId);
+    }
+    async getDeck(deckId) {
+        const userDecks = await this.dataProvider.getUserData('userDecks');
+        return findOrThrow(userDecks, it => it.deckId === deckId);
+    }
+    async getDeckCards(userDeck) {
+        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
+        return await Promise.all(cardIds.map(async (id) => await this.getUserCard(id)));
+    }
+    static toUserDeck(userCards, deckId = 1, name = 'ユニット01') {
+        if (userCards.length !== 5)
+            throw new Error('deck card should be 5');
+        return {
+            userId: userCards[0].userId,
+            deckId,
+            name,
+            leader: userCards[0].cardId,
+            subLeader: userCards[1].cardId,
+            member1: userCards[0].cardId,
+            member2: userCards[1].cardId,
+            member3: userCards[2].cardId,
+            member4: userCards[3].cardId,
+            member5: userCards[4].cardId
+        };
+    }
+    async getChallengeLiveSoloDeck(characterId) {
+        const userChallengeLiveSoloDecks = await this.dataProvider.getUserData('userChallengeLiveSoloDecks');
+        return findOrThrow(userChallengeLiveSoloDecks, it => it.characterId === characterId);
+    }
+    async getChallengeLiveSoloDeckCards(deck) {
+        const cardIds = [deck.leader, deck.support1, deck.support2, deck.support3, deck.support4];
+        return await Promise.all(cardIds.filter(it => it !== undefined && it !== null)
+            .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');
+        return {
+            characterId,
+            leader: userCards[0].cardId,
+            support1: userCards[1].cardId,
+            support2: userCards[2].cardId,
+            support3: userCards[3].cardId,
+            support4: userCards[4].cardId
+        };
+    }
 }
 
 class CardPowerCalculator {
@@ -222,18 +273,6 @@ class DeckCalculator {
         this.dataProvider = dataProvider;
         this.cardCalculator = new CardCalculator(dataProvider);
     }
-    async getDeck(deckId) {
-        const userDecks = await this.dataProvider.getUserData('userDecks');
-        return findOrThrow(userDecks, it => it.deckId === deckId);
-    }
-    async getDeckCards(userDeck) {
-        const userCards = await this.dataProvider.getUserData('userCards');
-        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
-        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
-    }
-    async getDeckCardsById(deckId) {
-        return await this.getDeckCards(await this.getDeck(deckId));
-    }
     async getHonorBonusPower() {
         const honors = await this.dataProvider.getMasterData('honors');
         const userHonors = await this.dataProvider.getUserData('userHonors');
@@ -268,9 +307,6 @@ class DeckCalculator {
         const cardDetails = await Promise.all(deckCards.map(async (it) => await this.cardCalculator.getCardDetail(it, userItemLevels)));
         return await this.getDeckDetailByCards(cardDetails, await this.getHonorBonusPower());
     }
-    async getDeckDetailById(deckId) {
-        return await this.getDeckDetail(await this.getDeckCardsById(deckId));
-    }
 }
 
 class CardEventCalculator {
@@ -314,21 +350,39 @@ class CardEventCalculator {
 
 class EventCalculator {
     dataProvider;
-    deckCalculator;
     cardEventCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
-        this.deckCalculator = new DeckCalculator(dataProvider);
         this.cardEventCalculator = new CardEventCalculator(dataProvider);
     }
-    async getDeckEventBonus(userDeck, eventId) {
-        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+    async getDeckEventBonus(deckCards, eventId) {
         return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
     }
-    async getDeckEventBonusById(deckId, eventId) {
-        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
+    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;
@@ -377,23 +431,40 @@ class LiveCalculator {
             tap: musicMeta.tap_count
         };
     }
-    getMultiLiveSkill(deckDetail) {
+    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;
-        return { scoreUp, lifeRecovery };
+        return {
+            scoreUp,
+            lifeRecovery
+        };
+    }
+    static getSoloLiveSkill(liveSkills, skillDetails) {
+        if (liveSkills === undefined)
+            return undefined;
+        const skills = liveSkills.map(liveSkill => findOrThrow(skillDetails, it => it.cardId === liveSkill.cardId));
+        const ret = [];
+        for (let i = 0; i < 6; ++i) {
+            ret.push({
+                scoreUp: 0,
+                lifeRecovery: 0
+            });
+        }
+        for (let i = 0; i < skills.length - 1; ++i) {
+            ret[i] = skills[i];
+        }
+        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);
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === exports.LiveType.MULTI
-            ? duplicateObj(this.getMultiLiveSkill(deckDetail), 6)
-            : (mapOrUndefined(liveSkills, liveSkill => findOrThrow(deckDetail.skill, it => it.cardId === liveSkill.cardId)));
+            ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
         return await this.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
-    async getLiveDetailById(deckId, musicId, musicDiff, liveType, liveSkills = undefined) {
-        return await this.getLiveDetail(await this.deckCalculator.getDeckCardsById(deckId), musicId, musicDiff, liveType, liveSkills);
-    }
 }
 exports.LiveType = void 0;
 (function (LiveType) {
@@ -404,6 +475,10 @@ exports.LiveType = void 0;
 
 exports.CardCalculator = CardCalculator;
 exports.CardDetailMap = CardDetailMap;
+exports.CardEventCalculator = CardEventCalculator;
+exports.CardPowerCalculator = CardPowerCalculator;
+exports.CardSkillCalculator = CardSkillCalculator;
 exports.DeckCalculator = DeckCalculator;
+exports.DeckService = DeckService;
 exports.EventCalculator = EventCalculator;
 exports.LiveCalculator = LiveCalculator;

package/dist/index.d.ts

@@ -5,7 +5,11 @@ interface DataProvider {
 }
 
 interface UserDeck {
+    userId: number;
     deckId: number;
+    name: string;
+    leader: number;
+    subLeader: number;
     member1: number;
     member2: number;
     member3: number;
@@ -13,27 +17,49 @@ interface UserDeck {
     member5: number;
 }
 
-declare class EventCalculator {
-    private readonly dataProvider;
-    private readonly deckCalculator;
-    private readonly cardEventCalculator;
-    constructor(dataProvider: DataProvider);
-    getDeckEventBonus(userDeck: UserDeck, eventId: number): Promise<number>;
-    getDeckEventBonusById(deckId: number, eventId: number): Promise<number>;
-}
-
 interface UserCard {
+    userId: number;
     cardId: number;
     level: number;
+    exp?: number;
+    totalExp: number;
     skillLevel: number;
+    skillExp: number;
+    totalSkillExp: number;
     masterRank: number;
-    specialTrainingStatus?: string;
+    specialTrainingStatus: string;
+    defaultImage: string;
+    duplicateCount: number;
+    createdAt: number;
     episodes: Array<{
         cardEpisodeId: number;
         scenarioStatus: string;
+        scenarioStatusReasons: string[];
+        isNotSkipped: boolean;
     }>;
 }
 
+interface UserChallengeLiveSoloDeck {
+    characterId: number;
+    leader: number;
+    support1: number;
+    support2: number | null;
+    support3: number | null;
+    support4: number | null;
+}
+
+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: UserCard[], deckId?: number, name?: string): UserDeck;
+    getChallengeLiveSoloDeck(characterId: number): Promise<UserChallengeLiveSoloDeck>;
+    getChallengeLiveSoloDeckCards(deck: UserChallengeLiveSoloDeck): Promise<UserCard[]>;
+    static toUserChallengeLiveSoloDeck(userCards: UserCard[], characterId: number): UserChallengeLiveSoloDeck;
+}
+
 interface AreaItemLevel {
     areaItemId: number;
     level: number;
@@ -77,17 +103,73 @@ declare class CardDetailMap {
     isCertainlyLessThen(another: CardDetailMap): boolean;
 }
 
+interface CommonResource {
+    resourceId?: number;
+    resourceType: string;
+    resourceLevel?: number;
+    quantity: number;
+}
+
+interface Card {
+    id: number;
+    seq: number;
+    characterId: number;
+    cardRarityType: string;
+    specialTrainingPower1BonusFixed: number;
+    specialTrainingPower2BonusFixed: number;
+    specialTrainingPower3BonusFixed: number;
+    attr: string;
+    supportUnit: string;
+    skillId: number;
+    cardSkillName: string;
+    prefix: string;
+    assetbundleName: string;
+    gachaPhrase: string;
+    flavorText: string;
+    releaseAt: number;
+    cardParameters: Array<{
+        id: number;
+        cardId: number;
+        cardLevel: number;
+        cardParameterType: string;
+        power: number;
+    }>;
+    specialTrainingCosts: CommonResource[];
+    masterLessonAchieveResources: {
+        releaseConditionId: number;
+        cardId: number;
+        masterRank: number;
+        resources: CommonResource[];
+    };
+}
+
+declare class CardPowerCalculator {
+    private readonly dataProvider;
+    constructor(dataProvider: DataProvider);
+    getCardPower(userCard: UserCard, card: Card, cardUnits: string[], userAreaItemLevels: AreaItemLevel[]): Promise<CardDetailMap>;
+    private getPower;
+    private getCardBasePowers;
+    private getAreaItemBonusPower;
+    private getCharacterBonusPower;
+}
+
+declare class CardSkillCalculator {
+    private readonly dataProvider;
+    constructor(dataProvider: DataProvider);
+    getCardSkill(userCard: UserCard, card: Card): Promise<{
+        scoreUp: CardDetailMap;
+        lifeRecovery: number;
+    }>;
+    private getSkillDetail;
+}
+
 declare class DeckCalculator {
     private readonly dataProvider;
     private readonly cardCalculator;
     constructor(dataProvider: DataProvider);
-    getDeck(deckId: number): Promise<UserDeck>;
-    getDeckCards(userDeck: UserDeck): Promise<UserCard[]>;
-    getDeckCardsById(deckId: number): Promise<UserCard[]>;
     private getHonorBonusPower;
     getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): Promise<DeckDetail>;
     getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
-    getDeckDetailById(deckId: number): Promise<DeckDetail>;
 }
 interface DeckDetail {
     power: number;
@@ -99,6 +181,27 @@ interface SkillDetail {
     lifeRecovery: number;
 }
 
+declare class CardEventCalculator {
+    private readonly dataProvider;
+    constructor(dataProvider: DataProvider);
+    private getEventDeckBonus;
+    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;
@@ -121,9 +224,9 @@ declare class LiveCalculator {
     private getBaseScore;
     private getSkillScore;
     getLiveDetailByDeck(deckDetail: DeckDetail, musicMeta: MusicMeta, liveType: LiveType, skillDetails?: SkillDetail[] | undefined, multiPowerSum?: number): Promise<LiveDetail>;
-    private getMultiLiveSkill;
+    private static getMultiLiveSkill;
+    private static getSoloLiveSkill;
     getLiveDetail(deckCards: UserCard[], musicId: number, musicDiff: string, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
-    getLiveDetailById(deckId: number, musicId: number, musicDiff: string, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
 }
 interface LiveDetail {
     score: number;
@@ -141,4 +244,4 @@ declare enum LiveType {
     AUTO = "auto"
 }
 
-export { CardCalculator, CardDetail, CardDetailMap, DataProvider, DeckCalculator, DeckDetail, EventCalculator, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };
+export { CardCalculator, CardDetail, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };

package/dist/index.mjs

@@ -25,10 +25,61 @@ function duplicateObj(obj, times) {
         ret.push(obj);
     return ret;
 }
-function mapOrUndefined(arr, fun) {
-    if (arr === undefined)
-        return undefined;
-    return arr.map(fun);
+
+class DeckService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getUserCard(cardId) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        return findOrThrow(userCards, it => it.cardId === cardId);
+    }
+    async getDeck(deckId) {
+        const userDecks = await this.dataProvider.getUserData('userDecks');
+        return findOrThrow(userDecks, it => it.deckId === deckId);
+    }
+    async getDeckCards(userDeck) {
+        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
+        return await Promise.all(cardIds.map(async (id) => await this.getUserCard(id)));
+    }
+    static toUserDeck(userCards, deckId = 1, name = 'ユニット01') {
+        if (userCards.length !== 5)
+            throw new Error('deck card should be 5');
+        return {
+            userId: userCards[0].userId,
+            deckId,
+            name,
+            leader: userCards[0].cardId,
+            subLeader: userCards[1].cardId,
+            member1: userCards[0].cardId,
+            member2: userCards[1].cardId,
+            member3: userCards[2].cardId,
+            member4: userCards[3].cardId,
+            member5: userCards[4].cardId
+        };
+    }
+    async getChallengeLiveSoloDeck(characterId) {
+        const userChallengeLiveSoloDecks = await this.dataProvider.getUserData('userChallengeLiveSoloDecks');
+        return findOrThrow(userChallengeLiveSoloDecks, it => it.characterId === characterId);
+    }
+    async getChallengeLiveSoloDeckCards(deck) {
+        const cardIds = [deck.leader, deck.support1, deck.support2, deck.support3, deck.support4];
+        return await Promise.all(cardIds.filter(it => it !== undefined && it !== null)
+            .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');
+        return {
+            characterId,
+            leader: userCards[0].cardId,
+            support1: userCards[1].cardId,
+            support2: userCards[2].cardId,
+            support3: userCards[3].cardId,
+            support4: userCards[4].cardId
+        };
+    }
 }
 
 class CardPowerCalculator {
@@ -220,18 +271,6 @@ class DeckCalculator {
         this.dataProvider = dataProvider;
         this.cardCalculator = new CardCalculator(dataProvider);
     }
-    async getDeck(deckId) {
-        const userDecks = await this.dataProvider.getUserData('userDecks');
-        return findOrThrow(userDecks, it => it.deckId === deckId);
-    }
-    async getDeckCards(userDeck) {
-        const userCards = await this.dataProvider.getUserData('userCards');
-        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
-        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
-    }
-    async getDeckCardsById(deckId) {
-        return await this.getDeckCards(await this.getDeck(deckId));
-    }
     async getHonorBonusPower() {
         const honors = await this.dataProvider.getMasterData('honors');
         const userHonors = await this.dataProvider.getUserData('userHonors');
@@ -266,9 +305,6 @@ class DeckCalculator {
         const cardDetails = await Promise.all(deckCards.map(async (it) => await this.cardCalculator.getCardDetail(it, userItemLevels)));
         return await this.getDeckDetailByCards(cardDetails, await this.getHonorBonusPower());
     }
-    async getDeckDetailById(deckId) {
-        return await this.getDeckDetail(await this.getDeckCardsById(deckId));
-    }
 }
 
 class CardEventCalculator {
@@ -312,21 +348,39 @@ class CardEventCalculator {
 
 class EventCalculator {
     dataProvider;
-    deckCalculator;
     cardEventCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
-        this.deckCalculator = new DeckCalculator(dataProvider);
         this.cardEventCalculator = new CardEventCalculator(dataProvider);
     }
-    async getDeckEventBonus(userDeck, eventId) {
-        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+    async getDeckEventBonus(deckCards, eventId) {
         return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
     }
-    async getDeckEventBonusById(deckId, eventId) {
-        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
+    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;
@@ -375,23 +429,40 @@ class LiveCalculator {
             tap: musicMeta.tap_count
         };
     }
-    getMultiLiveSkill(deckDetail) {
+    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;
-        return { scoreUp, lifeRecovery };
+        return {
+            scoreUp,
+            lifeRecovery
+        };
+    }
+    static getSoloLiveSkill(liveSkills, skillDetails) {
+        if (liveSkills === undefined)
+            return undefined;
+        const skills = liveSkills.map(liveSkill => findOrThrow(skillDetails, it => it.cardId === liveSkill.cardId));
+        const ret = [];
+        for (let i = 0; i < 6; ++i) {
+            ret.push({
+                scoreUp: 0,
+                lifeRecovery: 0
+            });
+        }
+        for (let i = 0; i < skills.length - 1; ++i) {
+            ret[i] = skills[i];
+        }
+        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);
         const deckDetail = await this.deckCalculator.getDeckDetail(deckCards);
         const skills = liveType === LiveType.MULTI
-            ? duplicateObj(this.getMultiLiveSkill(deckDetail), 6)
-            : (mapOrUndefined(liveSkills, liveSkill => findOrThrow(deckDetail.skill, it => it.cardId === liveSkill.cardId)));
+            ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
         return await this.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
-    async getLiveDetailById(deckId, musicId, musicDiff, liveType, liveSkills = undefined) {
-        return await this.getLiveDetail(await this.deckCalculator.getDeckCardsById(deckId), musicId, musicDiff, liveType, liveSkills);
-    }
 }
 var LiveType;
 (function (LiveType) {
@@ -400,4 +471,4 @@ var LiveType;
     LiveType["AUTO"] = "auto";
 })(LiveType || (LiveType = {}));
 
-export { CardCalculator, CardDetailMap, DeckCalculator, EventCalculator, LiveCalculator, LiveType };
+export { CardCalculator, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DeckCalculator, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveType };

package/package.json

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