sekai-calculator 0.12.2 → 0.13.0

package/dist/index.cjs

@@ -326,39 +326,44 @@ class CardPowerCalculator {
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
     }
-    async getCardPower(userCard, card, cardUnits, userAreaItemLevels) {
+    async getCardPower(userCard, card, cardUnits, userAreaItemLevels, hasCanvasBonus, userGateBonuses) {
         const ret = new CardDetailMap();
         const basePower = await this.getCardBasePowers(userCard, card);
+        const canvasBonus = await this.getMysekaiCanvasBonus(card, hasCanvasBonus);
         const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
+        const fixtureBonus = await this.getFixtureBonusPower(basePower, canvasBonus, card.characterId);
+        const gateBonus = await this.getGateBonusPower(basePower, canvasBonus, userGateBonuses, cardUnits);
         for (const unit of cardUnits) {
-            let power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true);
+            let power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, true, true);
             ret.set(unit, 5, 5, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, true, false);
             ret.set(unit, 5, 1, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, false, true);
             ret.set(unit, 1, 5, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, false, false);
             ret.set(unit, 1, 1, power.total, power);
         }
         return ret;
     }
-    async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
+    async getPower(card, basePower, canvasBonusPower, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
         const base = basePower.reduce((v, it) => v + it, 0);
+        const canvasBonus = canvasBonusPower.reduce((v, it) => v + it, 0);
         const areaItemBonus = await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
         return {
             base,
+            canvasBonus,
             areaItemBonus,
             characterBonus,
-            total: base + characterBonus + areaItemBonus
+            fixtureBonus,
+            gateBonus,
+            total: base + canvasBonus + areaItemBonus + characterBonus + fixtureBonus + gateBonus
         };
     }
     async getCardBasePowers(userCard, card) {
-        const p = await Promise.all([
+        const [cardEpisodes, masterLessons] = await Promise.all([
             await this.dataProvider.getMasterData('cardEpisodes'),
             await this.dataProvider.getMasterData('masterLessons')
         ]);
-        const cardEpisodes = p[0];
-        const masterLessons = p[1];
         const ret = [0, 0, 0];
         const cardParameters = card.cardParameters
             .filter(it => it.cardLevel === userCard.level);
@@ -389,6 +394,17 @@ class CardPowerCalculator {
         }
         return ret;
     }
+    async getMysekaiCanvasBonus(card, hasMysekaiCanvas) {
+        const ret = [0, 0, 0];
+        if (hasMysekaiCanvas) {
+            const cardMysekaiCanvasBonuses = await this.dataProvider.getMasterData('cardMysekaiCanvasBonuses');
+            const canvasBonus = findOrThrow(cardMysekaiCanvasBonuses, it => it.cardRarityType === card.cardRarityType);
+            ret[0] += canvasBonus.power1BonusFixed;
+            ret[1] += canvasBonus.power2BonusFixed;
+            ret[2] += canvasBonus.power3BonusFixed;
+        }
+        return ret;
+    }
     async getAreaItemBonusPower(userAreaItemLevels, basePower, characterId, unit, sameUnit, attr, sameAttr) {
         const usedAreaItems = userAreaItemLevels.filter(it => (it.targetUnit === 'any' || it.targetUnit === unit) &&
             (it.targetCardAttr === 'any' || it.targetCardAttr === attr) &&
@@ -424,6 +440,32 @@ class CardPowerCalculator {
             .reduce((v, it, i) => v +
             Math.floor(Math.fround(Math.fround(Math.fround(it) * Math.fround(0.01)) * basePower[i])), 0);
     }
+    async getFixtureBonusPower(basePower, canvasBonus, characterId) {
+        const userFixtureBonuses = await this.dataProvider.getUserData('userMysekaiFixtureGameCharacterPerformanceBonuses');
+        if (userFixtureBonuses === undefined || userFixtureBonuses === null || userFixtureBonuses.length === 0) {
+            return 0;
+        }
+        const fitureBonus = userFixtureBonuses
+            .find(it => it.gameCharacterId === characterId);
+        if (fitureBonus === undefined || fitureBonus === null) {
+            return 0;
+        }
+        const powers = [...basePower, ...canvasBonus];
+        return powers.reduce((v, it) => v +
+            Math.floor(Math.fround(it * Math.fround(fitureBonus.totalBonusRate * Math.fround(0.001)))), 0);
+    }
+    async getGateBonusPower(basePower, canvasBonus, userGateBonuses, cardUnits) {
+        const isOnlyPiapro = cardUnits.length === 1 && cardUnits[0] === 'piapro';
+        let powerBonusRate = 0;
+        for (const bonus of userGateBonuses) {
+            if (isOnlyPiapro || cardUnits.includes(bonus.unit)) {
+                powerBonusRate = Math.max(powerBonusRate, bonus.powerBonusRate);
+            }
+        }
+        const powers = [...basePower, ...canvasBonus];
+        return powers.reduce((v, it) => v +
+            Math.floor(Math.fround(it * Math.fround(Math.fround(powerBonusRate) * Math.fround(0.01)))), 0);
+    }
 }
 
 class CardSkillCalculator {
@@ -568,6 +610,39 @@ function safeNumber(num) {
     return num;
 }
 
+class MysekaiService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getMysekaiCanvasBonusCards() {
+        const userMysekaiCanvas = await this.dataProvider.getUserData('userMysekaiCanvases');
+        if (userMysekaiCanvas === undefined || userMysekaiCanvas === null) {
+            return [];
+        }
+        return userMysekaiCanvas.map(it => it.cardId);
+    }
+    async getMysekaiFixtureBonuses() {
+        return await this.dataProvider.getUserData('userMysekaiFixtureGameCharacterPerformanceBonuses');
+    }
+    async getMysekaiGateBonuses() {
+        const userMysekaiGates = await this.dataProvider.getUserData('userMysekaiGates');
+        if (userMysekaiGates === undefined || userMysekaiGates === null || userMysekaiGates.length === 0) {
+            return [];
+        }
+        const mysekaiGates = await this.dataProvider.getMasterData('mysekaiGates');
+        const mysekaiGateLevels = await this.dataProvider.getMasterData('mysekaiGateLevels');
+        return userMysekaiGates.map(it => {
+            const gate = findOrThrow(mysekaiGates, g => g.id === it.mysekaiGateId);
+            const level = findOrThrow(mysekaiGateLevels, l => l.mysekaiGateId === it.mysekaiGateId && l.level === it.mysekaiGateLevel);
+            return {
+                unit: gate.unit,
+                powerBonusRate: level.powerBonusRate
+            };
+        });
+    }
+}
+
 class CardCalculator {
     dataProvider;
     powerCalculator;
@@ -576,6 +651,7 @@ class CardCalculator {
     bloomEventCalculator;
     areaItemService;
     cardService;
+    mysekaiService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
@@ -584,8 +660,9 @@ class CardCalculator {
         this.bloomEventCalculator = new CardBloomEventCalculator(dataProvider);
         this.areaItemService = new AreaItemService(dataProvider);
         this.cardService = new CardService(dataProvider);
+        this.mysekaiService = new MysekaiService(dataProvider);
     }
-    async getCardDetail(userCard, userAreaItemLevels, config = {}, { eventId = 0, specialCharacterId = 0 } = {}) {
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, { eventId = 0, specialCharacterId = 0 } = {}, hasCanvasBonus, userGateBonuses) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const config0 = config[card.cardRarityType];
@@ -594,7 +671,7 @@ class CardCalculator {
         const userCard0 = await this.cardService.applyCardConfig(userCard, card, config0);
         const units = await this.cardService.getCardUnits(card);
         const skill = await this.skillCalculator.getCardSkill(userCard0, card);
-        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels, hasCanvasBonus, userGateBonuses);
         const eventBonus = eventId === 0
             ? undefined
             : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
@@ -611,14 +688,17 @@ class CardCalculator {
             power,
             skill,
             eventBonus,
-            supportDeckBonus
+            supportDeckBonus,
+            hasCanvasBonus
         };
     }
     async batchGetCardDetail(userCards, config = {}, eventConfig, areaItemLevels) {
         const areaItemLevels0 = areaItemLevels === undefined
             ? await this.areaItemService.getAreaItemLevels()
             : areaItemLevels;
-        const ret = await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventConfig))).then(it => it.filter(it => it !== undefined));
+        const userCanvasBonusCards = await this.mysekaiService.getMysekaiCanvasBonusCards();
+        const userGateBonuses = await this.mysekaiService.getMysekaiGateBonuses();
+        const ret = await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventConfig, userCanvasBonusCards.includes(it.cardId), userGateBonuses))).then(it => it.filter(it => it !== undefined));
         if (eventConfig?.specialCharacterId !== undefined && eventConfig.specialCharacterId > 0) {
             return ret.sort((a, b) => safeNumber(b.supportDeckBonus) - safeNumber(a.supportDeckBonus));
         }
