sekai-calculator 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -27,35 +27,60 @@ 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
+        };
     }
 }
 
@@ -333,7 +358,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;
@@ -382,18 +431,38 @@ 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);
     }
 }

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 {
@@ -176,6 +193,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 {
@@ -200,7 +224,8 @@ 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>;
 }
 interface LiveDetail {
@@ -219,4 +244,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, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventLiveType, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };

package/dist/index.mjs

@@ -25,35 +25,60 @@ 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
+        };
     }
 }
 
@@ -331,7 +356,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;
@@ -380,18 +429,38 @@ 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);
     }
 }
@@ -402,4 +471,4 @@ var LiveType;
     LiveType["AUTO"] = "auto";
 })(LiveType || (LiveType = {}));
 
-export { CardCalculator, CardDetailMap, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, DeckCalculator, DeckService, 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.1",
+  "version": "0.1.2",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",