sekai-calculator 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -27,35 +27,93 @@ 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 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));
+        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 userCards = await this.dataProvider.getUserData('userCards');
         const cardIds = [deck.leader, deck.support1, deck.support2, deck.support3, deck.support4];
-        return cardIds.filter(it => it !== undefined && it !== null)
-            .map(id => findOrThrow(userCards, it => it.cardId === id));
+        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 CardDetailMap {
+    min = Number.MAX_SAFE_INTEGER;
+    max = Number.MIN_SAFE_INTEGER;
+    values = new Map();
+    set(unit, unitMember, attrMember, value) {
+        this.min = Math.min(this.min, value);
+        this.max = Math.max(this.max, value);
+        this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
+    }
+    get(unit, unitMember, attrMember) {
+        const attrMember0 = attrMember === 5 ? 5 : 1;
+        let best = this.getInternal(unit, unitMember, attrMember0);
+        if (best !== undefined)
+            return best;
+        best = this.getInternal(unit, unitMember === 5 ? 5 : 1, attrMember0);
+        if (best !== undefined)
+            return best;
+        best = this.getInternal('any', 1, 1);
+        if (best !== undefined)
+            return best;
+        throw new Error('case not found');
+    }
+    getInternal(unit, unitMember, attrMember) {
+        return this.values.get(CardDetailMap.getKey(unit, unitMember, attrMember));
+    }
+    static getKey(unit, unitMember, attrMember) {
+        return `${unit}-${unitMember}-${attrMember}`;
+    }
+    isCertainlyLessThen(another) {
+        return this.max < another.min;
     }
 }
 
@@ -175,14 +233,55 @@ class CardSkillCalculator {
     }
 }
 
+class CardEventCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getEventDeckBonus(eventId, card) {
+        const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
+        const gameCharacterUnits = await this.dataProvider.getMasterData('gameCharacterUnits');
+        return eventDeckBonuses.filter(it => it.eventId === eventId &&
+            (it.cardAttr === undefined || it.cardAttr === card.attr))
+            .reduce((v, eventDeckBonus) => {
+            if (eventDeckBonus.gameCharacterUnitId === undefined)
+                return Math.max(v, eventDeckBonus.bonusRate);
+            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
+            if (gameCharacterUnit.gameCharacterId !== card.characterId)
+                return v;
+            if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
+                return Math.max(v, eventDeckBonus.bonusRate);
+            }
+            return Math.max(v, card.supportUnit === 'none' ? eventDeckBonus.bonusRate - 10 : 0);
+        }, 0);
+    }
+    async getCardEventBonus(userCard, eventId) {
+        const cards = await this.dataProvider.getMasterData('cards');
+        const eventCards = await this.dataProvider.getMasterData('eventCards');
+        const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
+        let eventBonus = 0;
+        const card = findOrThrow(cards, it => it.id === userCard.cardId);
+        eventBonus += await this.getEventDeckBonus(eventId, card);
+        const cardBonus = eventCards.find((it) => it.eventId === eventId && it.cardId === card.id);
+        if (cardBonus != null) {
+            eventBonus += cardBonus.bonusRate;
+        }
+        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
+        eventBonus += masterRankBonus.bonusRate;
+        return eventBonus;
+    }
+}
+
 class CardCalculator {
     dataProvider;
     powerCalculator;
     skillCalculator;
+    eventCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
         this.skillCalculator = new CardSkillCalculator(dataProvider);
+        this.eventCalculator = new CardEventCalculator(dataProvider);
     }
     async getCardUnits(card) {
         const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
@@ -192,52 +291,35 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels) {
+    async getCardDetail(userCard, userAreaItemLevels, 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);
         return {
             cardId: card.id,
+            characterId: card.characterId,
             units,
             attr: card.attr,
             power,
             scoreSkill: skill.scoreUp,
-            lifeSkill: skill.lifeRecovery
+            lifeSkill: skill.lifeRecovery,
+            eventBonus
         };
     }