@@ -881,15 +961,21 @@ class DeckCalculator {
                 return current.total > vv.total ? current : vv;
             }, cardDetail.power.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), getOrThrow(map, cardDetail.attr))));
         });
-        const base = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).base, 0);
-        const areaItemBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).areaItemBonus, 0);
-        const characterBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).characterBonus, 0);
+        const base = DeckCalculator.sumPower(cardDetails, cardPower, it => it.base);
+        const canvasBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.canvasBonus);
+        const areaItemBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.areaItemBonus);
+        const characterBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.characterBonus);
+        const fixtureBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.fixtureBonus);
+        const gateBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.gateBonus);
         const total = base + areaItemBonus + characterBonus + honorBonus;
         const power = {
             base,
+            canvasBonus,
             areaItemBonus,
             characterBonus,
             honorBonus,
+            fixtureBonus,
+            gateBonus,
             total
         };
         const cards = cardDetails.map(cardDetail => {
@@ -916,6 +1002,9 @@ class DeckCalculator {
             cards
         };
     }
+    static sumPower(cardDetails, cardPower, attr) {
+        return cardDetails.reduce((v, cardDetail) => v + attr(getOrThrow(cardPower, cardDetail.cardId)), 0);
+    }
     async getDeckDetail(deckCards, allCards, eventConfig, areaItemLevels) {
         const allCards0 = await this.cardCalculator.batchGetCardDetail(allCards, {}, eventConfig, areaItemLevels);
         return await this.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards, {}, eventConfig, areaItemLevels), allCards0, await this.getHonorBonusPower(), eventConfig?.eventType);

