sekai-calculator 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -16,15 +16,128 @@ interface UserCard {
     }>;
 }
 
+interface UserDeck {
+    deckId: number;
+    member1: number;
+    member2: number;
+    member3: number;
+    member4: number;
+    member5: number;
+}
+
 declare class EventCalculator {
     private readonly dataProvider;
+    private readonly deckCalculator;
     constructor(dataProvider: DataProvider);
     private getEventDeckBonus;
     getCardEventBonus(userCard: UserCard, eventId: number): Promise<number>;
+    getDeckEventBonus(userDeck: UserDeck, eventId: number): Promise<number>;
+}
+
+interface AreaItemLevel {
+    areaItemId: number;
+    level: number;
+    targetUnit: string;
+    targetCardAttr: string;
+    targetGameCharacterId: number;
+    power1BonusRate: number;
+    power1AllMatchBonusRate: number;
+    power2BonusRate: number;
+    power2AllMatchBonusRate: number;
+    power3BonusRate: number;
+    power3AllMatchBonusRate: number;
+    sentence: string;
+}
+
+interface 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[];
+    };
+}
+
+interface EventCard {
+    id: number;
+    cardId: number;
+    eventId: number;
+    bonusRate: number;
 }
 
-declare const _default: {
-    EventCalculator: typeof EventCalculator;
-};
+interface EventDeckBonus {
+    id: number;
+    eventId: number;
+    gameCharacterUnitId?: number;
+    cardAttr?: string;
+    bonusRate: number;
+}
+
+interface EventRarityBonusRate {
+    id: number;
+    cardRarityType: string;
+    masterRank: number;
+    bonusRate: number;
+}
+
+interface GameCharacterUnit {
+    id: number;
+    gameCharacterId: number;
+    unit: string;
+    colorCode: string;
+    skinColorCode: string;
+    skinShadowColorCode1: string;
+    skinShadowColorCode2: string;
+}
+
+interface UserAreaItem {
+    areaItemId: number;
+    level: number;
+}
+
+interface UserChallengeLiveSoloDeck {
+    characterId: number;
+    leader: number;
+    support1: number;
+    support2: number | null;
+    support3: number | null;
+    support4: number | null;
+}
+
+interface UserCharacter {
+    characterId: number;
+    characterRank: number;
+}
 
-export { _default as default };
+export { AreaItemLevel, Card, DataProvider, EventCalculator, EventCard, EventDeckBonus, EventRarityBonusRate, GameCharacterUnit, UserAreaItem, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck };

package/dist/index.es.js

@@ -1,7 +1,28 @@
+function findOrThrow(arr, p) {
+    const result = arr.find(p);
+    if (result === undefined)
+        throw new Error('object not found');
+    return result;
+}
+
+class DeckCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    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));
+    }
+}
+
 class EventCalculator {
     dataProvider;
+    deckCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
     }
     async getEventDeckBonus(eventId, card) {
         const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
@@ -11,9 +32,7 @@ class EventCalculator {
             .reduce((v, eventDeckBonus) => {
             if (eventDeckBonus.gameCharacterUnitId === undefined)
                 return Math.max(v, eventDeckBonus.bonusRate);
-            const gameCharacterUnit = gameCharacterUnits.find(it => it.id === eventDeckBonus.gameCharacterUnitId);
-            if (gameCharacterUnit === undefined)
-                throw new Error('game character unit not found');
+            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
             if (gameCharacterUnit.gameCharacterId !== card.characterId)
                 return v;
             if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
@@ -27,23 +46,20 @@ class EventCalculator {
         const eventCards = await this.dataProvider.getMasterData('eventCards');
         const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
         let eventBonus = 0;
-        const card = cards.find(it => it.id === userCard.cardId);
-        if (card === undefined)
-            throw new Error('card not found');
+        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 = eventRarityBonusRates
-            .find((it) => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
-        if (masterRankBonus === undefined)
-            throw new Error('master rank bonus not found');
+        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
         eventBonus += masterRankBonus.bonusRate;
         return eventBonus;
     }
+    async getDeckEventBonus(userDeck, eventId) {
+        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+        return await deckCards.reduce(async (v, it) => await this.getCardEventBonus(it, eventId) + await v, Promise.resolve(0));
+    }
 }
 
-var index = { EventCalculator };
-
-export { index as default };
+export { EventCalculator };

package/dist/index.js

@@ -1,9 +1,30 @@
 'use strict';
 
+function findOrThrow(arr, p) {
+    const result = arr.find(p);
+    if (result === undefined)
+        throw new Error('object not found');
+    return result;
+}
+
+class DeckCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    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));
+    }
+}
+
 class EventCalculator {
     dataProvider;
+    deckCalculator;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
     }
     async getEventDeckBonus(eventId, card) {
         const eventDeckBonuses = await this.dataProvider.getMasterData('eventDeckBonuses');
@@ -13,9 +34,7 @@ class EventCalculator {
             .reduce((v, eventDeckBonus) => {
             if (eventDeckBonus.gameCharacterUnitId === undefined)
                 return Math.max(v, eventDeckBonus.bonusRate);
-            const gameCharacterUnit = gameCharacterUnits.find(it => it.id === eventDeckBonus.gameCharacterUnitId);
-            if (gameCharacterUnit === undefined)
-                throw new Error('game character unit not found');
+            const gameCharacterUnit = findOrThrow(gameCharacterUnits, unit => unit.id === eventDeckBonus.gameCharacterUnitId);
             if (gameCharacterUnit.gameCharacterId !== card.characterId)
                 return v;
             if (card.characterId < 21 || card.supportUnit === gameCharacterUnit.unit) {
@@ -29,23 +48,20 @@ class EventCalculator {
         const eventCards = await this.dataProvider.getMasterData('eventCards');
         const eventRarityBonusRates = await this.dataProvider.getMasterData('eventRarityBonusRates');
         let eventBonus = 0;
-        const card = cards.find(it => it.id === userCard.cardId);
-        if (card === undefined)
-            throw new Error('card not found');
+        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 = eventRarityBonusRates
-            .find((it) => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
-        if (masterRankBonus === undefined)
-            throw new Error('master rank bonus not found');
+        const masterRankBonus = findOrThrow(eventRarityBonusRates, it => it.cardRarityType === card.cardRarityType && it.masterRank === userCard.masterRank);
         eventBonus += masterRankBonus.bonusRate;
         return eventBonus;
     }
+    async getDeckEventBonus(userDeck, eventId) {
+        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+        return await deckCards.reduce(async (v, it) => await this.getCardEventBonus(it, eventId) + await v, Promise.resolve(0));
+    }
 }
 
-var index = { EventCalculator };
-
-module.exports = index;
+exports.EventCalculator = EventCalculator;

package/package.json

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