-}
-class CardDetailMap {
-    min = Number.MAX_SAFE_INTEGER;
-    max = Number.MIN_SAFE_INTEGER;
-    values = new Map();
-    set(unit, unitMember, attrMember, value) {
-        this.min = Math.min(this.min, value);
-        this.max = Math.max(this.max, value);
-        this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
-    }
-    get(unit, unitMember, attrMember) {
-        const attrMember0 = attrMember === 5 ? 5 : 1;
-        let best = this.getInternal(unit, unitMember, attrMember0);
-        if (best !== undefined)
-            return best;
-        best = this.getInternal(unit, unitMember === 5 ? 5 : 1, attrMember0);
-        if (best !== undefined)
-            return best;
-        best = this.getInternal('any', 1, 1);
-        if (best !== undefined)
-            return best;
-        throw new Error('case not found');
-    }
-    getInternal(unit, unitMember, attrMember) {
-        return this.values.get(CardDetailMap.getKey(unit, unitMember, attrMember));
+    async batchGetCardDetail(userCards, 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)));
     }
-    static getKey(unit, unitMember, attrMember) {
-        return `${unit}-${unitMember}-${attrMember}`;
-    }
-    isCertainlyLessThen(another) {
-        return this.max < another.min;
+    static isCertainlyLessThan(cardDetail0, cardDetail1) {
+        return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
+            cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
+            (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
+                cardDetail0.eventBonus < cardDetail1.eventBonus);
     }
 }
 
@@ -258,7 +340,7 @@ class DeckCalculator {
         })
             .reduce((v, it) => v + it.bonus, 0);
     }
-    async getDeckDetailByCards(cardDetails, honorBonus) {
+    static getDeckDetailByCards(cardDetails, honorBonus) {
         const map = new Map();
         for (const cardDetail of cardDetails) {
             computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
@@ -276,50 +358,7 @@ class DeckCalculator {
         return { power, skill };
     }
     async getDeckDetail(deckCards) {
-        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));
-        const cardDetails = await Promise.all(deckCards.map(async (it) => await this.cardCalculator.getCardDetail(it, userItemLevels)));
-        return await this.getDeckDetailByCards(cardDetails, await this.getHonorBonusPower());
-    }
-}
-
-class CardEventCalculator {
-    dataProvider;
-    constructor(dataProvider) {
-        this.dataProvider = dataProvider;
-    }
-    async getEventDeckBonus(eventId, card) {
-        const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
-        const gameCharacterUnits = await this.dataProvider.getMasterData('gameCharacterUnits');
-        return eventDeckBonuses.filter(it => it.eventId === eventId &&
-            (it.cardAttr === undefined || it.cardAttr === card.attr))
-            .reduce((v, eventDeckBonus) => {
-            if (eventDeckBonus.gameCharacterUnitId === undefined)
-                return Math.max(v, eventDeckBonus.bonusRate);
-            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
-            if (gameCharacterUnit.gameCharacterId !== card.characterId)
-                return v;
-            if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
-                return Math.max(v, eventDeckBonus.bonusRate);
-            }
-            return Math.max(v, card.supportUnit === 'none' ? eventDeckBonus.bonusRate - 10 : 0);
-        }, 0);
-    }
-    async getCardEventBonus(userCard, eventId) {
-        const cards = await this.dataProvider.getMasterData('cards');
-        const eventCards = await this.dataProvider.getMasterData('eventCards');
-        const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
-        let eventBonus = 0;
-        const card = findOrThrow(cards, it => it.id === userCard.cardId);
-        eventBonus += await this.getEventDeckBonus(eventId, card);
-        const cardBonus = eventCards.find((it) => it.eventId === eventId && it.cardId === card.id);
-        if (cardBonus != null) {
-            eventBonus += cardBonus.bonusRate;
-        }
-        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
-        eventBonus += masterRankBonus.bonusRate;
-        return eventBonus;
+        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
     }
 }
 