package/dist/index.d.ts

@@ -186,6 +186,7 @@ declare class DeckCalculator {
     constructor(dataProvider: DataProvider);
     getHonorBonusPower(): Promise<number>;
     getDeckDetailByCards(cardDetails: CardDetail[], allCards: CardDetail[], honorBonus: number, eventType?: EventType): Promise<DeckDetail>;
+    private static sumPower;
     getDeckDetail(deckCards: UserCard[], allCards: UserCard[], eventConfig?: EventConfig, areaItemLevels?: AreaItemLevel[]): Promise<DeckDetail>;
 }
 interface DeckDetail {
@@ -205,15 +206,21 @@ interface DeckCardDetail {
 }
 interface DeckPowerDetail {
     base: number;
+    canvasBonus: number;
     areaItemBonus: number;
     characterBonus: number;
     honorBonus: number;
+    fixtureBonus: number;
+    gateBonus: number;
     total: number;
 }
 interface DeckCardPowerDetail {
     base: number;
+    canvasBonus: number;
     areaItemBonus: number;
     characterBonus: number;
+    fixtureBonus: number;
+    gateBonus: number;
     total: number;
 }
 interface DeckCardSkillDetail {
@@ -221,6 +228,11 @@ interface DeckCardSkillDetail {
     lifeRecovery: number;
 }
 
+interface MysekaiGateBonus {
+    unit: string;
+    powerBonusRate: number;
+}
+
 declare class CardCalculator {
     private readonly dataProvider;
     private readonly powerCalculator;
@@ -229,8 +241,9 @@ declare class CardCalculator {
     private readonly bloomEventCalculator;
     private readonly areaItemService;
     private readonly cardService;
+    private readonly mysekaiService;
     constructor(dataProvider: DataProvider);
-    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], config?: Record<string, CardConfig>, { eventId, specialCharacterId }?: EventConfig): Promise<CardDetail | undefined>;
+    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], config: Record<string, CardConfig> | undefined, { eventId, specialCharacterId }: EventConfig | undefined, hasCanvasBonus: boolean, userGateBonuses: MysekaiGateBonus[]): Promise<CardDetail | undefined>;
     batchGetCardDetail(userCards: UserCard[], config?: Record<string, CardConfig>, eventConfig?: EventConfig, areaItemLevels?: AreaItemLevel[]): Promise<CardDetail[]>;
     static isCertainlyLessThan(cardDetail0: CardDetail, cardDetail1: CardDetail): boolean;
 }
