haruki-sekai-deck-recommend-cpp 0.3.8__tar.gz → 0.4.2__tar.gz

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/.github/workflows/sonar.yml

@@ -50,7 +50,7 @@ jobs:
           python -m coverage run --source=tools/bench \
             -m unittest discover -s tests -p 'test_bench_tools.py'
           python -m coverage xml -o coverage-reports/python-coverage.xml
-          python -m unittest discover -s tests -p 'test_binding_smoke.py'
+          python -m unittest discover -s tests -p 'test_binding*.py'
           gcovr --root . --filter 'src/' \
             --exclude 'src/sekai_deck_recommend_wasm.cpp' \
             --lcov coverage-reports/lcov.info \

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.2
 Name: haruki-sekai-deck-recommend-cpp
-Version: 0.3.8
+Version: 0.4.2
 Requires-Python: >=3.10
 

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/npm/haruki-sekai-deck-recommend-cpp/index.d.ts

@@ -22,6 +22,7 @@ export type UnitType = "light_sound" | "idol" | "street" | "theme_park" | "schoo
 export type EventType = "marathon" | "cheerful_carnival" | "world_bloom"
 
 export type SkillChooseStrategy = "average" | "max" | "min"
+export type MultiUnitBonusEvaluation = "by_deck" | "force_on" | "force_off"
 
 export type SkillOrderChooseStrategy = SkillChooseStrategy | "specific"
 