@@ -333,7 +372,31 @@ class EventCalculator {
     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;
@@ -342,7 +405,7 @@ class LiveCalculator {
         this.dataProvider = dataProvider;
         this.deckCalculator = new DeckCalculator(dataProvider);
     }
-    getBaseScore(musicMeta, liveType) {
+    static getBaseScore(musicMeta, liveType) {
         switch (liveType) {
             case exports.LiveType.SOLO:
                 return musicMeta.base_score;
@@ -352,7 +415,7 @@ class LiveCalculator {
                 return musicMeta.base_score_auto;
         }
     }
-    getSkillScore(musicMeta, liveType) {
+    static getSkillScore(musicMeta, liveType) {
         switch (liveType) {
             case exports.LiveType.SOLO:
                 return musicMeta.skill_score_solo;
@@ -362,15 +425,18 @@ class LiveCalculator {
                 return musicMeta.skill_score_auto;
         }
     }
-    async getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
-        const bestSkill = skillDetails === undefined;
-        const skills = bestSkill
-            ? [...deckDetail.skill, deckDetail.skill[0]].sort((a, b) => a.scoreUp - b.scoreUp)
-            : skillDetails;
-        const baseRate = this.getBaseScore(musicMeta, liveType);
-        const skillRate = bestSkill
-            ? [...this.getSkillScore(musicMeta, liveType)].sort((a, b) => a - b)
-            : this.getSkillScore(musicMeta, liveType);
+    static getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
+        const skills = skillDetails !== undefined
+            ? skillDetails
+            : (liveType === exports.LiveType.MULTI
+                ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
+                : [...[...deckDetail.skill].sort((a, b) => a.scoreUp - b.scoreUp),
+                    deckDetail.skill[0]]);
+        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 powerSum = multiPowerSum === 0 ? 5 * deckDetail.power : multiPowerSum;
@@ -382,19 +448,39 @@ 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)));
-        return await this.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
+            ? undefined
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
+        return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
 }
 exports.LiveType = void 0;
@@ -405,7 +491,6 @@ exports.LiveType = void 0;
 })(exports.LiveType || (exports.LiveType = {}));
 
 exports.CardCalculator = CardCalculator;
-exports.CardDetailMap = CardDetailMap;
 exports.CardEventCalculator = CardEventCalculator;
 exports.CardPowerCalculator = CardPowerCalculator;
 exports.CardSkillCalculator = CardSkillCalculator;

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;
@@ -14,14 +18,24 @@ interface UserDeck {
 }
 
 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;
     }>;
 }
 