@@ -247,6 +260,7 @@ interface CardDetail {
     skill: CardDetailMap<DeckCardSkillDetail>;
     eventBonus?: number;
     supportDeckBonus?: number;
+    hasCanvasBonus: boolean;
 }
 interface CardConfig {
     disable?: boolean;
@@ -317,11 +331,14 @@ declare class DeckService {
 declare class CardPowerCalculator {
     private readonly dataProvider;
     constructor(dataProvider: DataProvider);
-    getCardPower(userCard: UserCard, card: Card, cardUnits: string[], userAreaItemLevels: AreaItemLevel[]): Promise<CardDetailMap<DeckCardPowerDetail>>;
+    getCardPower(userCard: UserCard, card: Card, cardUnits: string[], userAreaItemLevels: AreaItemLevel[], hasCanvasBonus: boolean, userGateBonuses: MysekaiGateBonus[]): Promise<CardDetailMap<DeckCardPowerDetail>>;
     private getPower;
     private getCardBasePowers;
+    private getMysekaiCanvasBonus;
     private getAreaItemBonusPower;
     private getCharacterBonusPower;
+    private getFixtureBonusPower;
+    private getGateBonusPower;
 }
 
 declare class CardSkillCalculator {

package/dist/index.mjs

@@ -324,39 +324,44 @@ class CardPowerCalculator {
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
     }
-    async getCardPower(userCard, card, cardUnits, userAreaItemLevels) {
+    async getCardPower(userCard, card, cardUnits, userAreaItemLevels, hasCanvasBonus, userGateBonuses) {
         const ret = new CardDetailMap();
         const basePower = await this.getCardBasePowers(userCard, card);
+        const canvasBonus = await this.getMysekaiCanvasBonus(card, hasCanvasBonus);
         const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
+        const fixtureBonus = await this.getFixtureBonusPower(basePower, canvasBonus, card.characterId);
+        const gateBonus = await this.getGateBonusPower(basePower, canvasBonus, userGateBonuses, cardUnits);
         for (const unit of cardUnits) {
-            let power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true);
+            let power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, true, true);
             ret.set(unit, 5, 5, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, true, false);
             ret.set(unit, 5, 1, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, false, true);
             ret.set(unit, 1, 5, power.total, power);
-            power = await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false);
+            power = await this.getPower(card, basePower, canvasBonus, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, false, false);
             ret.set(unit, 1, 1, power.total, power);
         }
         return ret;
     }
-    async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
+    async getPower(card, basePower, canvasBonusPower, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
         const base = basePower.reduce((v, it) => v + it, 0);
+        const canvasBonus = canvasBonusPower.reduce((v, it) => v + it, 0);
         const areaItemBonus = await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
         return {
             base,
+            canvasBonus,
             areaItemBonus,
             characterBonus,
-            total: base + characterBonus + areaItemBonus
+            fixtureBonus,
+            gateBonus,
+            total: base + canvasBonus + areaItemBonus + characterBonus + fixtureBonus + gateBonus
         };
     }
     async getCardBasePowers(userCard, card) {
-        const p = await Promise.all([
+        const [cardEpisodes, masterLessons] = await Promise.all([
             await this.dataProvider.getMasterData('cardEpisodes'),
             await this.dataProvider.getMasterData('masterLessons')
         ]);
-        const cardEpisodes = p[0];
-        const masterLessons = p[1];
         const ret = [0, 0, 0];
         const cardParameters = card.cardParameters
             .filter(it => it.cardLevel === userCard.level);
@@ -387,6 +392,17 @@ class CardPowerCalculator {
         }
         return ret;
     }
+    async getMysekaiCanvasBonus(card, hasMysekaiCanvas) {
+        const ret = [0, 0, 0];
+        if (hasMysekaiCanvas) {
+            const cardMysekaiCanvasBonuses = await this.dataProvider.getMasterData('cardMysekaiCanvasBonuses');
+            const canvasBonus = findOrThrow(cardMysekaiCanvasBonuses, it => it.cardRarityType === card.cardRarityType);
+            ret[0] += canvasBonus.power1BonusFixed;
+            ret[1] += canvasBonus.power2BonusFixed;
+            ret[2] += canvasBonus.power3BonusFixed;
+        }
+        return ret;
+    }
     async getAreaItemBonusPower(userAreaItemLevels, basePower, characterId, unit, sameUnit, attr, sameAttr) {
         const usedAreaItems = userAreaItemLevels.filter(it => (it.targetUnit === 'any' || it.targetUnit === unit) &&
             (it.targetCardAttr === 'any' || it.targetCardAttr === attr) &&
@@ -422,6 +438,32 @@ class CardPowerCalculator {
             .reduce((v, it, i) => v +
             Math.floor(Math.fround(Math.fround(Math.fround(it) * Math.fround(0.01)) * basePower[i])), 0);
     }
+    async getFixtureBonusPower(basePower, canvasBonus, characterId) {
+        const userFixtureBonuses = await this.dataProvider.getUserData('userMysekaiFixtureGameCharacterPerformanceBonuses');
+        if (userFixtureBonuses === undefined || userFixtureBonuses === null || userFixtureBonuses.length === 0) {
+            return 0;
+        }
+        const fitureBonus = userFixtureBonuses
+            .find(it => it.gameCharacterId === characterId);
+        if (fitureBonus === undefined || fitureBonus === null) {
+            return 0;
+        }
+        const powers = [...basePower, ...canvasBonus];
+        return powers.reduce((v, it) => v +
+            Math.floor(Math.fround(it * Math.fround(fitureBonus.totalBonusRate * Math.fround(0.001)))), 0);
+    }
+    async getGateBonusPower(basePower, canvasBonus, userGateBonuses, cardUnits) {
+        const isOnlyPiapro = cardUnits.length === 1 && cardUnits[0] === 'piapro';
+        let powerBonusRate = 0;
+        for (const bonus of userGateBonuses) {
+            if (isOnlyPiapro || cardUnits.includes(bonus.unit)) {
+                powerBonusRate = Math.max(powerBonusRate, bonus.powerBonusRate);
+            }
+        }
+        const powers = [...basePower, ...canvasBonus];
+        return powers.reduce((v, it) => v +
+            Math.floor(Math.fround(it * Math.fround(Math.fround(powerBonusRate) * Math.fround(0.01)))), 0);
+    }
 }
 
 class CardSkillCalculator {
@@ -566,6 +608,39 @@ function safeNumber(num) {
     return num;
 }
 
+class MysekaiService {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getMysekaiCanvasBonusCards() {
+        const userMysekaiCanvas = await this.dataProvider.getUserData('userMysekaiCanvases');
+        if (userMysekaiCanvas === undefined || userMysekaiCanvas === null) {
+            return [];
+        }
+        return userMysekaiCanvas.map(it => it.cardId);
+    }
+    async getMysekaiFixtureBonuses() {
+        return await this.dataProvider.getUserData('userMysekaiFixtureGameCharacterPerformanceBonuses');
+    }
+    async getMysekaiGateBonuses() {
+        const userMysekaiGates = await this.dataProvider.getUserData('userMysekaiGates');
+        if (userMysekaiGates === undefined || userMysekaiGates === null || userMysekaiGates.length === 0) {
+            return [];
+        }
+        const mysekaiGates = await this.dataProvider.getMasterData('mysekaiGates');
+        const mysekaiGateLevels = await this.dataProvider.getMasterData('mysekaiGateLevels');
+        return userMysekaiGates.map(it => {
+            const gate = findOrThrow(mysekaiGates, g => g.id === it.mysekaiGateId);
+            const level = findOrThrow(mysekaiGateLevels, l => l.mysekaiGateId === it.mysekaiGateId && l.level === it.mysekaiGateLevel);
+            return {
+                unit: gate.unit,
+                powerBonusRate: level.powerBonusRate
+            };
+        });
+    }
+}
+
 class CardCalculator {
     dataProvider;
     powerCalculator;
@@ -574,6 +649,7 @@ class CardCalculator {
     bloomEventCalculator;
     areaItemService;
     cardService;
+    mysekaiService;
     constructor(dataProvider) {
         this.dataProvider = dataProvider;
         this.powerCalculator = new CardPowerCalculator(dataProvider);
@@ -582,8 +658,9 @@ class CardCalculator {
         this.bloomEventCalculator = new CardBloomEventCalculator(dataProvider);
         this.areaItemService = new AreaItemService(dataProvider);
         this.cardService = new CardService(dataProvider);
+        this.mysekaiService = new MysekaiService(dataProvider);
     }
-    async getCardDetail(userCard, userAreaItemLevels, config = {}, { eventId = 0, specialCharacterId = 0 } = {}) {
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, { eventId = 0, specialCharacterId = 0 } = {}, hasCanvasBonus, userGateBonuses) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const config0 = config[card.cardRarityType];
@@ -592,7 +669,7 @@ class CardCalculator {
         const userCard0 = await this.cardService.applyCardConfig(userCard, card, config0);
         const units = await this.cardService.getCardUnits(card);
         const skill = await this.skillCalculator.getCardSkill(userCard0, card);
-        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels, hasCanvasBonus, userGateBonuses);
         const eventBonus = eventId === 0
             ? undefined
             : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
@@ -609,14 +686,17 @@ class CardCalculator {
             power,
             skill,
             eventBonus,
-            supportDeckBonus
+            supportDeckBonus,
+            hasCanvasBonus
         };
     }
     async batchGetCardDetail(userCards, config = {}, eventConfig, areaItemLevels) {
         const areaItemLevels0 = areaItemLevels === undefined
             ? await this.areaItemService.getAreaItemLevels()
             : areaItemLevels;
-        const ret = await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventConfig))).then(it => it.filter(it => it !== undefined));
+        const userCanvasBonusCards = await this.mysekaiService.getMysekaiCanvasBonusCards();
+        const userGateBonuses = await this.mysekaiService.getMysekaiGateBonuses();
+        const ret = await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, areaItemLevels0, config, eventConfig, userCanvasBonusCards.includes(it.cardId), userGateBonuses))).then(it => it.filter(it => it !== undefined));
         if (eventConfig?.specialCharacterId !== undefined && eventConfig.specialCharacterId > 0) {
             return ret.sort((a, b) => safeNumber(b.supportDeckBonus) - safeNumber(a.supportDeckBonus));
         }
@@ -879,15 +959,21 @@ class DeckCalculator {
                 return current.total > vv.total ? current : vv;
             }, cardDetail.power.get(cardDetail.units[0], getOrThrow(map, cardDetail.units[0]), getOrThrow(map, cardDetail.attr))));
         });
