sekai-calculator 0.0.7 → 0.1.0

package/README.md

@@ -1,8 +1,9 @@
 # sekai-calculator
 Project SEKAI Calculator for deck power, live score, event point and more.
 
-## Requirement
-- Node.js >= 18
+This project is fully made up in TypeScript, while reducing `any` as possible. 
+
+Both ECMAScript Module `index.mjs` and CommonJS `index.cjs` are provided with types `index.d.ts` for TypeScript.
 
 ## Quick Start
 W.I.P.

package/dist/index.cjs

@@ -0,0 +1,409 @@
+'use strict';
+
+function findOrThrow(arr, p) {
+    const result = arr.find(p);
+    if (result === undefined)
+        throw new Error('object not found');
+    return result;
+}
+function getOrThrow(map, key) {
+    const value = map.get(key);
+    if (value === undefined)
+        throw new Error('key not found');
+    return value;
+}
+function getOrDefault(map, key, defaultValue) {
+    const value = map.get(key);
+    if (value === undefined)
+        return defaultValue;
+    return value;
+}
+function computeWithDefault(map, key, defaultValue, action) {
+    map.set(key, action(getOrDefault(map, key, defaultValue)));
+}
+function duplicateObj(obj, times) {
+    const ret = [];
+    for (let i = 0; i < times; ++i)
+        ret.push(obj);
+    return ret;
+}
+function mapOrUndefined(arr, fun) {
+    if (arr === undefined)
+        return undefined;
+    return arr.map(fun);
+}
+
+class CardPowerCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getCardPower(userCard, card, cardUnits, userAreaItemLevels) {
+        const ret = new CardDetailMap();
+        const basePower = await this.getCardBasePowers(userCard, card);
+        const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
+        for (const unit of cardUnits) {
+            ret.set(unit, 5, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true));
+            ret.set(unit, 5, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false));
+            ret.set(unit, 1, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true));
+            ret.set(unit, 1, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false));
+        }
+        return ret;
+    }
+    async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
+        return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+    }
+    async getCardBasePowers(userCard, card) {
+        const cardEpisodes = await this.dataProvider.getMasterData('cardEpisodes');
+        const masterLessons = await this.dataProvider.getMasterData('masterLessons');
+        const ret = [0, 0, 0];
+        const cardParameters = card.cardParameters.filter(it => it.cardLevel === userCard.level);
+        const params = ['param1', 'param2', 'param3'];
+        params.forEach((param, i) => {
+            ret[i] = findOrThrow(cardParameters, it => it.cardParameterType === param).power;
+        });
+        if (userCard.specialTrainingStatus === 'done') {
+            ret[0] += card.specialTrainingPower1BonusFixed;
+            ret[1] += card.specialTrainingPower2BonusFixed;
+            ret[2] += card.specialTrainingPower3BonusFixed;
+        }
+        const episodes = userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
+            .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
+        for (const episode of episodes) {
+            ret[0] += episode.power1BonusFixed;
+            ret[1] += episode.power2BonusFixed;
+            ret[2] += episode.power3BonusFixed;
+        }
+        const usedMasterLessons = masterLessons
+            .filter((it) => it.cardRarityType === card.cardRarityType && it.masterRank <= userCard.masterRank);
+        for (const masterLesson of usedMasterLessons) {
+            ret[0] += masterLesson.power1BonusFixed;
+            ret[1] += masterLesson.power2BonusFixed;
+            ret[2] += masterLesson.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) &&
+            (it.targetGameCharacterId === undefined || it.targetGameCharacterId === characterId));
+        const areaItemBonus = [0, 0, 0];
+        for (const areaItem of usedAreaItems) {
+            const allMatch = (areaItem.targetUnit !== 'any' && sameUnit) || (areaItem.targetCardAttr !== 'any' && sameAttr);
+            areaItemBonus[0] += allMatch ? areaItem.power1AllMatchBonusRate : areaItem.power1BonusRate;
+            areaItemBonus[1] += allMatch ? areaItem.power2AllMatchBonusRate : areaItem.power2BonusRate;
+            areaItemBonus[2] += allMatch ? areaItem.power3AllMatchBonusRate : areaItem.power3BonusRate;
+        }
+        return basePower.reduce((v, it, i) => v + Math.floor(it * areaItemBonus[i] / 100), 0);
+    }
+    async getCharacterBonusPower(basePower, characterId) {
+        const characterRanks = await this.dataProvider.getMasterData('characterRanks');
+        const userCharacters = await this.dataProvider.getUserData('userCharacters');
+        const userCharacter = findOrThrow(userCharacters, it => it.characterId === characterId);
+        const characterRank = findOrThrow(characterRanks, it => it.characterId === userCharacter.characterId && it.characterRank === userCharacter.characterRank);
+        const rates = [characterRank.power1BonusRate, characterRank.power2BonusRate, characterRank.power3BonusRate];
+        return rates.reduce((v, it, i) => v + Math.floor(basePower[i] * it / 100), 0);
+    }
+}
+
+class CardSkillCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getCardSkill(userCard, card) {
+        const scoreUpMap = new CardDetailMap();
+        const detail = await this.getSkillDetail(userCard, card);
+        if (detail.scoreUpEnhance !== undefined) {
+            for (let i = 1; i <= 5; ++i) {
+                const scoreUp = detail.scoreUp + (i === 5 ? 5 : (i - 1)) * detail.scoreUpEnhance.value;
+                scoreUpMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp);
+            }
+        }
+        scoreUpMap.set('any', 1, 1, detail.scoreUp);
+        return { scoreUp: scoreUpMap, lifeRecovery: detail.lifeRecovery };
+    }
+    async getSkillDetail(userCard, card) {
+        const skills = await this.dataProvider.getMasterData('skills');
+        const skill = findOrThrow(skills, it => it.id === card.skillId);
+        const ret = { scoreUp: 0, lifeRecovery: 0 };
+        for (const skillEffect of skill.skillEffects) {
+            const skillEffectDetail = findOrThrow(skillEffect.skillEffectDetails, it => it.level === userCard.skillLevel);
+            if (skillEffect.skillEffectType === 'score_up' ||
+                skillEffect.skillEffectType === 'score_up_condition_life' ||
+                skillEffect.skillEffectType === 'score_up_keep') {
+                const current = skillEffectDetail.activateEffectValue;
+                if (skillEffect.skillEnhance !== undefined) {
+                    ret.scoreUpEnhance = {
+                        unit: skillEffect.skillEnhance.skillEnhanceCondition.unit,
+                        value: skillEffect.skillEnhance.activateEffectValue
+                    };
+                }
+                ret.scoreUp = Math.max(ret.scoreUp, current);
+            }
+            else if (skillEffect.skillEffectType === 'life_recovery') {
+                ret.lifeRecovery += skillEffectDetail.activateEffectValue;
+            }
+        }
+        return ret;
+    }
+}
+
+class CardCalculator {
+    dataProvider;
+    powerCalculator;
+    skillCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.powerCalculator = new CardPowerCalculator(dataProvider);
+        this.skillCalculator = new CardSkillCalculator(dataProvider);
+    }
+    async getCardUnits(card) {
+        const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
+        const units = [];
+        if (card.supportUnit !== 'none')
+            units.push(card.supportUnit);
+        units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
+        return units;
+    }
+    async getCardDetail(userCard, userAreaItemLevels) {
+        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);
+        return {
+            cardId: card.id,
+            units,
+            attr: card.attr,
+            power,
+            scoreSkill: skill.scoreUp,
+            lifeSkill: skill.lifeRecovery
+        };
+    }
+}
+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;
+    }
+}
+
+class DeckCalculator {
+    dataProvider;
+    cardCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardCalculator = new CardCalculator(dataProvider);
+    }
+    async getDeck(deckId) {
+        const userDecks = await this.dataProvider.getUserData('userDecks');
+        return findOrThrow(userDecks, it => it.deckId === deckId);
+    }
+    async getDeckCards(userDeck) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
+        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
+    }
+    async getDeckCardsById(deckId) {
+        return await this.getDeckCards(await this.getDeck(deckId));
+    }
+    async getHonorBonusPower() {
+        const honors = await this.dataProvider.getMasterData('honors');
+        const userHonors = await this.dataProvider.getUserData('userHonors');
+        return userHonors
+            .map(userHonor => {
+            const honor = findOrThrow(honors, it => it.id === userHonor.honorId);
+            return findOrThrow(honor.levels, it => it.level === userHonor.level);
+        })
+            .reduce((v, it) => v + it.bonus, 0);
+    }
+    async getDeckDetailByCards(cardDetails, honorBonus) {
+        const map = new Map();
+        for (const cardDetail of cardDetails) {
+            computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
+            cardDetail.units.forEach(key => { computeWithDefault(map, key, 0, it => it + 1); });
+        }
+        const power = cardDetails.reduce((v, cardDetail) => v + cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0), 0) + honorBonus;
+        const skill = cardDetails.map(cardDetail => {
+            const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
+            return {
+                cardId: cardDetail.cardId,
+                scoreUp,
+                lifeRecovery: cardDetail.lifeSkill
+            };
+        });
+        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());
+    }
+    async getDeckDetailById(deckId) {
+        return await this.getDeckDetail(await this.getDeckCardsById(deckId));
+    }
+}
+
+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 EventCalculator {
+    dataProvider;
+    deckCalculator;
+    cardEventCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
+        this.cardEventCalculator = new CardEventCalculator(dataProvider);
+    }
+    async getDeckEventBonus(userDeck, eventId) {
+        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
+    }
+    async getDeckEventBonusById(deckId, eventId) {
+        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
+    }
+}
+
+class LiveCalculator {
+    dataProvider;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    getBaseScore(musicMeta, liveType) {
+        switch (liveType) {
+            case exports.LiveType.SOLO:
+                return musicMeta.base_score;
+            case exports.LiveType.MULTI:
+                return musicMeta.base_score + musicMeta.fever_score;
+            case exports.LiveType.AUTO:
+                return musicMeta.base_score_auto;
+        }
+    }
+    getSkillScore(musicMeta, liveType) {
+        switch (liveType) {
+            case exports.LiveType.SOLO:
+                return musicMeta.skill_score_solo;
+            case exports.LiveType.MULTI:
+                return musicMeta.skill_score_multi;
+            case exports.LiveType.AUTO:
+                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);
+        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;
+        const activeBonus = liveType === exports.LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
+        return {
+            score: Math.floor(rate * deckDetail.power * 4 + activeBonus),
+            time: musicMeta.music_time,
+            life: Math.min(2000, life + 1000),
+            tap: musicMeta.tap_count
+        };
+    }
+    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 };
+    }
+    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);
+    }
+    async getLiveDetailById(deckId, musicId, musicDiff, liveType, liveSkills = undefined) {
+        return await this.getLiveDetail(await this.deckCalculator.getDeckCardsById(deckId), musicId, musicDiff, liveType, liveSkills);
+    }
+}
+exports.LiveType = void 0;
+(function (LiveType) {
+    LiveType["SOLO"] = "solo";
+    LiveType["MULTI"] = "multi";
+    LiveType["AUTO"] = "auto";
+})(exports.LiveType || (exports.LiveType = {}));
+
+exports.CardCalculator = CardCalculator;
+exports.CardDetailMap = CardDetailMap;
+exports.DeckCalculator = DeckCalculator;
+exports.EventCalculator = EventCalculator;
+exports.LiveCalculator = LiveCalculator;