@@ -37,10 +51,13 @@ interface UserChallengeLiveSoloDeck {
 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 {
@@ -58,16 +75,31 @@ interface AreaItemLevel {
     sentence: string;
 }
 
+declare class CardDetailMap {
+    min: number;
+    max: number;
+    values: Map<string, number>;
+    set(unit: string, unitMember: number, attrMember: number, value: number): void;
+    get(unit: string, unitMember: number, attrMember: number): number;
+    private getInternal;
+    static getKey(unit: string, unitMember: number, attrMember: number): string;
+    isCertainlyLessThen(another: CardDetailMap): boolean;
+}
+
 declare class CardCalculator {
     private readonly dataProvider;
     private readonly powerCalculator;
     private readonly skillCalculator;
+    private readonly eventCalculator;
     constructor(dataProvider: DataProvider);
     private getCardUnits;
-    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[]): Promise<CardDetail>;
+    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], eventId?: number): Promise<CardDetail>;
+    batchGetCardDetail(userCards: UserCard[], eventId?: number): Promise<CardDetail[]>;
+    static isCertainlyLessThan(cardDetail0: CardDetail, cardDetail1: CardDetail): boolean;
 }
 interface CardDetail {
     cardId: number;
+    characterId: number;
     units: string[];
     attr: string;
     power: CardDetailMap;
@@ -75,16 +107,6 @@ interface CardDetail {
     lifeSkill: number;
     eventBonus?: number;
 }
-declare class CardDetailMap {
-    min: number;
-    max: number;
-    values: Map<string, number>;
-    set(unit: string, unitMember: number, attrMember: number, value: number): void;
-    get(unit: string, unitMember: number, attrMember: number): number;
-    private getInternal;
-    static getKey(unit: string, unitMember: number, attrMember: number): string;
-    isCertainlyLessThen(another: CardDetailMap): boolean;
-}
 
 interface CommonResource {
     resourceId?: number;
@@ -150,8 +172,8 @@ declare class DeckCalculator {
     private readonly dataProvider;
     private readonly cardCalculator;
     constructor(dataProvider: DataProvider);
-    private getHonorBonusPower;
-    getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): Promise<DeckDetail>;
+    getHonorBonusPower(): Promise<number>;
+    static getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): DeckDetail;
     getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
 }
 interface DeckDetail {
@@ -176,6 +198,13 @@ declare class EventCalculator {
     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 {
@@ -197,10 +226,11 @@ declare class LiveCalculator {
     private readonly dataProvider;
     private readonly deckCalculator;
     constructor(dataProvider: DataProvider);
-    private getBaseScore;
-    private getSkillScore;
-    getLiveDetailByDeck(deckDetail: DeckDetail, musicMeta: MusicMeta, liveType: LiveType, skillDetails?: SkillDetail[] | undefined, multiPowerSum?: number): Promise<LiveDetail>;
-    private getMultiLiveSkill;
+    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>;
 }
 interface LiveDetail {
@@ -219,4 +249,4 @@ declare enum LiveType {
     AUTO = "auto"
 }
 
-export { CardCalculator, CardDetail, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };
+export { CardCalculator, CardDetail, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };

package/dist/index.mjs

@@ -25,35 +25,93 @@ 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 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));
+        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 userCards = await this.dataProvider.getUserData('userCards');
         const cardIds = [deck.leader, deck.support1, deck.support2, deck.support3, deck.support4];
-        return cardIds.filter(it => it !== undefined && it !== null)
-            .map(id => findOrThrow(userCards, it => it.cardId === id));
+        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 CardDetailMap {
+    min = Number.MAX_SAFE_INTEGER;
+    max = Number.MIN_SAFE_INTEGER;
+    values = new Map();
+    set(unit, unitMember, attrMember, value) {
+        this.min = Math.min(this.min, value);
+        this.max = Math.max(this.max, value);
+        this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
+    }
+    get(unit, unitMember, attrMember) {
+        const attrMember0 = attrMember === 5 ? 5 : 1;
+        let best = this.getInternal(unit, unitMember, attrMember0);
+        if (best !== undefined)
+            return best;
+        best = this.getInternal(unit, unitMember === 5 ? 5 : 1, attrMember0);
+        if (best !== undefined)
+            return best;
+        best = this.getInternal('any', 1, 1);
+        if (best !== undefined)
+            return best;
+        throw new Error('case not found');
+    }
+    getInternal(unit, unitMember, attrMember) {
+        return this.values.get(CardDetailMap.getKey(unit, unitMember, attrMember));
+    }
+    static getKey(unit, unitMember, attrMember) {
+        return `${unit}-${unitMember}-${attrMember}`;
+    }
+    isCertainlyLessThen(another) {
+        return this.max < another.min;
     }
 }
 
@@ -173,14 +231,55 @@ class CardSkillCalculator {
     }
 }
 
+class CardEventCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getEventDeckBonus(eventId, card) {
+        const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
+        const gameCharacterUnits = await this.dataProvider.getMasterData('gameCharacterUnits');
+        return eventDeckBonuses.filter(it => it.eventId === eventId &&
+            (it.cardAttr === undefined || it.cardAttr === card.attr))
+            .reduce((v, eventDeckBonus) => {
+            if (eventDeckBonus.gameCharacterUnitId === undefined)
+                return Math.max(v, eventDeckBonus.bonusRate);
+            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
+            if (gameCharacterUnit.gameCharacterId !== card.characterId)
+                return v;
+            if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
+                return Math.max(v, eventDeckBonus.bonusRate);
+            }
+            return Math.max(v, card.supportUnit === 'none' ? eventDeckBonus.bonusRate - 10 : 0);
+        }, 0);
+    }
+    async getCardEventBonus(userCard, eventId) {
+        const cards = await this.dataProvider.getMasterData('cards');
+        const eventCards = await this.dataProvider.getMasterData('eventCards');
+        const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
+        let eventBonus = 0;
+        const card = findOrThrow(cards, it => it.id === userCard.cardId);
+        eventBonus += await this.getEventDeckBonus(eventId, card);
+        const cardBonus = eventCards.find((it) => it.eventId === eventId && it.cardId === card.id);
+        if (cardBonus != null) {
+            eventBonus += cardBonus.bonusRate;
+        }
+        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
+        eventBonus += masterRankBonus.bonusRate;
+        return eventBonus;
+    }
+}
+
 class CardCalculator {
     dataProvider;
     powerCalculator;
     skillCalculator;
+    eventCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
         this.skillCalculator = new CardSkillCalculator(dataProvider);
+        this.eventCalculator = new CardEventCalculator(dataProvider);
     }
     async getCardUnits(card) {
         const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
@@ -190,52 +289,35 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels) {
+    async getCardDetail(userCard, userAreaItemLevels, 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);
         return {
             cardId: card.id,
+            characterId: card.characterId,
             units,
             attr: card.attr,
             power,
             scoreSkill: skill.scoreUp,
-            lifeSkill: skill.lifeRecovery
+            lifeSkill: skill.lifeRecovery,
+            eventBonus
         };
     }