@@ -113,6 +114,8 @@ export interface RecommendOptions {
   forcedLeaderCharacterId?: number
   skill_reference_choose_strategy?: SkillChooseStrategy
   keep_after_training_state?: boolean
+  /** How area item "multi_unit" effects (JP 7.0.0+) apply; default "by_deck". No effect without multi_unit rows. */
+  multi_unit_bonus_evaluation?: MultiUnitBonusEvaluation
   multi_live_teammate_score_up?: number
   multi_live_teammate_power?: number
   best_skill_as_leader?: boolean
@@ -161,6 +164,7 @@ export interface AreaItemRecommendOptions {
   userDataStr?: string
   user_data_file_path?: string
   userDataFilePath?: string
+  multi_unit_bonus_evaluation?: MultiUnitBonusEvaluation
   [key: string]: unknown
 }
 

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/npm/haruki-sekai-deck-recommend-cpp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haruki-sekai-deck-recommend-cpp",
-  "version": "0.3.8",
+  "version": "0.4.2",
   "description": "WebAssembly bindings for the Project Sekai deck recommendation engine.",
   "type": "module",
   "license": "LGPL-2.0-only",

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "haruki-sekai-deck-recommend-cpp"
-version = "0.3.8"
+version = "0.4.2"
 requires-python = ">=3.10"
 
 [tool.scikit-build]

haruki_sekai_deck_recommend_cpp-0.4.2/src/area-item-information/area-item-service.cpp

@@ -0,0 +1,81 @@
+#include "area-item-information/area-item-service.h"
+
+#include <algorithm>
+
+std::vector<AreaItemLevel> AreaItemService::getAreaItemLevels()
+{
+    auto& userAreas = this->dataProvider.userData->userAreas;
+    std::vector<AreaItemLevel> areaItemLevels{};
+    for (const auto& userArea : userAreas) {
+        for (const auto& areaItem : userArea.areaItems) {
+            auto rows = this->getAreaItemLevel(areaItem.areaItemId, areaItem.level);
+            areaItemLevels.insert(areaItemLevels.end(), rows.begin(), rows.end());
+        }
+    }
+    return areaItemLevels;
+}
+
+std::vector<AreaItemLevel> AreaItemService::getAreaItemLevel(int areaItemId, int level)
+{
+    auto& areaItemLevels = this->dataProvider.masterData->areaItemLevels;
+    int clampedLevel = std::min(level, this->getMaxAreaItemLevel(areaItemId));
+    // 客户端按(areaItemId, level)取出所有效果行后逐行结算，这里保持master中的顺序
+    std::vector<AreaItemLevel> rows{};
+    for (const auto& it : areaItemLevels) {
+        if (it.areaItemId == areaItemId && it.level == clampedLevel) {
+            rows.push_back(it);
+        }
+    }
+    if (rows.empty()) {
+        throw ElementNoFoundError("Area item level not found for areaItemId=" + std::to_string(areaItemId) + " level=" + std::to_string(level));
+    }
+    return rows;
+}
+
+int AreaItemService::getMaxAreaItemLevel(int areaItemId)
+{
+    auto& areaItemLevels = this->dataProvider.masterData->areaItemLevels;
+    int maxLevel = 0;
+    for (const auto& areaItemLevel : areaItemLevels) {
+        if (areaItemLevel.areaItemId == areaItemId) {
+            maxLevel = std::max(maxLevel, areaItemLevel.level);
+        }
+    }
+    if (maxLevel == 0) {
+        throw ElementNoFoundError("Area item levels not found for areaItemId=" + std::to_string(areaItemId));
+    }
+    return maxLevel;
+}
+
+std::vector<AreaItemLevel> AreaItemService::getAreaItemNextLevel(const AreaItem &areaItem, std::optional<int> currentLevel)
+{
+    // 如果没有给定当前等级，就按未购买算；如果已到当前master上限，下个等级仍为上限。
+    int maxLevel = this->getMaxAreaItemLevel(areaItem.id);
+    int level = currentLevel.has_value() ? std::min(currentLevel.value() + 1, maxLevel) : 1;
+    return this->getAreaItemLevel(areaItem.id, level);
+}
+
+int AreaItemService::getShopItemId(int areaItemId, int level)
+{
+    // 对照JP 7.0.0、JP 6.6.0、CN的shopItems/resourceBoxes验证过的规律：
+    // - 1-10级：1001起，每个道具10个
+    // - 11-15级：1551起，每个道具5个
+    // - 16-20级（6.6.0起）：1826起，每个道具5个
+    // - 56号道具（7.0.0起）单独编号：2101起
+    if (areaItemId == 56)
+        return 2100 + level;
+    if (level <= 10)
+        return 1000 + (areaItemId - 1) * 10 + level;
+    if (level <= 15)
+        return 1550 + (areaItemId - 1) * 5 + (level - 10);
+    return 1825 + (areaItemId - 1) * 5 + (level - 15);
+}
+
+ShopItem AreaItemService::getShopItem(int areaItemId, int level)
+{
+    auto& shopItems = this->dataProvider.masterData->shopItems;
+    int id = getShopItemId(areaItemId, level);
+    return findOrThrow(shopItems, [&](const ShopItem& it) {
+        return it.id == id;
+    }, [&]() { return "Shop item not found for areaItemId=" + std::to_string(areaItemId) + " level=" + std::to_string(level) + " shopItemId=" + std::to_string(id); } );
+}

haruki_sekai_deck_recommend_cpp-0.4.2/src/area-item-information/area-item-service.h

@@ -0,0 +1,55 @@
+#ifndef AREA_ITEM_SERVICE_H
+#define AREA_ITEM_SERVICE_H
+
+#include "data-provider/data-provider.h"
+
+class AreaItemService {
+
+    DataProvider dataProvider;
+
+public:
+    AreaItemService(const DataProvider& dataProvider) : dataProvider(dataProvider) {}
+
+    /**
+     * 获取用户纳入计算的区域道具效果
+     * 同一道具同一等级可能有多行效果（如7.0.0的56号道具：全角色加成+多组合加成），全部返回
+     */
+    std::vector<AreaItemLevel> getAreaItemLevels();
+
+    /**
+     * 获取对应等级的区域道具的所有效果行（等级超过当前master上限时按上限取）
+     * @param areaItemId 区域道具ID
+     * @param level 等级
+     */
+    std::vector<AreaItemLevel> getAreaItemLevel(int areaItemId, int level);
+
+    /**
+     * 获取区域道具在当前master中的最高等级
+     * @param areaItemId 区域道具ID
+     */
+    int getMaxAreaItemLevel(int areaItemId);
+
+    /**
+     * 获取下一级区域道具的所有效果行
+     * @param areaItem 区域道具
+     * @param currentLevel （可选）当前等级
+     */
+    std::vector<AreaItemLevel> getAreaItemNextLevel(const AreaItem& areaItem, std::optional<int> currentLevel = std::nullopt);
+
+    /**
+     * 获取区域道具等级对应的ShopItem
+     * 按理来说应该先去resourceBoxes中找到道具等级对应的ID，再通过resourceBoxId获取ShopItem
+     * 但是为了这么简单的需求获取一个11MB的resourceBoxes纯属想不开，所以用对照resourceBoxes验证过的规律推算
+     * @param areaItemId 区域道具ID
+     * @param level 等级
+     */
+    ShopItem getShopItem(int areaItemId, int level);
+
+    /**
+     * 区域道具等级对应的ShopItem ID（规律推算，见实现注释）
+     */
+    static int getShopItemId(int areaItemId, int level);
+
+};
+
+#endif // AREA_ITEM_SERVICE_H

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/src/area-item-recommend/area-item-recommend.cpp

@@ -14,7 +14,8 @@ int AreaItemRecommend::findCost(const ShopItem& shopItem, const std::string& res
 
 std::vector<CardDetail> AreaItemRecommend::getCardDetails(
     const std::vector<int>& cardIds,
-    const std::vector<AreaItemLevel>& areaItemLevels
+    const std::vector<AreaItemLevel>& areaItemLevels,
+    MultiUnitBonusEvaluation multiUnitEval
 )
 {
     std::vector<UserCard> userCards{};
@@ -28,16 +29,22 @@ std::vector<CardDetail> AreaItemRecommend::getCardDetails(
         {},
         {},
         std::nullopt,
-        areaItemLevels
+        areaItemLevels,
+        std::nullopt,
+        std::nullopt,
+        std::nullopt,
+        std::nullopt,
+        multiUnitEval
     );
 }
 
 int AreaItemRecommend::getDeckPower(
     const std::vector<int>& cardIds,
-    const std::vector<AreaItemLevel>& areaItemLevels
+    const std::vector<AreaItemLevel>& areaItemLevels,
+    MultiUnitBonusEvaluation multiUnitEval
 )
 {
-    auto cardDetails = getCardDetails(cardIds, areaItemLevels);
+    auto cardDetails = getCardDetails(cardIds, areaItemLevels, multiUnitEval);
     if (cardDetails.size() != cardIds.size()) {
         throw std::runtime_error("Failed to calculate all requested cards for area item recommendation");
     }
@@ -56,7 +63,8 @@ int AreaItemRecommend::getDeckPower(
         std::nullopt,
         SkillReferenceChooseStrategy::Average,
         true,
-        false
+        false,
+        multiUnitEval
     );
     if (deckDetails.empty()) {
         throw std::runtime_error("Failed to calculate deck power for area item recommendation");
@@ -64,14 +72,17 @@ int AreaItemRecommend::getDeckPower(
     return deckDetails.front().power.total;
 }
 
-std::vector<RecommendAreaItem> AreaItemRecommend::recommendAreaItem(const std::vector<int>& cardIds)
+std::vector<RecommendAreaItem> AreaItemRecommend::recommendAreaItem(
+    const std::vector<int>& cardIds,
+    MultiUnitBonusEvaluation multiUnitEval
+)
 {
     if (cardIds.empty() || cardIds.size() > 5) {
         throw std::invalid_argument("cardIds must contain 1 to 5 cards");
     }
 
     auto currentAreaItemLevels = areaItemService.getAreaItemLevels();
-    int currentPower = getDeckPower(cardIds, currentAreaItemLevels);
+    int currentPower = getDeckPower(cardIds, currentAreaItemLevels, multiUnitEval);
 
     std::vector<RecommendAreaItem> recommend{};
     for (const auto& areaItem : dataProvider.masterData->areaItems) {
@@ -80,27 +91,32 @@ std::vector<RecommendAreaItem> AreaItemRecommend::recommendAreaItem(const std::v
             currentAreaItemLevels.end(),
             [&](const AreaItemLevel& it) { return it.areaItemId == areaItem.id; }
         );
-        std::optional<AreaItemLevel> currentLevel = currentIt == currentAreaItemLevels.end()
+        std::optional<int> currentLevel = currentIt == currentAreaItemLevels.end()
             ? std::nullopt
-            : std::optional<AreaItemLevel>(*currentIt);
-        auto nextLevel = areaItemService.getAreaItemNextLevel(areaItem, currentLevel);
-        if (currentLevel.has_value() && nextLevel.level <= currentLevel->level) {
+            : std::optional<int>(currentIt->level);
+        auto nextLevelRows = areaItemService.getAreaItemNextLevel(areaItem, currentLevel);
+        int nextLevel = nextLevelRows.front().level;
+        if (currentLevel.has_value() && nextLevel <= currentLevel.value()) {
             continue;
         }
 
-        auto newAreaItemLevels = currentAreaItemLevels;
-        if (currentIt == currentAreaItemLevels.end()) {
-            newAreaItemLevels.push_back(nextLevel);
-        } else {
-            auto newIt = std::find_if(
-                newAreaItemLevels.begin(),
-                newAreaItemLevels.end(),
-                [&](const AreaItemLevel& it) { return it.areaItemId == areaItem.id; }
-            );
-            *newIt = nextLevel;
+        // 同一道具的所有效果行一起替换为下一级
+        std::vector<AreaItemLevel> newAreaItemLevels{};
+        newAreaItemLevels.reserve(currentAreaItemLevels.size() + nextLevelRows.size());
+        bool inserted = false;
+        for (const auto& it : currentAreaItemLevels) {
+            if (it.areaItemId != areaItem.id) {
+                newAreaItemLevels.push_back(it);
+            } else if (!inserted) {
+                newAreaItemLevels.insert(newAreaItemLevels.end(), nextLevelRows.begin(), nextLevelRows.end());
+                inserted = true;
+            }
+        }
+        if (!inserted) {
+            newAreaItemLevels.insert(newAreaItemLevels.end(), nextLevelRows.begin(), nextLevelRows.end());
         }
 
-        int power = getDeckPower(cardIds, newAreaItemLevels) - currentPower;
+        int power = getDeckPower(cardIds, newAreaItemLevels, multiUnitEval) - currentPower;
         if (power <= 0) {
             continue;
         }
@@ -108,7 +124,7 @@ std::vector<RecommendAreaItem> AreaItemRecommend::recommendAreaItem(const std::v
         auto& area = findOrThrow(dataProvider.masterData->areas, [&](const Area& it) {
             return it.id == areaItem.areaId;
         }, [&]() { return "Area not found for areaId=" + std::to_string(areaItem.areaId); });
-        auto shopItem = areaItemService.getShopItem(nextLevel);
+        auto shopItem = areaItemService.getShopItem(areaItem.id, nextLevel);
         RecommendAreaItemCost cost{
             .coin = findCost(shopItem, "coin", 0),
             .seed = findCost(shopItem, "material", 17),
@@ -119,7 +135,7 @@ std::vector<RecommendAreaItem> AreaItemRecommend::recommendAreaItem(const std::v
             .areaType = area.areaType,
             .areaViewType = area.viewType,
             .areaItemId = areaItem.id,
-            .nextLevel = nextLevel.level,
+            .nextLevel = nextLevel,
             .shopItemId = shopItem.id,
             .cost = cost,
             .power = power,

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/src/area-item-recommend/area-item-recommend.h

@@ -32,12 +32,14 @@ class AreaItemRecommend {
 
     std::vector<CardDetail> getCardDetails(
         const std::vector<int>& cardIds,
-        const std::vector<AreaItemLevel>& areaItemLevels
+        const std::vector<AreaItemLevel>& areaItemLevels,
+        MultiUnitBonusEvaluation multiUnitEval
     );
 
     int getDeckPower(
         const std::vector<int>& cardIds,
-        const std::vector<AreaItemLevel>& areaItemLevels
+        const std::vector<AreaItemLevel>& areaItemLevels,
+        MultiUnitBonusEvaluation multiUnitEval
     );
 
 public:
@@ -49,8 +51,13 @@ public:
 
     /**
      * Recommend the next area item upgrades for a fixed deck, sorted by power gain per coin.
+     * All effect rows of an area item level (e.g. item 56's all-character and multi_unit rows)
+     * are swapped together.
      */
-    std::vector<RecommendAreaItem> recommendAreaItem(const std::vector<int>& cardIds);
+    std::vector<RecommendAreaItem> recommendAreaItem(
+        const std::vector<int>& cardIds,
+        MultiUnitBonusEvaluation multiUnitEval = MultiUnitBonusEvaluation::ByDeck
+    );
 };
 
 #endif // AREA_ITEM_RECOMMEND_H

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/src/card-information/card-calculator.cpp

@@ -14,7 +14,8 @@ std::optional<CardDetail> CardCalculator::getCardDetail(
     std::optional<double> scoreUpLimit,
     const std::optional<std::vector<int>>& customBonusCharacterIds,
     const std::optional<int>& customBonusAttr,
-    const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits
+    const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits,
+    MultiUnitBonusEvaluation multiUnitEval
 )
 {
     const Card* cardPtr = this->dataProvider.masterData->findCardById(userCard.cardId);
@@ -41,9 +42,11 @@ std::optional<CardDetail> CardCalculator::getCardDetail(
     auto userCard0 = this->cardService.applyCardConfig(userCard, card, cfg);
     auto units = this->cardService.getCardUnits(card);
     auto skill = this->skillCalculator.getCardSkill(userCard0, card, scoreUpLimit);
+    std::vector<DeckCardPowerDetail> multiUnitPower{};
     auto power = this->powerCalculator.getCardPower(
         userCard0, card, units, userAreaItemLevels, hasCanvasBonus, userGateBonuses,
-        eventConfig.has_value() ? eventConfig->mysekaiFixtureLimit : std::nullopt
+        eventConfig.has_value() ? eventConfig->mysekaiFixtureLimit : std::nullopt,
+        multiUnitEval == MultiUnitBonusEvaluation::ForceOff ? nullptr : &multiUnitPower
     );
 
     CardEventBonusInfo eventBonus{};
@@ -89,7 +92,8 @@ std::optional<CardDetail> CardCalculator::getCardDetail(
         .episode1Read = episode1Read,
         .episode2Read = episode2Read,
         .afterTraining = afterTraining,
-        .defaultImage = userCard0.defaultImage
+        .defaultImage = userCard0.defaultImage,
+        .multiUnitPower = std::move(multiUnitPower)
     };
 }
 
@@ -102,7 +106,8 @@ std::vector<CardDetail> CardCalculator::batchGetCardDetail(
     std::optional<double> scoreUpLimit,
     const std::optional<std::vector<int>>& customBonusCharacterIds,
     const std::optional<int>& customBonusAttr,
-    const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits
+    const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits,
+    MultiUnitBonusEvaluation multiUnitEval
 )
 {
     std::vector<CardDetail> ret{};
@@ -118,7 +123,8 @@ std::vector<CardDetail> CardCalculator::batchGetCardDetail(
         details[i] = this->getCardDetail(
             userCards[i], areaItemLevels0, config, singleCardConfig, eventConfig,
             userCanvasBonusCards.find(userCards[i].cardId) != userCanvasBonusCards.end(),
-            userGateBonuses, scoreUpLimit, customBonusCharacterIds, customBonusAttr, customBonusSupportUnits
+            userGateBonuses, scoreUpLimit, customBonusCharacterIds, customBonusAttr, customBonusSupportUnits,
+            multiUnitEval
         );
     });
     for (auto& cardDetail : details) {

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/src/card-information/card-calculator.h

@@ -38,8 +38,19 @@ struct CardDetail {
     bool episode2Read;
     bool afterTraining;
     int defaultImage;
+    // 多组合编成（区域道具multi_unit效果生效）时的综合力，按multiUnitPowerIndex索引；
+    // 用户区域道具没有multi_unit效果或指定force_off时为空
+    std::vector<DeckCardPowerDetail> multiUnitPower{};
 };
 
+// CardService::getCardUnits的顺序为[支援组合(可选), 角色组合]
+inline int getCardCharacterUnit(const CardDetail& card) {
+    return card.units.back();
+}
+inline int getCardSupportUnit(const CardDetail& card) {
+    return card.units.size() > 1 ? card.units.front() : Enums::Unit::none;
+}
+
 struct SupportDeckCard {
     int cardId;
     double bonus;
@@ -95,7 +106,8 @@ public:
         std::optional<double> scoreUpLimit = std::nullopt,
         const std::optional<std::vector<int>>& customBonusCharacterIds = std::nullopt,
         const std::optional<int>& customBonusAttr = std::nullopt,
-        const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits = std::nullopt
+        const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits = std::nullopt,
+        MultiUnitBonusEvaluation multiUnitEval = MultiUnitBonusEvaluation::ByDeck
     );
 
     /**
@@ -105,6 +117,7 @@ public:
      * @param eventConfig 活动设置
      * @param areaItemLevels （可选）纳入计算的区域道具等级
      * @param scoreUpLimit 终章应用的技能加分上限
+     * @param multiUnitEval 多组合加成判定方式（force_off时不计算多组合综合力表）
      */
     std::vector<CardDetail> batchGetCardDetail(
         const std::vector<UserCard>& userCards,
@@ -115,7 +128,8 @@ public:
         std::optional<double> scoreUpLimit = std::nullopt,
         const std::optional<std::vector<int>>& customBonusCharacterIds = std::nullopt,
         const std::optional<int>& customBonusAttr = std::nullopt,
-        const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits = std::nullopt
+        const std::optional<std::unordered_map<int, int>>& customBonusSupportUnits = std::nullopt,
+        MultiUnitBonusEvaluation multiUnitEval = MultiUnitBonusEvaluation::ByDeck
     );
 
     /**

{haruki_sekai_deck_recommend_cpp-0.3.8 → haruki_sekai_deck_recommend_cpp-0.4.2}/src/card-information/card-power-calculator.cpp

@@ -10,7 +10,8 @@ CardDetailMap<DeckCardPowerDetail> CardPowerCalculator::getCardPower(
     const std::vector<AreaItemLevel> &userAreaItemLevels, 
     bool hasCanvasBonus, 
     const std::vector<MysekaiGateBonus> &userGateBonuses,
-    std::optional<int> fixtureBonusLimit
+    std::optional<int> fixtureBonusLimit,
+    std::vector<DeckCardPowerDetail>* multiUnitPower
 )
 {
     auto ret = CardDetailMap<DeckCardPowerDetail>();
@@ -32,6 +33,38 @@ CardDetailMap<DeckCardPowerDetail> CardPowerCalculator::getCardPower(
         power = getPower(card, basePower, characterBonus, fixtureBonus, gateBonus, userAreaItemLevels, unit, false, false);
         ret.set(unit, 1, 1, power.total, power);
     }
+
+    bool hasMultiUnitEffect = std::any_of(userAreaItemLevels.begin(), userAreaItemLevels.end(), [](const AreaItemLevel& it) {
+        return it.targetUnit == Enums::Unit::multi_unit;
+    });
+    if (multiUnitPower != nullptr && hasMultiUnitEffect) {
+        // getCardUnits: [支援组合(可选), 角色组合]
+        int characterUnit = cardUnits.back();
+        int supportUnit = cardUnits.size() > 1 ? cardUnits.front() : Enums::Unit::none;
+        int base = sumPower(basePower);
+        multiUnitPower->assign(MULTI_UNIT_POWER_SIZE, DeckCardPowerDetail{});
+        for (int mask = 0; mask < MULTI_UNIT_POWER_SIZE; ++mask) {
+            bool characterUnitAllMatch = mask & 4;
+            bool supportUnitAllMatch = mask & 2;
+            bool attrAllMatch = mask & 1;
+            int areaItemBonus = getMultiUnitAreaItemBonusPower(
+                userAreaItemLevels, basePower, card, characterUnit, supportUnit,
+                characterUnitAllMatch, supportUnitAllMatch, attrAllMatch
+            );
+            auto& power = (*multiUnitPower)[multiUnitPowerIndex(characterUnitAllMatch, supportUnitAllMatch, attrAllMatch)];
+            power = DeckCardPowerDetail{
+                base,
+                areaItemBonus,
+                characterBonus,
+                fixtureBonus,
+                gateBonus,
+                base + areaItemBonus + characterBonus + fixtureBonus + gateBonus
+            };
+            // 多组合加成不会让综合力降低，实际只会放宽上界；下界也一并纳入以保证剪枝在任意master数据下都成立
+            ret.max = std::max(ret.max, power.total);
+            ret.min = std::min(ret.min, power.total);
+        }
+    }
     return ret;
 }
 
@@ -138,6 +171,112 @@ int CardPowerCalculator::getAreaItemBonusPower(const std::vector<AreaItemLevel>
     return total;
 }
 
+int CardPowerCalculator::getMultiUnitAreaItemBonusPower(
+    const std::vector<AreaItemLevel> &userAreaItemLevels,
+    const BasePower &basePower,
+    const Card &card,
+    int characterUnit,
+    int supportUnit,
+    bool characterUnitAllMatch,
+    bool supportUnitAllMatch,
+    bool attrAllMatch
+)
+{
+    // 与客户端CardUtility.GetAreaItemBuffList(isMultiUnitDeck=true)一致：
+    // 每行效果归入一个桶（角色/多组合/组合/支援组合/属性/全体），
+    // 组合与支援组合同时存在时去掉三维比率和较小的一个（相等保留组合），
+    // 之后若有多组合加成：剩下的组合桶的全员匹配额外加成>=多组合加成则去掉多组合加成，
+    // 否则该组合桶回退为普通比率。决策用float比率（与客户端一致），最终加成仍按行累加后逐维向下取整。
+    enum Bucket : int { None = 0, Character, Multi, UnitBucket, SupportBucket, AttrBucket, AnyBucket, BucketCount };
+    struct RowPick {
+        Bucket bucket;
+        bool allMatch;
+    };
+    // Explicit aggregate initialization also works with MSVC local types.
+    std::vector<RowPick> picks(userAreaItemLevels.size(), RowPick{None, false});
+    std::array<std::array<float, 3>, BucketCount> buff{};
+    std::array<std::array<float, 3>, BucketCount> baseBuff{};
+    std::array<bool, BucketCount> present{};
+
+    for (size_t i = 0; i < userAreaItemLevels.size(); ++i) {
+        const auto& it = userAreaItemLevels[i];
+        RowPick pick{None, false};
+        if (it.targetGameCharacterId != 0) {
+            if (it.targetGameCharacterId == card.characterId)
+                pick.bucket = Character;
+        } else if (it.targetUnit == Enums::Unit::multi_unit) {
+            pick.bucket = Multi;
+        } else if (it.targetUnit != Enums::Unit::any) {
+            if (it.targetUnit == characterUnit) {
+                pick = {UnitBucket, characterUnitAllMatch};
+            } else if (supportUnit != Enums::Unit::none && it.targetUnit == supportUnit) {
+                pick = {SupportBucket, supportUnitAllMatch};
+            }
+        } else if (it.targetCardAttr != Enums::Attr::any) {
+            if (it.targetCardAttr == card.attr)
+                pick = {AttrBucket, attrAllMatch};
+        } else {
+            pick.bucket = AnyBucket;
+        }
+        picks[i] = pick;
+        if (pick.bucket == None)
+            continue;
+        float normal[3] = {float(it.power1BonusRate), float(it.power2BonusRate), float(it.power3BonusRate)};
+        float allMatch[3] = {float(it.power1AllMatchBonusRate), float(it.power2AllMatchBonusRate), float(it.power3AllMatchBonusRate)};
+        present[pick.bucket] = true;
+        for (int k = 0; k < 3; ++k) {
+            buff[pick.bucket][k] += pick.allMatch ? allMatch[k] : normal[k];
+            baseBuff[pick.bucket][k] += normal[k];
+        }
+    }
+
+    auto sum3 = [](const std::array<float, 3>& v) { return (v[0] + v[1]) + v[2]; };
+    std::array<bool, BucketCount> dropped{};
+    std::array<bool, BucketCount> useBaseRate{};
+    if (present[UnitBucket] && present[SupportBucket]) {
+        if (sum3(buff[UnitBucket]) < sum3(buff[SupportBucket]))
+            dropped[UnitBucket] = true;
+        else
+            dropped[SupportBucket] = true;
+    }
+    if (present[Multi]) {
+        Bucket k = None;
+        if (present[UnitBucket] && !dropped[UnitBucket])
+            k = UnitBucket;
+        else if (present[SupportBucket] && !dropped[SupportBucket])
+            k = SupportBucket;
+        if (k != None) {
+            float extra = ((buff[k][0] - baseBuff[k][0]) + (buff[k][1] - baseBuff[k][1])) + (buff[k][2] - baseBuff[k][2]);
+            if (extra >= sum3(buff[Multi]))
+                dropped[Multi] = true;
+            else
+                useBaseRate[k] = true;
+        }
+    }
+
+    double areaItemBonus[3] = {0, 0, 0};
+    for (size_t i = 0; i < userAreaItemLevels.size(); ++i) {
+        const auto& pick = picks[i];
+        if (pick.bucket == None || dropped[pick.bucket])
+            continue;
+        const auto& it = userAreaItemLevels[i];
+        bool allMatch = pick.allMatch && !useBaseRate[pick.bucket];
+        double rates[3] = {
+            allMatch ? it.power1AllMatchBonusRate : it.power1BonusRate,
+            allMatch ? it.power2AllMatchBonusRate : it.power2BonusRate,
+            allMatch ? it.power3AllMatchBonusRate : it.power3BonusRate,
+        };
+        for (int k = 0; k < 3; ++k) {
+            areaItemBonus[k] += rates[k] * 0.01 * basePower[k];
+        }
+    }
+    int total = 0;
+    for (int k = 0; k < 3; ++k) {
+        total += std::floor(areaItemBonus[k]);
+    }
+    return total;
+}
+
 int CardPowerCalculator::getCharacterBonusPower(const BasePower &basePower, int characterId)
 {
     auto& userCharacters = dataProvider.userData->userCharacters;
@@ -178,15 +317,28 @@ int CardPowerCalculator::getFixtureBonusPower(const BasePower &basePower, int ch
 
 int CardPowerCalculator::getGateBonusPower(const BasePower &basePower, const std::vector<MysekaiGateBonus> &userGateBonuses, const std::vector<int> &cardUnits)
 {
-    bool isOnlyPiapro = cardUnits.size() == 1 && cardUnits[0] == Enums::Unit::piapro;
-    double powerBonusRate = 0;
+    // 与客户端CardUtility.GetGateBonus一致：
+    // 加成组合 = 支援组合（有的话），否则为角色原组合（getCardUnits保证它在cardUnits[0]）。
+    // - 非piapro：只看该组合的大门
+    // - piapro（无支援组合的V）：取等级最高的大门（同等级取用户数据中靠前的，与稳定排序一致），
+    //   即使该大门没有等级行（加成为0）也不会换成其他大门
+    if (cardUnits.empty())
+        return 0;
+    int unit = cardUnits[0];
+    const MysekaiGateBonus* selected = nullptr;
     for (auto& bonus : userGateBonuses) {
-        if (isOnlyPiapro || std::find(cardUnits.begin(), cardUnits.end(), bonus.unit) != cardUnits.end()) {
-            powerBonusRate = std::max(powerBonusRate, bonus.powerBonusRate);
+        if (unit == Enums::Unit::piapro) {
+            if (selected == nullptr || bonus.level > selected->level)
+                selected = &bonus;
+        } else if (bonus.unit == unit) {
+            selected = &bonus;
+            break;
         }
     }
+    if (selected == nullptr)
+        return 0;
     // 按各个综合分别计算加成，其中powerBonusRate单位是1%
-    double total = sumPower(basePower) * powerBonusRate * 0.01;
+    double total = sumPower(basePower) * selected->powerBonusRate * 0.01;
     return std::floor(total);
 }