package/dist/index.d.ts

@@ -4,18 +4,6 @@ interface DataProvider {
     getMusicMeta: () => Promise<any>;
 }
 
-interface UserCard {
-    cardId: number;
-    level?: number;
-    skillLevel?: number;
-    masterRank: number;
-    specialTrainingStatus?: string;
-    episodes?: Array<{
-        cardEpisodeId: number;
-        scenarioStatus: string;
-    }>;
-}
-
 interface UserDeck {
     deckId: number;
     member1: number;
@@ -28,19 +16,30 @@ interface UserDeck {
 declare class EventCalculator {
     private readonly dataProvider;
     private readonly deckCalculator;
+    private readonly cardEventCalculator;
     constructor(dataProvider: DataProvider);
-    private getEventDeckBonus;
-    getCardEventBonus(userCard: UserCard, eventId: number): Promise<number>;
     getDeckEventBonus(userDeck: UserDeck, eventId: number): Promise<number>;
     getDeckEventBonusById(deckId: number, eventId: number): Promise<number>;
 }
 
+interface UserCard {
+    cardId: number;
+    level: number;
+    skillLevel: number;
+    masterRank: number;
+    specialTrainingStatus?: string;
+    episodes: Array<{
+        cardEpisodeId: number;
+        scenarioStatus: string;
+    }>;
+}
+
 interface AreaItemLevel {
     areaItemId: number;
     level: number;
     targetUnit: string;
     targetCardAttr: string;
-    targetGameCharacterId: number;
+    targetGameCharacterId?: number;
     power1BonusRate: number;
     power1AllMatchBonusRate: number;
     power2BonusRate: number;
@@ -50,95 +49,96 @@ interface AreaItemLevel {
     sentence: string;
 }
 
-interface CommonResource {
-    resourceId?: number;
-    resourceType: string;
-    resourceLevel?: number;
-    quantity: number;
+declare class CardCalculator {
+    private readonly dataProvider;
+    private readonly powerCalculator;
+    private readonly skillCalculator;
+    constructor(dataProvider: DataProvider);
+    private getCardUnits;
+    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[]): Promise<CardDetail>;
 }
-
-interface Card {
-    id: number;
-    seq: number;
-    characterId: number;
-    cardRarityType: string;
-    specialTrainingPower1BonusFixed: number;
-    specialTrainingPower2BonusFixed: number;
-    specialTrainingPower3BonusFixed: number;
+interface CardDetail {
+    cardId: number;
+    units: string[];
     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[];
-    };
+    power: CardDetailMap;
+    scoreSkill: CardDetailMap;
+    lifeSkill: number;
+    eventBonus?: number;
 }
-
-interface EventCard {
-    id: number;
-    cardId: number;
-    eventId: number;
-    bonusRate: 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 EventDeckBonus {
-    id: number;
-    eventId: number;
-    gameCharacterUnitId?: number;
-    cardAttr?: string;
-    bonusRate: number;
+declare class DeckCalculator {
+    private readonly dataProvider;
+    private readonly cardCalculator;
+    constructor(dataProvider: DataProvider);
+    getDeck(deckId: number): Promise<UserDeck>;
+    getDeckCards(userDeck: UserDeck): Promise<UserCard[]>;
+    getDeckCardsById(deckId: number): Promise<UserCard[]>;
+    private getHonorBonusPower;
+    getDeckDetailByCards(cardDetails: CardDetail[], honorBonus: number): Promise<DeckDetail>;
+    getDeckDetail(deckCards: UserCard[]): Promise<DeckDetail>;
+    getDeckDetailById(deckId: number): Promise<DeckDetail>;
 }
-
-interface EventRarityBonusRate {
-    id: number;
-    cardRarityType: string;
-    masterRank: number;
-    bonusRate: number;
+interface DeckDetail {
+    power: number;
+    skill: SkillDetail[];
 }
-
-interface GameCharacterUnit {
-    id: number;
-    gameCharacterId: number;
-    unit: string;
-    colorCode: string;
-    skinColorCode: string;
-    skinShadowColorCode1: string;
-    skinShadowColorCode2: string;
+interface SkillDetail {
+    cardId?: number;
+    scoreUp: number;
+    lifeRecovery: number;
 }
 
-interface UserAreaItem {
-    areaItemId: number;
-    level: number;
+interface MusicMeta {
+    music_id: number;
+    difficulty: string;
+    music_time: number;
+    event_rate: number;
+    base_score: number;
+    base_score_auto: number;
+    skill_score_solo: number[];
+    skill_score_auto: number[];
+    skill_score_multi: number[];
+    fever_score: number;
+    fever_end_time: number;
+    tap_count: number;
 }
 
-interface UserChallengeLiveSoloDeck {
-    characterId: number;
-    leader: number;
-    support1: number;
-    support2: number | null;
-    support3: number | null;
-    support4: number | null;
+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;
+    getLiveDetail(deckCards: UserCard[], musicId: number, musicDiff: string, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
+    getLiveDetailById(deckId: number, musicId: number, musicDiff: string, liveType: LiveType, liveSkills?: LiveSkill[] | undefined): Promise<LiveDetail>;
 }
-
-interface UserCharacter {
-    characterId: number;
-    characterRank: number;
+interface LiveDetail {
+    score: number;
+    time: number;
+    life: number;
+    tap: number;
+}
+interface LiveSkill {
+    seq?: number;
+    cardId: number;
+}
+declare enum LiveType {
+    SOLO = "solo",
+    MULTI = "multi",
+    AUTO = "auto"
 }
 
-export { AreaItemLevel, Card, DataProvider, EventCalculator, EventCard, EventDeckBonus, EventRarityBonusRate, GameCharacterUnit, UserAreaItem, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck };
+export { CardCalculator, CardDetail, CardDetailMap, DataProvider, DeckCalculator, DeckDetail, EventCalculator, LiveCalculator, LiveDetail, LiveSkill, LiveType, SkillDetail };

package/dist/index.mjs

@@ -0,0 +1,403 @@
+function findOrThrow(arr, p) {
+    const result = arr.find(p);
+    if (result === undefined)
+        throw new Error('object not found');
+    return result;
+}
+function getOrThrow(map, key) {
+    const value = map.get(key);
+    if (value === undefined)
+        throw new Error('key not found');
+    return value;
+}
+function getOrDefault(map, key, defaultValue) {
+    const value = map.get(key);
+    if (value === undefined)
+        return defaultValue;
+    return value;
+}
+function computeWithDefault(map, key, defaultValue, action) {
+    map.set(key, action(getOrDefault(map, key, defaultValue)));
+}
+function duplicateObj(obj, times) {
+    const ret = [];
+    for (let i = 0; i < times; ++i)
+        ret.push(obj);
+    return ret;
+}
+function mapOrUndefined(arr, fun) {
+    if (arr === undefined)
+        return undefined;
+    return arr.map(fun);
+}
+
+class CardPowerCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getCardPower(userCard, card, cardUnits, userAreaItemLevels) {
+        const ret = new CardDetailMap();
+        const basePower = await this.getCardBasePowers(userCard, card);
+        const characterBonus = await this.getCharacterBonusPower(basePower, card.characterId);
+        for (const unit of cardUnits) {
+            ret.set(unit, 5, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, true));
+            ret.set(unit, 5, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, true, false));
+            ret.set(unit, 1, 5, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, true));
+            ret.set(unit, 1, 1, await this.getPower(card, basePower, characterBonus, userAreaItemLevels, unit, false, false));
+        }
+        return ret;
+    }
+    async getPower(card, basePower, characterBonus, userAreaItemLevels, unit, sameUnit, sameAttr) {
+        return basePower.reduce((v, it) => v + it, 0) + characterBonus + await this.getAreaItemBonusPower(userAreaItemLevels, basePower, card.characterId, unit, sameUnit, card.attr, sameAttr);
+    }
+    async getCardBasePowers(userCard, card) {
+        const cardEpisodes = await this.dataProvider.getMasterData('cardEpisodes');
+        const masterLessons = await this.dataProvider.getMasterData('masterLessons');
+        const ret = [0, 0, 0];
+        const cardParameters = card.cardParameters.filter(it => it.cardLevel === userCard.level);
+        const params = ['param1', 'param2', 'param3'];
+        params.forEach((param, i) => {
+            ret[i] = findOrThrow(cardParameters, it => it.cardParameterType === param).power;
+        });
+        if (userCard.specialTrainingStatus === 'done') {
+            ret[0] += card.specialTrainingPower1BonusFixed;
+            ret[1] += card.specialTrainingPower2BonusFixed;
+            ret[2] += card.specialTrainingPower3BonusFixed;
+        }
+        const episodes = userCard.episodes.filter(it => it.scenarioStatus === 'already_read')
+            .map(it => findOrThrow(cardEpisodes, e => e.id === it.cardEpisodeId));
+        for (const episode of episodes) {
+            ret[0] += episode.power1BonusFixed;
+            ret[1] += episode.power2BonusFixed;
+            ret[2] += episode.power3BonusFixed;
+        }
+        const usedMasterLessons = masterLessons
+            .filter((it) => it.cardRarityType === card.cardRarityType && it.masterRank <= userCard.masterRank);
+        for (const masterLesson of usedMasterLessons) {
+            ret[0] += masterLesson.power1BonusFixed;
+            ret[1] += masterLesson.power2BonusFixed;
+            ret[2] += masterLesson.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) &&
+            (it.targetGameCharacterId === undefined || it.targetGameCharacterId === characterId));
+        const areaItemBonus = [0, 0, 0];
+        for (const areaItem of usedAreaItems) {
+            const allMatch = (areaItem.targetUnit !== 'any' && sameUnit) || (areaItem.targetCardAttr !== 'any' && sameAttr);
+            areaItemBonus[0] += allMatch ? areaItem.power1AllMatchBonusRate : areaItem.power1BonusRate;
+            areaItemBonus[1] += allMatch ? areaItem.power2AllMatchBonusRate : areaItem.power2BonusRate;
+            areaItemBonus[2] += allMatch ? areaItem.power3AllMatchBonusRate : areaItem.power3BonusRate;
+        }
+        return basePower.reduce((v, it, i) => v + Math.floor(it * areaItemBonus[i] / 100), 0);
+    }
+    async getCharacterBonusPower(basePower, characterId) {
+        const characterRanks = await this.dataProvider.getMasterData('characterRanks');
+        const userCharacters = await this.dataProvider.getUserData('userCharacters');
+        const userCharacter = findOrThrow(userCharacters, it => it.characterId === characterId);
+        const characterRank = findOrThrow(characterRanks, it => it.characterId === userCharacter.characterId && it.characterRank === userCharacter.characterRank);
+        const rates = [characterRank.power1BonusRate, characterRank.power2BonusRate, characterRank.power3BonusRate];
+        return rates.reduce((v, it, i) => v + Math.floor(basePower[i] * it / 100), 0);
+    }
+}
+
+class CardSkillCalculator {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    async getCardSkill(userCard, card) {
+        const scoreUpMap = new CardDetailMap();
+        const detail = await this.getSkillDetail(userCard, card);
+        if (detail.scoreUpEnhance !== undefined) {
+            for (let i = 1; i <= 5; ++i) {
+                const scoreUp = detail.scoreUp + (i === 5 ? 5 : (i - 1)) * detail.scoreUpEnhance.value;
+                scoreUpMap.set(detail.scoreUpEnhance.unit, i, 1, scoreUp);
+            }
+        }
+        scoreUpMap.set('any', 1, 1, detail.scoreUp);
+        return { scoreUp: scoreUpMap, lifeRecovery: detail.lifeRecovery };
+    }
+    async getSkillDetail(userCard, card) {
+        const skills = await this.dataProvider.getMasterData('skills');
+        const skill = findOrThrow(skills, it => it.id === card.skillId);
+        const ret = { scoreUp: 0, lifeRecovery: 0 };
+        for (const skillEffect of skill.skillEffects) {
+            const skillEffectDetail = findOrThrow(skillEffect.skillEffectDetails, it => it.level === userCard.skillLevel);
+            if (skillEffect.skillEffectType === 'score_up' ||
+                skillEffect.skillEffectType === 'score_up_condition_life' ||
+                skillEffect.skillEffectType === 'score_up_keep') {
+                const current = skillEffectDetail.activateEffectValue;
+                if (skillEffect.skillEnhance !== undefined) {
+                    ret.scoreUpEnhance = {
+                        unit: skillEffect.skillEnhance.skillEnhanceCondition.unit,
+                        value: skillEffect.skillEnhance.activateEffectValue
+                    };
+                }
+                ret.scoreUp = Math.max(ret.scoreUp, current);
+            }
+            else if (skillEffect.skillEffectType === 'life_recovery') {
+                ret.lifeRecovery += skillEffectDetail.activateEffectValue;
+            }
+        }
+        return ret;
+    }
+}
+
+class CardCalculator {
+    dataProvider;
+    powerCalculator;
+    skillCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.powerCalculator = new CardPowerCalculator(dataProvider);
+        this.skillCalculator = new CardSkillCalculator(dataProvider);
+    }
+    async getCardUnits(card) {
+        const gameCharacters = await this.dataProvider.getMasterData('gameCharacters');
+        const units = [];
+        if (card.supportUnit !== 'none')
+            units.push(card.supportUnit);
+        units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
+        return units;
+    }
+    async getCardDetail(userCard, userAreaItemLevels) {
+        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);
+        return {
+            cardId: card.id,
+            units,
+            attr: card.attr,
+            power,
+            scoreSkill: skill.scoreUp,
+            lifeSkill: skill.lifeRecovery
+        };
+    }
+}
+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;
+    }
+}
+
+class DeckCalculator {
+    dataProvider;
+    cardCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.cardCalculator = new CardCalculator(dataProvider);
+    }
+    async getDeck(deckId) {
+        const userDecks = await this.dataProvider.getUserData('userDecks');
+        return findOrThrow(userDecks, it => it.deckId === deckId);
+    }
+    async getDeckCards(userDeck) {
+        const userCards = await this.dataProvider.getUserData('userCards');
+        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
+        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
+    }
+    async getDeckCardsById(deckId) {
+        return await this.getDeckCards(await this.getDeck(deckId));
+    }
+    async getHonorBonusPower() {
+        const honors = await this.dataProvider.getMasterData('honors');
+        const userHonors = await this.dataProvider.getUserData('userHonors');
+        return userHonors
+            .map(userHonor => {
+            const honor = findOrThrow(honors, it => it.id === userHonor.honorId);
+            return findOrThrow(honor.levels, it => it.level === userHonor.level);
+        })
+            .reduce((v, it) => v + it.bonus, 0);
+    }
+    async getDeckDetailByCards(cardDetails, honorBonus) {
+        const map = new Map();
+        for (const cardDetail of cardDetails) {
+            computeWithDefault(map, cardDetail.attr, 0, it => it + 1);
+            cardDetail.units.forEach(key => { computeWithDefault(map, key, 0, it => it + 1); });
+        }
+        const power = cardDetails.reduce((v, cardDetail) => v + cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.power.get(unit, getOrThrow(map, unit), getOrThrow(map, cardDetail.attr))), 0), 0) + honorBonus;
+        const skill = cardDetails.map(cardDetail => {
+            const scoreUp = cardDetail.units.reduce((vv, unit) => Math.max(vv, cardDetail.scoreSkill.get(unit, getOrThrow(map, unit), 1)), 0);
+            return {
+                cardId: cardDetail.cardId,
+                scoreUp,
+                lifeRecovery: cardDetail.lifeSkill
+            };
+        });
+        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());
+    }
+    async getDeckDetailById(deckId) {
+        return await this.getDeckDetail(await this.getDeckCardsById(deckId));
+    }
+}
+
+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 EventCalculator {
+    dataProvider;
+    deckCalculator;
+    cardEventCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
+        this.cardEventCalculator = new CardEventCalculator(dataProvider);
+    }
+    async getDeckEventBonus(userDeck, eventId) {
+        const deckCards = await this.deckCalculator.getDeckCards(userDeck);
+        return await deckCards.reduce(async (v, it) => await v + await this.cardEventCalculator.getCardEventBonus(it, eventId), Promise.resolve(0));
+    }
+    async getDeckEventBonusById(deckId, eventId) {
+        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
+    }
+}
+
+class LiveCalculator {
+    dataProvider;
+    deckCalculator;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+        this.deckCalculator = new DeckCalculator(dataProvider);
+    }
+    getBaseScore(musicMeta, liveType) {
+        switch (liveType) {
+            case LiveType.SOLO:
+                return musicMeta.base_score;
+            case LiveType.MULTI:
+                return musicMeta.base_score + musicMeta.fever_score;
+            case LiveType.AUTO:
+                return musicMeta.base_score_auto;
+        }
+    }
+    getSkillScore(musicMeta, liveType) {
+        switch (liveType) {
+            case LiveType.SOLO:
+                return musicMeta.skill_score_solo;
+            case LiveType.MULTI:
+                return musicMeta.skill_score_multi;
+            case LiveType.AUTO:
+                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);
+        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;
+        const activeBonus = liveType === LiveType.MULTI ? 5 * 0.015 * powerSum : 0;
+        return {
+            score: Math.floor(rate * deckDetail.power * 4 + activeBonus),
+            time: musicMeta.music_time,
+            life: Math.min(2000, life + 1000),
+            tap: musicMeta.tap_count
+        };
+    }
+    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 };
+    }
+    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);
+    }
+    async getLiveDetailById(deckId, musicId, musicDiff, liveType, liveSkills = undefined) {
+        return await this.getLiveDetail(await this.deckCalculator.getDeckCardsById(deckId), musicId, musicDiff, liveType, liveSkills);
+    }
+}
+var LiveType;
+(function (LiveType) {
+    LiveType["SOLO"] = "solo";
+    LiveType["MULTI"] = "multi";
+    LiveType["AUTO"] = "auto";
+})(LiveType || (LiveType = {}));
+
+export { CardCalculator, CardDetailMap, DeckCalculator, EventCalculator, LiveCalculator, LiveType };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "sekai-calculator",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.es.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
   "files": [
-    "dist/index.js",
-    "dist/index.es.js",
+    "dist/index.cjs",
+    "dist/index.mjs",
     "dist/index.d.ts"
   ],
   "keywords": [

package/dist/index.es.js

@@ -1,75 +0,0 @@
-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 getDeck(deckId) {
-        const userDecks = await this.dataProvider.getUserData('userDecks');
-        return findOrThrow(userDecks, it => it.deckId === deckId);
-    }
-    async getDeckCards(userDeck) {
-        const userCards = await this.dataProvider.getUserData('userCards');
-        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
-        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
-    }
-    async getDeckCardsById(deckId) {
-        return await this.getDeckCards(await this.getDeck(deckId));
-    }
-}
-
-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');
-        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;
-    }
-    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));
-    }
-    async getDeckEventBonusById(deckId, eventId) {
-        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
-    }
-}
-
-export { EventCalculator };

package/dist/index.js

@@ -1,77 +0,0 @@
-'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 getDeck(deckId) {
-        const userDecks = await this.dataProvider.getUserData('userDecks');
-        return findOrThrow(userDecks, it => it.deckId === deckId);
-    }
-    async getDeckCards(userDeck) {
-        const userCards = await this.dataProvider.getUserData('userCards');
-        const cardIds = [userDeck.member1, userDeck.member2, userDeck.member3, userDeck.member4, userDeck.member5];
-        return cardIds.map(id => findOrThrow(userCards, it => it.cardId === id));
-    }
-    async getDeckCardsById(deckId) {
-        return await this.getDeckCards(await this.getDeck(deckId));
-    }
-}
-
-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');
-        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;
-    }
-    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));
-    }
-    async getDeckEventBonusById(deckId, eventId) {
-        return await this.getDeckEventBonus(await this.deckCalculator.getDeck(deckId), eventId);
-    }
-}
-
-exports.EventCalculator = EventCalculator;