-}
-class CardDetailMap {
-    min = Number.MAX_SAFE_INTEGER;
-    max = Number.MIN_SAFE_INTEGER;
-    values = new Map();
-    set(unit, unitMember, attrMember, value) {
-        this.min = Math.min(this.min, value);
-        this.max = Math.max(this.max, value);
-        this.values.set(CardDetailMap.getKey(unit, unitMember, attrMember), value);
-    }
-    get(unit, unitMember, attrMember) {
-        const attrMember0 = attrMember === 5 ? 5 : 1;
-        let best = this.getInternal(unit, unitMember, attrMember0);
-        if (best !== undefined)
-            return best;
-        best = this.getInternal(unit, unitMember === 5 ? 5 : 1, attrMember0);
-        if (best !== undefined)
-            return best;
-        best = this.getInternal('any', 1, 1);
-        if (best !== undefined)
-            return best;
-        throw new Error('case not found');
-    }
-    getInternal(unit, unitMember, attrMember) {
-        return this.values.get(CardDetailMap.getKey(unit, unitMember, attrMember));
+    async batchGetCardDetail(userCards, 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)));
     }
-    static getKey(unit, unitMember, attrMember) {
-        return `${unit}-${unitMember}-${attrMember}`;
-    }
-    isCertainlyLessThen(another) {
-        return this.max < another.min;
+    static isCertainlyLessThan(cardDetail0, cardDetail1) {
+        return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
+            cardDetail0.scoreSkill.isCertainlyLessThen(cardDetail1.scoreSkill) &&
+            (cardDetail0.eventBonus === undefined || cardDetail1.eventBonus === undefined ||
+                cardDetail0.eventBonus < cardDetail1.eventBonus);
     }
 }
 
@@ -256,7 +338,7 @@ class DeckCalculator {
         })
             .reduce((v, it) => v + it.bonus, 0);
     }