-        const base = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).base, 0);
-        const areaItemBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).areaItemBonus, 0);
-        const characterBonus = cardDetails.reduce((v, cardDetail) => v + getOrThrow(cardPower, cardDetail.cardId).characterBonus, 0);
+        const base = DeckCalculator.sumPower(cardDetails, cardPower, it => it.base);
+        const canvasBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.canvasBonus);
+        const areaItemBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.areaItemBonus);
+        const characterBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.characterBonus);
+        const fixtureBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.fixtureBonus);
+        const gateBonus = DeckCalculator.sumPower(cardDetails, cardPower, it => it.gateBonus);
         const total = base + areaItemBonus + characterBonus + honorBonus;
         const power = {
             base,
+            canvasBonus,
             areaItemBonus,
             characterBonus,
             honorBonus,
+            fixtureBonus,
+            gateBonus,
             total
         };
         const cards = cardDetails.map(cardDetail => {
@@ -914,6 +1000,9 @@ class DeckCalculator {
             cards
         };
     }
+    static sumPower(cardDetails, cardPower, attr) {
+        return cardDetails.reduce((v, cardDetail) => v + attr(getOrThrow(cardPower, cardDetail.cardId)), 0);
+    }
     async getDeckDetail(deckCards, allCards, eventConfig, areaItemLevels) {
         const allCards0 = await this.cardCalculator.batchGetCardDetail(allCards, {}, eventConfig, areaItemLevels);
         return await this.getDeckDetailByCards(await this.cardCalculator.batchGetCardDetail(deckCards, {}, eventConfig, areaItemLevels), allCards0, await this.getHonorBonusPower(), eventConfig?.eventType);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekai-calculator",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",
@@ -40,7 +40,7 @@
     "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-promise": "^6.1.1",
     "jest": "^29.5.0",
-    "rollup": "^3.20.2",
+    "rollup": "^4.22.4",
     "rollup-plugin-dts": "^5.3.0",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",