-    async getDeckDetailByCards(cardDetails, honorBonus) {
+    static getDeckDetailByCards(cardDetails, honorBonus) {
         const map = new Map();
         for (const cardDetail of cardDetails) {
             computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
@@ -274,50 +356,7 @@ class DeckCalculator {
         return { power, skill };
     }
     async getDeckDetail(deckCards) {
-        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));
-        const cardDetails = await Promise.all(deckCards.map(async (it) => await this.cardCalculator.getCardDetail(it, userItemLevels)));
-        return await this.getDeckDetailByCards(cardDetails, await this.getHonorBonusPower());
-    }
-}
-
-class CardEventCalculator {
-    dataProvider;
-    constructor(dataProvider) {
-        this.dataProvider = dataProvider;
-    }
-    async getEventDeckBonus(eventId, card) {
-        const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
-        const gameCharacterUnits = await this.dataProvider.getMasterData('gameCharacterUnits');
-        return eventDeckBonuses.filter(it => it.eventId === eventId &&
-            (it.cardAttr === undefined || it.cardAttr === card.attr))
-            .reduce((v, eventDeckBonus) => {
-            if (eventDeckBonus.gameCharacterUnitId === undefined)
-                return Math.max(v, eventDeckBonus.bonusRate);
-            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
-            if (gameCharacterUnit.gameCharacterId !== card.characterId)
-                return v;
-            if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
-                return Math.max(v, eventDeckBonus.bonusRate);
-            }
-            return Math.max(v, card.supportUnit === 'none' ? eventDeckBonus.bonusRate - 10 : 0);
-        }, 0);
-    }
-    async getCardEventBonus(userCard, eventId) {
-        const cards = await this.dataProvider.getMasterData('cards');
-        const eventCards = await this.dataProvider.getMasterData('eventCards');
-        const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
-        let eventBonus = 0;
-        const card = findOrThrow(cards, it => it.id === userCard.cardId);
-        eventBonus += await this.getEventDeckBonus(eventId, card);
-        const cardBonus = eventCards.find((it) => it.eventId === eventId && it.cardId === card.id);
-        if (cardBonus != null) {
-            eventBonus += cardBonus.bonusRate;
-        }
-        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
-        eventBonus += masterRankBonus.bonusRate;
-        return eventBonus;
+        return DeckCalculator.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards), await this.getHonorBonusPower());
     }
 }
 
@@ -331,7 +370,31 @@ class EventCalculator {
     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;
@@ -340,7 +403,7 @@ class LiveCalculator {
         this.dataProvider = dataProvider;
         this.deckCalculator = new DeckCalculator(dataProvider);
     }
-    getBaseScore(musicMeta, liveType) {
+    static getBaseScore(musicMeta, liveType) {
         switch (liveType) {
             case LiveType.SOLO:
                 return musicMeta.base_score;
@@ -350,7 +413,7 @@ class LiveCalculator {
                 return musicMeta.base_score_auto;
         }
     }
-    getSkillScore(musicMeta, liveType) {
+    static getSkillScore(musicMeta, liveType) {
         switch (liveType) {
             case LiveType.SOLO:
                 return musicMeta.skill_score_solo;
@@ -360,15 +423,18 @@ class LiveCalculator {
                 return musicMeta.skill_score_auto;
         }
     }
-    async getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
-        const bestSkill = skillDetails === undefined;
-        const skills = bestSkill
-            ? [...deckDetail.skill, deckDetail.skill[0]].sort((a, b) => a.scoreUp - b.scoreUp)
-            : skillDetails;
-        const baseRate = this.getBaseScore(musicMeta, liveType);
-        const skillRate = bestSkill
-            ? [...this.getSkillScore(musicMeta, liveType)].sort((a, b) => a - b)
-            : this.getSkillScore(musicMeta, liveType);
+    static getLiveDetailByDeck(deckDetail, musicMeta, liveType, skillDetails = undefined, multiPowerSum = 0) {
+        const skills = skillDetails !== undefined
+            ? skillDetails
+            : (liveType === LiveType.MULTI
+                ? duplicateObj(LiveCalculator.getMultiLiveSkill(deckDetail), 6)
+                : [...[...deckDetail.skill].sort((a, b) => a.scoreUp - b.scoreUp),
+                    deckDetail.skill[0]]);
+        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 powerSum = multiPowerSum === 0 ? 5 * deckDetail.power : multiPowerSum;
@@ -380,19 +446,39 @@ 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)));
-        return await this.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
+            ? undefined
+            : LiveCalculator.getSoloLiveSkill(liveSkills, deckDetail.skill);
+        return LiveCalculator.getLiveDetailByDeck(deckDetail, musicMeta, liveType, skills);
     }
 }
 var LiveType;
@@ -402,4 +488,4 @@ var LiveType;
     LiveType["AUTO"] = "auto";
 })(LiveType || (LiveType = {}));
 
-export { CardCalculator, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DeckCalculator, DeckService, EventCalculator, LiveCalculator, LiveType };
+export { CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DeckCalculator, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveType };

package/package.json

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