#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerOnline
#
# @todo:ÔÚÏßÍæ¼Ò¹ÜÀí
# @author hxp
# @date 2025-07-02
# @version 1.0
#
# ÏêϸÃèÊö: ÔÚÏßÍæ¼Ò¹ÜÀí£¬ÓÃÓÚ¹ÜÀíÔÚÏßÍæ¼Ò¡¢×¼ÔÚÏßÍæ¼ÒµÄÁÙʱÊý¾Ý£¬ÖضÁ²»»á±»ÖØÖÃ
#         ×¼ÔÚÏßÍæ¼Ò - ʵ¼Ê²»ÔÚÏߣ¬x·ÖÖÓÄÚÀëÏßµÄÍæ¼Ò£¬ÓÃÓÚÖ§³Ö¶ÏÏßÖØÁ¬£¬¶Ìʱ¼äÄÚÁÙʱÊý¾Ý¿É³ÖÐø
#
#-------------------------------------------------------------------------------
#"""Version = 2025-07-02 17:30"""
#-------------------------------------------------------------------------------

import BattleObj
import TurnAttack
import PyGameData
import ShareDefine
import PlayerControl
import IpyGameDataPY
import FormulaControl
import PlayerPrestigeSys
import GameLogic_Dingjunge
import PlayerBeauty
import PlayerFamily
import PlayerHorse
import PlayerGubao
import PlayerHero
import PlayerHJG
import GameWorld
import ChConfig
import ChEquip

import time

class LineupHero():
    ## ÕóÈÝÎ佫£¬×¢Ò⣺ͬһ¸öÎ佫ÔÚ²»Í¬ÕóÈÝÖпÉÄÜÊôÐÔ²»Ò»Ñù
    
    def __init__(self):
        self.Clear()
        return
    
    def Clear(self):
        self.itemIndex = 0
        self.heroID = 0
        self.skinID = 0
        self.posNum = 0
        self.heroBatAttrDict = {} # Î佫µÄ×îÖÕÕ½¶·ÊôÐÔ×ֵ䣬 {attrID:value, ...}
        self.heroSkillIDList = [] # Î佫ӵÓеļ¼ÄÜIDÁбí [skillID, ...]
        self.fightPower = 0 # Î佫×îÖÕÕ½Á¦
        self.skillFightPower = 0 # ¼¼ÄÜÕ½Á¦
        return
    
class Lineup():
    ## ÕóÈÝ
    
    def __init__(self, playerID, lineupID, exclusiveMapID=0):
        self.playerID = playerID
        self.lineupID = lineupID
        self.exclusiveMapID = exclusiveMapID # ´óÓÚ0ʱ´ú±íÊÇij¸ö¹¦ÄܵØͼרÓã¬È綨¾ü¸ó£¬ÕóÈÝÓëÖ÷ÕóÈÝÏàͬ£¬Ö»ÊÇÊôÐÔ¡¢Õ½Á¦¿ÉÄܲ»Ò»Ñù
        self.olPlayer = None
        self.shapeType = 0
        self.heroItemDict = {} # ÕóÈÝÎ佫±³°üË÷ÒýÐÅÏ¢  {itemIndex:posNum, ...}
        self.lineupChange = False # ÊÇ·ñÒѱä¸üÕóÈݱê¼Ç£¬ÔÚË¢ÐÂÊôÐÔºóÖØÖñê¼Ç
        self.__refreshState = 0 # Ë¢ÊôÐÔ±ê¼Ç£¬ 0-²»ÐèҪˢÐÂÁË£¬1-ÐèҪˢÐÂ
        
        self.__freeLineupHeroObjs = [] # ÊͷŵĿÕÏжÔÏó[LineupHero, ...]
        self.__lineupHeroDict = {} # Ë¢ÐÂÕóÈݺóµÄÎ佫ÐÅÏ¢ {posNum:LineupHero, ...}
        self.fightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
        return
    
    def UpdLineup(self, heroItemDict, shapeType=0, refreshForce=False, isReload=False):
        '''±ä¸üÕóÈÝʱ¸üÐÂ
        @param heroItemDict: Î佫±³°üË÷ÒýÐÅÏ¢  {itemIndex:posNum, ...}
        @param shapeType: ÕóÐÍ
        @param refreshForce: ÊÇ·ñÇ¿ÖÆË¢ÊôÐÔ
        '''
        if not isReload: # ·ÇÖضÁÕóÈݵÄÊÓΪ±ä¸ü
            self.lineupChange = True
        self.shapeType = shapeType
        self.heroItemDict = heroItemDict
        GameWorld.DebugLog("¸üÐÂÕóÈÝ: lineupID=%s,exclusiveMapID=%s,%s" % (self.lineupID, self.exclusiveMapID, heroItemDict), self.playerID)
        self.RefreshLineupAttr(refreshForce)
        if not isReload and self.olPlayer.curPlayer and not self.exclusiveMapID:
            PlayerHero.Sync_Lineup(self.olPlayer.curPlayer, self.lineupID)
        return
    
    def IsEmpty(self): return (not self.__lineupHeroDict or not self.heroItemDict)
    
    def GetPosNumList(self): return self.__lineupHeroDict.keys()
    
    def FreeLineupHero(self):
        ## ÊÍ·ÅÕóÈÝÎ佫¶ÔÏó£¬ÖØмÆËã
        for freeObj in self.__lineupHeroDict.values():
            if freeObj not in self.__freeLineupHeroObjs:
                self.__freeLineupHeroObjs.append(freeObj)
        self.__lineupHeroDict = {}
        self.fightPower = 0
        return
    
    def GetLineupHero(self, posNum):
        lineupHero = None
        if posNum in self.__lineupHeroDict:
            lineupHero = self.__lineupHeroDict[posNum]
        elif self.__freeLineupHeroObjs:
            lineupHero = self.__freeLineupHeroObjs.pop(0)
            lineupHero.Clear()
            self.__lineupHeroDict[posNum] = lineupHero
        else:
            lineupHero = LineupHero()
            self.__lineupHeroDict[posNum] = lineupHero
        return lineupHero
    
    def GetLineupHeroByID(self, heroID):
        lineupHero = None
        for posNum in self.__lineupHeroDict.keys():
            lineupHero = self.GetLineupHero(posNum)
            if lineupHero.heroID == heroID:
                return lineupHero
        if False:
            lineupHero = LineupHero()
        return lineupHero
    
    def SetNeedRefreshState(self):
        ## ÉèÖÃÐèҪˢÊôÐÔ
        self.__refreshState = 1
        return
    
    def RefreshLineupAttr(self, refreshForce=False):
        self.__refreshState = 1 # ±ê¼ÇҪˢÐÂ
        if refreshForce:
            self.CheckRefreshLineupAttr()
        return
    
    def CheckRefreshLineupAttr(self):
        ## ¼ì²éË¢ÐÂÕóÈÝÊôÐÔ
        if not self.__refreshState:
            return False
        self.__refreshState = 0
        doRefreshLineupAttr(self.olPlayer.curPlayer, self.olPlayer, self)
        self.lineupChange = False
        return True
    
    def CheckHeroItemUpdate(self, itemIndex):
        if itemIndex not in self.heroItemDict:
            return
        self.RefreshLineupAttr()
        return True
    
class OnlinePlayer():
    ## Íæ¼ÒÔÚÏßÁÙʱÊý¾Ý£¬Ö÷ҪʱÊý¾ÝµÄ»º´æ£¬Âß¼­¿É²»ÔÚÀàÖд¦Àí£¬·½±ãÖضÁ½Å±¾Ê±²âÊÔ
    
    def __init__(self, playerID):
        self.playerID = playerID
        self.curPlayer = None
        
        # ÊôÐÔ¡¢ÕóÈÝ
        self._calcAttrDict = {} # ¹¦ÄܵãÊôÐÔͳ¼Æ {calcIndex:{attrID:value, ...}, ...}
        self._calcSpecEffDict = {} # ¹¦ÄܵãÌØÊâЧ¹ûͳ¼Æ {calcIndex:effInfo, ...}
        self._lineupDict = {} # ÉÏÕóÕóÈÝ {lineKey:Lineup, ...}   lineKey Ϊ lineupID »òÕß (lineupID, exclusiveMapID)
        self._effectiveCardDict = {} # ¼Ó³ÉÊôÐÔÉúЧµÄÎ佫¿¨ÅÆÐÅÏ¢ {heroID:[cardAddPer, itemIndex, inMain], ...}
        
        # Ö÷ÏßÕ½¶·
        self.mainFight = TurnAttack.MainFight(playerID)
        
        self._lastBatBufferInfo = [] # ×îºóÒ»³¡Õ½¶·ÁÙʱ»Ø·Å ["guid", "buffer"]
        return
    
    def OnClear(self):
        self.mainFight.turnFight.exitFight()
        return
    
    def SetPlayer(self, curPlayer):
        self.curPlayer = curPlayer
        self.mainFight.turnFight.curPlayer = curPlayer
        return
    
    def IsRealOnline(self):
        ## ÊÇ·ñÕæµÄÔÚÏß
        return self.curPlayer != None
    
    def GetLineup(self, lineupID, checkAttr=True, exclusiveMapID=0):
        # @param checkAttr: ¼ì²éˢе½×îÐÂÕóÈÝÊôÐÔ
        lineup = None
        lineKey = lineupID
        if exclusiveMapID:
            if exclusiveMapID in ChConfig.ExclusiveBatAttrMapIDList:
                lineKey = (lineupID, exclusiveMapID)
            else:
                exclusiveMapID = 0
        if lineKey in self._lineupDict:
            lineup = self._lineupDict[lineKey]
        else:
            lineup = Lineup(self.playerID, lineupID, exclusiveMapID)
            self._lineupDict[lineKey] = lineup
        lineup.olPlayer = self
        if checkAttr:
            lineup.CheckRefreshLineupAttr()
        return lineup
    
    def GetHeroEffectiveCard(self, heroID): return self._effectiveCardDict.get(heroID, [-1, -1, False])
    def SetHeroEffectiveCard(self, heroID, cardAddPer, itemIndex, inMain):
        ## ¸üÐÂij¸öÎ佫ÉúЧµÄ¿¨ÅÆÐÅÏ¢
        self._effectiveCardDict[heroID] = [cardAddPer, itemIndex, inMain]
        self.RefreshRoleAttr()
        
    def SetEffectiveCardDict(self, effectiveCardDict): self._effectiveCardDict = effectiveCardDict
    def GetEffectiveCardDict(self): return self._effectiveCardDict
    
    def GetCalcSpecInfo(self, calcIndex): return self._calcSpecEffDict.get(calcIndex, {})
    def GetCalcAttr(self, calcIndex): return self._calcAttrDict.get(calcIndex, {})
    def SetCalcAttr(self, calcIndex, attrDict, specEffInfo=None):
        ## ÉèÖÃij¸ö¹¦Äܵã¼ÆËãµÄÊôÐÔ
        # @param specEffDict: ÌØÊâЧ¹û»º´æ£¬¹¦ÄÜ×Ô¶¨ÒåÊý¾Ý½á¹¹
        self._calcAttrDict[calcIndex] = attrDict
        if specEffInfo != None:
            self._calcSpecEffDict[calcIndex] = specEffInfo
        return
    
    def ReCalcAllAttr(self):
        ## ÖØÖÃËùÓй¦Äܵã¼ÆËãµÄÊôÐÔ£¬Ò»°ãµÇ¼µÄʱºòµ÷ÓÃÒ»´Î¼´¿É£¬ÆäËûµ¥¹¦ÄÜˢеĻ°Ò»°ãʹÓà RefreshRoleAttr
        curPlayer = self.curPlayer
        GameWorld.DebugLog("ReCalcAllAttr...", self.playerID)
        
        self._calcAttrDict = {}
        self._calcSpecEffDict = {}
        self._lineupDict = {}
        self._effectiveCardDict = {}
        
        doCalcAllAttr(curPlayer)
        doReloadLineup(curPlayer, self)
        reloadEffHeroCard(curPlayer, self)
        
        self.RefreshRoleAttr()
        return
    
    def RefreshRoleAttr(self, refreshForce=False, isAllLineup=False, exclusiveMapID=0):
        '''Ë¢ÐÂÖ÷¹«ÊôÐÔ£¬Ó°ÏìÖ÷¹«ÊôÐԵŦÄܵãÊôÐԱ仯ʱͳһµ÷Óô˺¯Êý
        @param refreshForce: ÊÇ·ñÇ¿ÖÆÁ¢ÂíË¢ÐÂ
        @param isAllLineup: ÊÇ·ñֻͬ²½Ë¢ËùÓÐÕóÈÝÊôÐÔ£¬Èç¹ûÉèÖÃFalseÔòĬÈϽöË¢Ö÷ÕóÈÝÊôÐÔ
        '''
        GameWorld.DebugLog("ÇëÇóË¢ÊôÐÔ: refreshForce=%s" % (refreshForce), self.playerID)
        # Ö÷¹«ÊôÐÔË¢ÐÂʱ£¬ËùÓÐÕóÈݶ¼ÒªÍ¬²½Ë¢ÐÂ
        for lineup in self._lineupDict.values():
            if exclusiveMapID and lineup.exclusiveMapID != exclusiveMapID:
                # ÓÐÖ¸¶¨µÄ»°Ö»ÒªÖ¸¶¨µÄ¼´¿É
                continue
            lineup.SetNeedRefreshState()
            
        if refreshForce:
            self.DoRefreshRoleAttr(isAllLineup, exclusiveMapID)
        return
    
    def DoRefreshRoleAttr(self, isAllLineup=False, exclusiveMapID=0):
        '''Ö´ÐÐË¢ÊôÐÔ£¬Ä¬È϶îÍâË¢Ö÷ÕóÈÝ£¬ÆäËûÕóÈÝ¿ÉÒÔÓõ½µÄʱºòÔÙË¢ÐÂ
        @param isAllLineup: ÊÇ·ñË¢ËùÓÐÕóÈÝ£¬Èç¹ûÉèÖÃFalseÔòĬÈϽöË¢Ö÷ÕóÈÝÊôÐÔ
        @return: ÊÇ·ñÓÐË¢ÊôÐÔ£¬0-ÎÞ£»1-ÓÐ
        '''
        
        isRefresh = False
        # ͬ²½Ö´ÐÐÕóÈÝÊôÐÔË¢ÐÂ
        for lineup in self._lineupDict.values():
            if not isAllLineup:
                # ÓÐÖ¸¶¨µÄ»°Ö»ÒªÖ¸¶¨µÄ¼´¿É
                if exclusiveMapID:
                    if lineup.exclusiveMapID != exclusiveMapID:
                        continue
                    
                # ·ñÔòֻˢÖ÷ÕóÈÝ£¬Ö¸¶¨µØͼÓÐЧµÄÒ²²»ÐèҪˢ
                elif lineup.lineupID != ShareDefine.Lineup_Main or lineup.exclusiveMapID != 0:
                    continue
            if lineup.CheckRefreshLineupAttr():
                isRefresh = True
                
        return isRefresh
    
    def OnHeroItemUpate(self, heroItem):
        '''Î佫ÎïÆ·±ä»¯Ê±ÐèÒª´¦ÀíµÄÂß¼­
        @param heroItem: ±ä»¯Î佫ÎïÆ·
        @param return: Ó°ÏìµÄÕóÈÝIDÁбí
        '''
        effLineupIDList = []
        
        checkUpdEffHeroCard(self, heroItem) # ¼ì²é¸üÐÂÉúЧµÄ¿¨ÅÆ
        
        itemIndex = heroItem.GetItemPlaceIndex()
        for lineKey, lineup in self._lineupDict.items():
            if lineup.CheckHeroItemUpdate(itemIndex):
                if lineKey not in effLineupIDList:
                    effLineupIDList.append(lineKey)
                    
        GameWorld.DebugLog("Î佫ÎïÆ·±ä»¯: itemIndex=%s, Ó°ÏìÕóÈÝ:%s" % (itemIndex, effLineupIDList), self.playerID)
        return
    
    def GetLastBatBuffer(self): return self._lastBatBufferInfo
    def SetLastBatBuffer(self, guid, batBuffer):
        self._lastBatBufferInfo = [guid, batBuffer]
        return
    
class OnlineMgr():
    ## ×¼ÔÚÏßÍæ¼Ò¹ÜÀí
    
    def __init__(self):
        self.__onlinePlayerDict = {} # ×¼ÔÚÏßÍæ¼ÒÁÙʱÊý¾Ý×Öµä {playerID:OnlinePlayer, ...}
        self.__offlinePlayerTimeDict = {} # ×¼ÔÚÏßÍæ¼ÒÁÙʱÀëÏßʱ¼ä´Á {playerID:ÀëÏßʱ¼ä´Á, ...}
        return
    
    def GetOnlinePlayer(self, curPlayer):
        olPlayer = None
        playerID = curPlayer.GetPlayerID()
        if playerID in self.__onlinePlayerDict:
            olPlayer = self.__onlinePlayerDict[playerID]
        else:
            olPlayer = OnlinePlayer(playerID)
            self.__onlinePlayerDict[playerID] = olPlayer
        olPlayer.SetPlayer(curPlayer)
        return olPlayer
    
    def SetPlayerOnline(self, curPlayer):
        ## ÉèÖÃÍæ¼ÒÔÚÏß
        playerID = curPlayer.GetPlayerID()
        self.__offlinePlayerTimeDict.pop(playerID, None)
        if playerID not in self.__onlinePlayerDict:
            olPlayer = OnlinePlayer(playerID)
            self.__onlinePlayerDict[playerID] = olPlayer
        else:
            olPlayer = self.__onlinePlayerDict[playerID]
        olPlayer.SetPlayer(curPlayer)
        return
    
    def SetPlayerOffline(self, curPlayer):
        ## ÉèÖÃÍæ¼ÒÀëÏß
        playerID = curPlayer.GetPlayerID()
        if playerID not in self.__onlinePlayerDict:
            return
        olPlayer = self.__onlinePlayerDict[playerID]
        olPlayer.SetPlayer(None)
        self.__offlinePlayerTimeDict[playerID] = int(time.time())
        return
    
    def ProcessOffline(self):
        ## ¶¨Ê±´¦ÀíÀëÏßÍæ¼Ò
        curTime = int(time.time())
        offlineTimes = 5 * 60 # 5·ÖÖÓºóÇå³ýÊý¾Ý
        for playerID, offlineTime in self.__offlinePlayerTimeDict.items():
            if curTime - offlineTime < offlineTimes:
                continue
            self.__offlinePlayerTimeDict.pop(playerID, None)
            if playerID not in self.__onlinePlayerDict:
                continue
            olPlayer = self.__onlinePlayerDict.pop(playerID, None)
            olPlayer.OnClear()
        return
    
def GetOnlineMgr():
    mgr = None
    if PyGameData.g_onlineMgr:
        mgr = PyGameData.g_onlineMgr
    else:
        mgr = OnlineMgr()
        PyGameData.g_onlineMgr = mgr
    return mgr

def GetOnlinePlayer(curPlayer): return GetOnlineMgr().GetOnlinePlayer(curPlayer)

def OnPlayerLogin(curPlayer):
    ## ÐèµÇ¼Âß¼­×îÔçµ÷ÓÃ
    GetOnlineMgr().SetPlayerOnline(curPlayer)
    return

def OnPlayerLogoff(curPlayer):
    ## ÐèÏÂÏßÂß¼­×îºóµ÷ÓÃ
    GetOnlineMgr().SetPlayerOffline(curPlayer)
    return

def OnMinute():
    GetOnlineMgr().ProcessOffline()
    return

def CalcRoleBase(curPlayer):
    playerID = curPlayer.GetID()
    playerLV = curPlayer.GetLV()
    lvIpyData = PlayerControl.GetPlayerLVIpyData(playerLV)
    
    lvAttrDict = {}
    if lvIpyData:
        lvAttrDict = {ChConfig.AttrID_Atk:lvIpyData.GetAtk(),
                    ChConfig.AttrID_Def:lvIpyData.GetDef(),
                    ChConfig.AttrID_MaxHP:lvIpyData.GetMaxHP()
                    }
        
    GameWorld.DebugLog("½ÇÉ«µÈ¼¶ÊôÐÔ: %s" % lvAttrDict, playerID)
    GetOnlinePlayer(curPlayer).SetCalcAttr(ChConfig.Def_CalcAttr_LV, lvAttrDict)
    return

def checkUpdEffHeroCard(olPlayer, heroItem, isNotify=True):
    ## Íæ¼ÒÎ佫±³°ü¿¨ÅƱä¸üʱµ÷ÓÃ
    # @return: ¼Ó³ÉÊÇ·ñ±ä¸ü 
    if not hasattr(heroItem, "GetItemPlaceIndex"):
        return
    curPlayer = olPlayer.curPlayer
    if not curPlayer:
        return
    itemIndex = heroItem.GetItemPlaceIndex()
    heroID = heroItem.GetItemTypeID()
    curAddPer = getHeroCardAddPer(heroItem)
    effAddPer, effItemIndex, inMain = olPlayer.GetHeroEffectiveCard(heroID)
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    hisEffItem = curPack.GetAt(effItemIndex) if curPack.GetCount() > effItemIndex else None
    if not hisEffItem or hisEffItem.IsEmpty():
        GameWorld.DebugLog("ÀúÊ·ÉúЧµÄÎïÆ·²»ÔÚÁË£¬Ç¿ÖÆÉèÖÿÕ! effAddPer=%s,effItemIndex=%s,inMain=%s" % (effAddPer, effItemIndex, inMain))
        effAddPer, effItemIndex, inMain = -1, -1, False
        
    if itemIndex == effItemIndex:
        if curAddPer == effAddPer:
            GameWorld.DebugLog("ÉúЧµÄ¿¨ÅƲ»±äÇÒ¼Ó³ÉÒ²²»±ä£¬²»Óô¦Àí! heroID=%s,itemIndex=%s,inMain=%s,effAddPer=%s,curAddPer=%s" % (heroID, itemIndex, inMain, effAddPer, curAddPer))
            return
        olPlayer.SetHeroEffectiveCard(heroID, curAddPer, itemIndex, inMain)
        if curAddPer > effAddPer:
            GameWorld.DebugLog("ÉúЧµÄ¿¨ÅƲ»±äÇÒ¼Ó³ÉÌáÉýÁË! heroID=%s,itemIndex=%s,inMain=%s,effAddPer=%s,curAddPer=%s" % (heroID, itemIndex, inMain, effAddPer, curAddPer))
            return
        if inMain:
            GameWorld.DebugLog("ÉúЧµÄ¿¨ÅÆЧ¹û¼Ó³É½µµÍÁË£¬µ«ÔÚÖ÷ÕóÈÝÖÐÒÀ¾É±£³ÖÉúЧ! heroID=%s,itemIndex=%s,inMain=%s,effAddPer=%s,curAddPer=%s" % (heroID, itemIndex, inMain, effAddPer, curAddPer))
            return
        GameWorld.DebugLog("ÉúЧµÄ¿¨ÅÆЧ¹û¼Ó³É½µµÍÁË£¬Î´ÔÚÖ÷ÕóÈÝÖÐÖØмìË÷ÊÇ·ñÓмӳɸü¸ßµÄ! heroID=%s,itemIndex=%s,inMain=%s,effAddPer=%s,curAddPer=%s" 
                           % (heroID, itemIndex, inMain, effAddPer, curAddPer))
        curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
        for index in range(curPack.GetCount()):
            if index == itemIndex:
                continue
            packItem = curPack.GetAt(index)
            if not packItem or packItem.IsEmpty():
                continue
            if heroID != packItem.GetItemTypeID():
                continue
            packCardPer = getHeroCardAddPer(packItem)
            if packCardPer <= curAddPer:
                continue
            GameWorld.DebugLog("Óиü¸ß¼Ó³ÉµÄͬÃûÎ佫! heroID=%s,index=%s,packCardPer=%s > curAddPer=%s" % (heroID, index, packCardPer, curAddPer))
            checkUpdEffHeroCard(olPlayer, packItem, isNotify)
            return
        
        GameWorld.DebugLog("ûÓиü¸ß¼Ó³ÉµÄͬÃûÎ佫£¬±£Áô±¾¿¨ÉúЧ! heroID=%s,itemIndex=%s,curAddPer=%s" % (heroID, itemIndex, curAddPer))
        return
    
    if inMain:
        GameWorld.DebugLog("ûÓÐÔÚÖ÷ÕóÈÝÖÐÇÒµ±Ç°ÉúЧµÄ¿¨ÅÆÔÚÖ÷ÕóÈÝÖв»´¦Àí! heroID=%s,effItemIndex=%s,itemIndex=%s" % (heroID, effItemIndex, itemIndex))
        return
    
    if curAddPer <= effAddPer:
        GameWorld.DebugLog("¶¼Ã»ÓÐÔÚÖ÷ÕóÈÝÖÐÇÒ²»¸ßÓÚµ±Ç°ÉúЧ¿¨ÅƼӳɲ»´¦Àí! heroID=%s,itemIndex=%s,curAddPer=%s <= %s,effItemIndex=%s" 
                           % (heroID, itemIndex, curAddPer, effAddPer, effItemIndex))
        return
    GameWorld.DebugLog("¶¼Ã»ÓÐÔÚÖ÷ÕóÈÝÖÐÇÒ¸ßÓÚµ±Ç°ÉúЧ¿¨ÅƼӳÉÌæ»»ÉúЧ¿¨ÅÆ! heroID=%s,itemIndex=%s,curAddPer=%s > %s,effItemIndex=%s" 
                       % (heroID, itemIndex, curAddPer, effAddPer, effItemIndex))
    olPlayer.SetHeroEffectiveCard(heroID, curAddPer, itemIndex, inMain)
    
    item = heroItem.GetItem()
    item.SetUserAttr(ShareDefine.Def_IudetHeroCardEffective, 1)
    isNotify and heroItem.Sync_Item()
    
    if effItemIndex >= 0:
        curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
        hisEffItem = curPack.GetAt(effItemIndex) if curPack.GetCount() > effItemIndex else None
        if hisEffItem and not hisEffItem.IsEmpty():
            item = hisEffItem.GetItem()
            item.SetUserAttr(ShareDefine.Def_IudetHeroCardEffective, 0)
            isNotify and hisEffItem.Sync_Item()
            
    return

def reloadEffHeroCard(curPlayer, olPlayer):
    ## ÖØмì²éÔØÈëÉúЧµÄ¿¨ÅÆ£¬Ò»°ãÓÃÓڱȽϸ´ÔÓµÄÇé¿ö£¬Ö±½ÓÖØбéÀúÒ»±é£¬ÈçµÇ¼ʱ¡¢ÖØб£´æÖ÷ÕóÈÝʱ
    hisEffCardIndexList = [] # ÀúÊ·ÉúЧµÄ¿¨ÅÆ [index, ...]
    updEffectiveCardDict = {} # ¸üÐÂÉúЧµÄ¿¨ÅÆ {heroID:[cardAddPer, itemIndex, inMain], ...}
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    for index in range(curPack.GetCount()):
        heroItem = curPack.GetAt(index)
        if not heroItem or heroItem.IsEmpty():
            continue
        
        heroID = heroItem.GetItemTypeID()
        inMain = PlayerHero.InMainLineup(heroItem)
        cardAddPer = getHeroCardAddPer(heroItem)
        # ÀúÊ·ÉúЧµÄ
        if heroItem.GetUserAttr(ShareDefine.Def_IudetHeroCardEffective): # ÊÇ·ñÉúЧµÄ
            hisEffCardIndexList.append(index)
            
        # ×îÐÂÉúЧµÄ: Ö÷ÕóÈÝÖеÄÓÅÏÈÉúЧ£¬·ÇÖ÷ÕóÈÝÖеÄ×î¸ß¼Ó³ÉµÄÉúЧ
        if inMain:
            updEffectiveCardDict[heroID] = [cardAddPer, index, inMain]
        else:
            effInfo = updEffectiveCardDict.get(heroID, [-1, -1, False])
            if effInfo[2] == True:
                pass #GameWorld.Log("    ÒѾ­ÓÐÔÚÕóÈÝÖеÄÉúЧ¿¨ÁË: index=%s" % effInfo[1])
            elif cardAddPer > effInfo[0]:
                updEffectiveCardDict[heroID] = [cardAddPer, index, inMain]
                
    # ¸üÐÂÉúЧ±ä¸üµÄ¿¨ÅÆ
    syncItemDict = {} # ÐèҪͬ²½µÄÒì³£ÎïÆ· {index:heroItem, ...}
    GameWorld.DebugLog("ÀúÊ·ÉúЧµÄ¿¨ÅÆË÷Òý: %s" % hisEffCardIndexList)
    GameWorld.DebugLog("×îÐÂÉúЧµÄ¿¨ÅÆÐÅÏ¢: %s" % updEffectiveCardDict)
    cardPerTotal = 0
    olPlayer.SetEffectiveCardDict(updEffectiveCardDict)
    for heroID, effInfo in updEffectiveCardDict.items():
        cardAddPer, itemIndex, inMain = effInfo
        cardPerTotal += cardAddPer
        if itemIndex in hisEffCardIndexList:
            hisEffCardIndexList.remove(itemIndex) # ²»±äµÄÖ±½ÓÒƳý£¬Ê£ÓàδÒƳýµÄ¾ÍÊÇʧЧµÄ
            #GameWorld.DebugLog("ÉúЧµÄ¿¨ÅƲ»±äµÄ: heroID=%s,itemIndex=%s,inMain=%s,cardAddPer=%s,cardPerTotal=%s" % (heroID, itemIndex, inMain, cardAddPer, cardPerTotal))
        else:
            GameWorld.DebugLog("ÉúЧµÄ¿¨ÅƱ仯µÄ: heroID=%s,itemIndex=%s,inMain=%s,cardAddPer=%s,cardPerTotal=%s" % (heroID, itemIndex, inMain, cardAddPer, cardPerTotal))
            heroItem = curPack.GetAt(itemIndex)
            item = heroItem.GetItem()
            item.SetUserAttr(ShareDefine.Def_IudetHeroCardEffective, 1)
            syncItemDict[itemIndex] = heroItem
            
    # ÒƳýÀúʷʧЧµÄ¿¨ÅÆ
    GameWorld.DebugLog("ÒƳýʧЧµÄ¿¨ÅÆË÷Òý: %s" % hisEffCardIndexList)
    for itemIndex in hisEffCardIndexList:
        heroItem = curPack.GetAt(itemIndex)
        item = heroItem.GetItem()
        item.SetUserAttr(ShareDefine.Def_IudetHeroCardEffective, 0)
        syncItemDict[itemIndex] = heroItem
        
    # ͬ²½±ä¸üµÄÎïÆ·
    for syncItem in syncItemDict.values():
        syncItem.Sync_Item()
        
    return

def getHeroCardAddPer(heroItem):
    ## »ñÈ¡¸ÃÎ佫¿¨µÄ¿¨ÅƼӳÉ
    heroID = heroItem.GetItemTypeID()
    heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
    if not heroIpyData:
        return 0
    quality = heroIpyData.GetQuality()
    qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
    if not qualityIpyData:
        return 0
    
    heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
    star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
    breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
    
    starMax = PlayerHero.GetHeroStarMax(heroItem)
    addPer = qualityIpyData.GetInitAddPer()
    addPer += qualityIpyData.GetLVAddPer() * max(0, heroLV - 1)
    addPer += qualityIpyData.GetBreakLVAddPer() * breakLV
    addPer += qualityIpyData.GetStarAddPer() * min(star, starMax)
    return addPer

def doReloadLineup(curPlayer, olPlayer):
    ## ÖØÐÂÔØÈëÕóÈÝ    
    loadLineupIDList = ShareDefine.LineupList
    lineupDict = {} # {ÕóÈÝID:{itemIndex:posNum, ...}, ...}
    lineShapeTypeDict = {} # {ÕóÈÝID:ÕóÐÍ, ...}
    syncItemDict = {} # ÐèҪͬ²½µÄÒì³£ÎïÆ· {index:heroItem, ...}
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    for index in range(curPack.GetCount()):
        heroItem = curPack.GetAt(index)
        if not heroItem or heroItem.IsEmpty():
            continue
        
        lineupCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroLineup)
        if not lineupCount:
            continue
        delValueList = []
        for lpIndex in range(lineupCount)[::-1]:
            lineupValue = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
            lineupID, shapeType, posNum = PlayerHero.GetLineupValue(lineupValue)
            if lineupID not in loadLineupIDList:
                continue
            # ÈÎÒâÈ¡Ò»¸öÎ佫±£´æµÄÕóÐͼ´¿É£¬Í¬ÕóÈݵÄÎ佫ÀíÂÛÉϱ£´æµÄÕóÐÍÊÇÒ»ÑùµÄ
            if lineupID not in lineShapeTypeDict:
                lineShapeTypeDict[lineupID] = shapeType
            if lineupID not in lineupDict:
                lineupDict[lineupID] = {}
            heroItemDict = lineupDict[lineupID]
            
            # ³¬³öÈËÊýÏÞÖÆ»òλÖÃÒì³£
            if len(heroItemDict) >= ShareDefine.LineupObjMax or posNum in heroItemDict.values() or index in heroItemDict:
                delValueList.append(lineupValue)
            else:
                heroItemDict[index] = posNum
                
        if delValueList:
            item = heroItem.GetItem()
            for lineupValue in delValueList:
                item.DelUserAttr(ShareDefine.Def_IudetHeroLineup, lineupValue)
            syncItemDict[index] = heroItem
            
    # ͬ²½±ä¸üµÄÎïÆ·
    for syncItem in syncItemDict.values():
        syncItem.Sync_Item()
        
    GameWorld.DebugLog("ÖØÔØÕóÈÝ: %s" % lineupDict, curPlayer.GetPlayerID())
    for lineupID, heroItemDict in lineupDict.items():
        lineup = olPlayer.GetLineup(lineupID, False)
        
        # »ñÈ¡ÆäËû°ó¶¨¸ÃÕóÈݵŦÄÜ£¬ÈçºìÑÕ¡¢ÁéÊÞµÈ
        
        shapeType = lineShapeTypeDict.get(lineupID, 0)
        lineup.UpdLineup(heroItemDict, shapeType, isReload=True)
        
        if lineupID == ShareDefine.Lineup_Main:
            for exclusiveMapID in ChConfig.ExclusiveBatAttrMapIDList:
                exclusiveLineup = olPlayer.GetLineup(lineupID, False, exclusiveMapID=exclusiveMapID)
                exclusiveLineup.UpdLineup(heroItemDict, shapeType, isReload=True)
                
    PlayerHero.Sync_Lineup(curPlayer)
    return

def doCalcAllAttr(curPlayer):
    ## ¼ÆËãËùÓÐÊôÐÔ
    GameWorld.DebugLog("doCalcAllAttr...", curPlayer.GetPlayerID())
    CalcRoleBase(curPlayer)
    ChEquip.CalcRoleEquipAttr(curPlayer)
    PlayerHero.CalcHeroAddAttr(curPlayer)
    PlayerPrestigeSys.CalcOfficialRankAttr(curPlayer)
    PlayerGubao.CalcGubaoAttr(curPlayer)
    PlayerHJG.CalcHJGAttr(curPlayer)
    PlayerHorse.CalcHorseAttr(curPlayer)
    PlayerBeauty.CalcBeautyAttr(curPlayer)
    GameLogic_Dingjunge.CalcDingjungeAttr(curPlayer)
    return

def doRefreshLineupAttr(curPlayer, olPlayer, lineup):
    ''' Ë¢ÐÂij¸öÕóÈÝÊôÐÔ
        »ù´¡ÊôÐÔ-Ãæ°åÏÔʾ£º
        1.È«Ìå»ù´¡¹Ì¶¨Öµ=ËùÓд©´÷×°±¸¡¾×°±¸»ù´¡¹Ì¶¨Öµ¡¿+¡¾·¨±¦»ù´¡¹Ì¶¨Öµ¡¿+¡¾ºìÑÕ»ù´¡¹Ì¶¨Öµ¡¿+¡¾ÆäËüÄ£¿éµÄ¹Ì¶¨Öµ¡¿
        2.È«Ìå°Ù·Ö±È¼Ó³É=ͼ¼ø¼Ó³É+¡¾ÁéÊÞÄ£¿é¡¿+¡¾ºìÑÕÄ£¿é¡¿+¡¾ÆäËüÄ£¿é¡¿+ËùÓÐÉÏÕó¿¨ÅÆ¡¾³õʼ¼Ó³É+Éý¼¶¼Ó³É+Í»ÆƼӳÉ+ÍÌÊɼӳɡ¿
        3.¿¨ÅƼ̳бÈÀý=¿¨ÅÆÆ·Öʼ°Ö°Òµ¼Ì³Ð±ÈÀý²»Í¬
        4.¿¨ÅÆ×ÔÉíÅàÑø¼Ó³É=¡¾î¿°í¼Ó³É%+Í»ÆÆ´ÊÌõ¼Ó³É%+Ì츳¼Ó³É%¡¿
        ×îÖÕÃæ°åÉúÃü=¡¾EÈ«Ìå»ù´¡¹Ì¶¨Öµ¡¿*¡¾1+EÈ«Ìå°Ù·Ö±È¼Ó³É¡¿*¡¾¿¨ÅÆ×ÔÉí¼Ì³Ð±ÈÀý+ ¿¨ÅÆ×ÔÉíÅàÑø%¼Ó³É¡¿+¡¾¿¨ÅÆ×ÔÉí¹Ì¶¨Öµ¡¿

        Õ½¶·ÊôÐÔ/Õ½¶·¿¹ÐÔ/ÌØÊâÊôÐÔ-Ãæ°åÏÔʾ£º
        1.È«ÌåÕ½¶·ÊôÐÔÖµ=ËùÓд©´÷×°±¸¡¾×°±¸Õ½¶·ÊôÐÔÖµ¡¿+¡¾·¨±¦Õ½¶·ÊôÐÔÖµ¡¿+¡¾ºìÑÕÕ½¶·ÊôÐÔÖµ¡¿+¡¾ÆäËüÄ£¿éµÄÕ½¶·ÊôÐÔ¡¿
        2.¿¨ÅƼ̳бÈÀý=ĬÈÏ100%
        3.¿¨ÅÆ×ÔÉíÅàÑøÕ½¶·ÊôÐÔ=¡¾¿¨ÅƳõʼս¶·ÊôÐÔ+Í»ÆÆ´ÊÌõÕ½¶·ÊôÐÔ+Ì츳ս¶·ÊôÐÔ+¾õÐÑÕ½¶·ÊôÐÔ¡¿+¡¾·¨ÔòÏ´Á¶¡¿+¡¾ÃØÄÜ×°±¸¡¿+¡¾ÆäËüÄ£¿é¡¿
        ×îÖÕÃæ°åÕ½¶·ÊôÐÔ=¡¾EÈ«ÌåÕ½¶·ÊôÐÔÖµ¡¿*¡¾¿¨ÅƼ̳бÈÀý¡¿+¡¾¿¨ÅÆ×ÔÉíÅàÑøÕ½¶·ÊôÐÔ¡¿
    '''
    playerID = curPlayer.GetPlayerID()
    lineupID = lineup.lineupID
    exclusiveMapID = lineup.exclusiveMapID
    
    GameWorld.DebugLog("Ë¢ÐÂÕóÈÝÊôÐÔ: lineupID=%s,exclusiveMapID=%s" % (lineupID, exclusiveMapID), playerID)
    GameWorld.DebugLog("    itemIndex-posNum : %s" % lineup.heroItemDict, playerID)
    
    lineup.FreeLineupHero()
    
    # ÒòΪͬÕóÈݵÄÎ佫ID²»ÄÜÖظ´£¬ËùÒÔ×Öµäkey¿ÉÒÔÓÃÎ佫ID
    countryHeroInfo = {} # ¹ú¼ÒÎ佫ͳ¼Æ {country:[heroID, ...], ...}
    fetterHeroInfo = {} # ÕóÈÝî¿°íÎ佫ͳ¼ÆÐÅÏ¢ {fetterID:[heroID, ...], ...}
    heroSelfAttrInfo = {} # Î佫×ÔÉíÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroLVAttrInfo = {} # Î佫µÈ¼¶ÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroStarTalentInfo = {} # Î佫ÐǼ¶Ì츳ÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroBreakAttrInfo = {} # Î佫ͻÆÆDZÄÜÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroAwakeTalentInfo = {} # Î佫¾õÐÑÌ츳ÊôÐÔ {heroID:{attrID:value, ...}, ...}
    
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    for itemIndex, posNum in lineup.heroItemDict.items():
        if itemIndex < 0 or itemIndex >= curPack.GetCount():
            continue
        heroItem = curPack.GetAt(itemIndex)
        if not heroItem or heroItem.IsEmpty():
            continue
        heroID = heroItem.GetItemTypeID()
        heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
        if not heroIpyData:
            continue
        quality = heroIpyData.GetQuality()
        qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
        if not qualityIpyData:
            continue
        
        heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
        #star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
        breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
        awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
        skinIndex = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroSkin)
        
        skinID = 0
        skinIDList = heroIpyData.GetSkinIDList()
        if skinIndex < 0 or skinIndex >= len(skinIDList):
            skinID = skinIDList[skinIndex]
        elif skinIDList:
            skinID = skinIDList[0]
            
        lineupHero = lineup.GetLineupHero(posNum)
        #if False:
        #    lineupHero = LineupHero()
        lineupHero.itemIndex = itemIndex
        lineupHero.posNum = posNum
        lineupHero.heroID = heroID
        lineupHero.skinID = skinID
        lineupHero.heroBatAttrDict = {}
        lineupHero.heroSkillIDList = []
        lineupHero.fightPower = 0
        
        normalSkillID = heroIpyData.GetNormalSkillID()
        angerSkillID = heroIpyData.GetAngerSkillID()
        lineupHero.heroSkillIDList.extend([normalSkillID, angerSkillID])
        
        # ×ÔÉíÊôÐÔ
        selfAttrDict = {}
        selfAttrDict.update({ChConfig.AttrID_AtkInheritPer:heroIpyData.GetAtkInheritPer(),
                             ChConfig.AttrID_DefInheritPer:heroIpyData.GetDefInheritPer(),
                             ChConfig.AttrID_HPInheritPer:heroIpyData.GetHPInheritPer(),
                             })
        for k, v in heroIpyData.GetBatAttrDict().items():
            selfAttrDict[int(k)] = v
        heroSelfAttrInfo[heroID] = selfAttrDict
        
        # µÈ¼¶ÊôÐÔ
        heroLVAttrDict = {}
        heroLVIpyData = IpyGameDataPY.GetIpyGameData("HeroQualityLV", quality, heroLV)
        if heroLVIpyData:
            attrIDList = heroLVIpyData.GetAttrIDList()
            attrValueList = heroLVIpyData.GetAttrValueList()
            for aIndex in range(min(len(attrIDList), len(attrValueList))):
                attrID = attrIDList[aIndex]
                attrValue = attrValueList[aIndex]
                heroLVAttrDict[attrID] = heroLVAttrDict.get(attrID, 0) + attrValue
        heroLVAttrInfo[heroID] = heroLVAttrDict
        
        # Í»ÆÆDZÄÜ
        breakAttrDict = {}
        breakIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroBreak", heroID)
        if breakIpyDataList:
            for breakIpyData in breakIpyDataList:
                if breakIpyData.GetBreakLV() > breakLV:
                    break
                attrIDList = breakIpyData.GetAttrIDList()
                attrValueList = breakIpyData.GetAttrValueList()
                for aIndex in range(min(len(attrIDList), len(attrValueList))):
                    attrID = attrIDList[aIndex]
                    attrValue = attrValueList[aIndex]
                    breakAttrDict[attrID] = breakAttrDict.get(attrID, 0) + attrValue
                skillID = breakIpyData.GetSkillID()
                if skillID:
                    lineupHero.heroSkillIDList.append(skillID)
        heroBreakAttrInfo[heroID] = breakAttrDict
        
        # ¾õÐÑÌ츳
        maxUnlockSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
        awakeTalentAttrDict = {}
        awakeIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("HeroAwake", heroID)
        if awakeIpyDataList:
            for awakeIpyData in awakeIpyDataList:
                if awakeIpyData.GetAwakeLV() > awakeLV:
                    break
                unlockTalentSlot = awakeIpyData.GetUnlockTalentSlot()
                maxUnlockSlot = max(maxUnlockSlot, unlockTalentSlot)
                attrIDList = awakeIpyData.GetAttrIDList()
                attrValueList = awakeIpyData.GetAttrValueList()
                for aIndex in range(min(len(attrIDList), len(attrValueList))):
                    attrID = attrIDList[aIndex]
                    attrValue = attrValueList[aIndex]
                    awakeTalentAttrDict[attrID] = awakeTalentAttrDict.get(attrID, 0) + attrValue
                skillID = awakeIpyData.GetSkillID()
                if skillID:
                    lineupHero.heroSkillIDList.append(skillID)
        heroAwakeTalentInfo[heroID] = awakeTalentAttrDict
        
        # ÐǼ¶Ì츳
        starTalentAttrDict = {}
        idCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
        lvCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
        for aIndex in range(min(idCount, lvCount, maxUnlockSlot)): # ÖØÉúµ¼ÖÂÒѾõÐѲÛλʧЧʱÊôÐÔÒ²ÎÞЧ
            talentID = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, aIndex)
            talentLV = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, aIndex)
            stIpyData = IpyGameDataPY.GetIpyGameData("HeroTalent", talentID)
            if not stIpyData:
                continue
            attrID = stIpyData.GetAttrID()
            attrValue = stIpyData.GetAttrValue() * talentLV
            starTalentAttrDict[attrID] = starTalentAttrDict.get(attrID, 0) + attrValue
        heroStarTalentInfo[heroID] = starTalentAttrDict
        
        # î¿°íͳ¼Æ
        for fetterID in heroIpyData.GetFetterIDList():
            if fetterID not in fetterHeroInfo:
                fetterHeroInfo[fetterID] = []
            fetterHeroIDList = fetterHeroInfo[fetterID]
            if heroID not in fetterHeroIDList:
                fetterHeroIDList.append(heroID)
                
        # ¹ú¼Òͳ¼Æ
        country = heroIpyData.GetCountry()
        if country not in countryHeroInfo:
            countryHeroInfo[country] = []
        countryHeroIDList = countryHeroInfo[country]
        if heroID not in countryHeroIDList:
            countryHeroIDList.append(heroID)
    
    # î¿°íÊôÐÔ - ½öî¿°íÏà¹ØÎ佫ÓÐЧ
    heroFetterAttrInfo = {} # Î佫íÊôÐÔ {heroID:{attrID:value, ...}, ...}
    for fetterID, fetterHeroIDList in fetterHeroInfo.items():
        fetterIpyData = IpyGameDataPY.GetIpyGameData("HeroFetter", fetterID)
        if not fetterIpyData:
            continue
        needHeroIDList = fetterIpyData.GetHeroIDList()
        canFetter = True
        for needHeroID in needHeroIDList:
            if needHeroID not in fetterHeroIDList:
                canFetter = False
                break
        if not canFetter:
            continue
        attrIDList = fetterIpyData.GetAttrIDList()
        attrValueList = fetterIpyData.GetAttrValueList()
        for aIndex in range(min(len(attrIDList), len(attrValueList))):
            attrID = attrIDList[aIndex]
            attrValue = attrValueList[aIndex]
            for heroID in needHeroIDList:
                if heroID not in heroFetterAttrInfo:
                    heroFetterAttrInfo[heroID] = {}
                heroFetterAttrDict = heroFetterAttrInfo[heroID]
                heroFetterAttrDict[attrID] = heroFetterAttrDict.get(attrID, 0) + attrValue
                
    # ÕóÈÝÊôÐÔ - ÕóÈÝËùÓÐÎ佫ÓÐЧ
    lineupHaloAttrInfo = {} # ÕóÈݹ⻷ÊôÐÔ {attrID:value, ...}
    for country, countryHeroIDList in countryHeroInfo.items():
        haloIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroLineupHalo", country)
        if not haloIpyDataList:
            continue
        
        attrIDList, attrValueList = [], []
        countryHeroCnt = len(countryHeroIDList)
        for haloIpyData in haloIpyDataList:
            needHeroCount = haloIpyData.GetNeedHeroCount()
            if countryHeroCnt < needHeroCount:
                break
            attrIDList = haloIpyData.GetAttrIDList()
            attrValueList = haloIpyData.GetAttrValueList()
        # ÿ¸ö¹ú¼Ò×î¶à½öÉúЧһÌõÊôÐÔ£¬²»Í¬¹ú¼ÒÊôÐԿɵþ¼Ó
        for aIndex in range(min(len(attrIDList), len(attrValueList))):
            attrID = attrIDList[aIndex]
            attrValue = attrValueList[aIndex]
            lineupHaloAttrInfo[attrID] = lineupHaloAttrInfo.get(attrID, 0) + attrValue
            
    # --------------------------- ÉÏÃæͳ¼ÆºÃÁË£¬ÏÂÃæ¼ÆËãÎ佫×îÖÕÊôÐÔ --------------------------------
    baseAttrFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 1)
    otherAttrFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 2)
    fightPowerFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 3)
    skillFPFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 4)
    
    lvAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_LV)
    equipAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_MainEquip)
    fatesAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_HeroFates)
    realmAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Realm)
    gubaoAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Gubao)
    hjgAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_HJG)
    horseAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Horse)
    beautyAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Beauty)
    dingjungeAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Dingjunge) if exclusiveMapID == ChConfig.Def_FBMapID_Dingjunge else {}
    
    GameWorld.DebugLog("    ¹ú¼ÒÎ佫ͳ¼Æ=%s" % countryHeroInfo, playerID)
    GameWorld.DebugLog("    î¿°íÎ佫ͳ¼Æ=%s" % fetterHeroInfo, playerID)
    GameWorld.DebugLog("    Î佫×ÔÉíÊôÐÔ=%s" % heroSelfAttrInfo, playerID)
    GameWorld.DebugLog("    Î佫µÈ¼¶ÊôÐÔ=%s" % heroLVAttrInfo, playerID)
    GameWorld.DebugLog("    Î佫ÍÌÊÉÊôÐÔ=%s" % heroStarTalentInfo, playerID)
    GameWorld.DebugLog("    Î佫ͻÆÆDZÄÜ=%s" % heroBreakAttrInfo, playerID)
    GameWorld.DebugLog("    Î佫¾õÐÑÌ츳=%s" % heroAwakeTalentInfo, playerID)
    GameWorld.DebugLog("    Î佫íÊôÐÔ=%s" % heroFetterAttrInfo, playerID)
    GameWorld.DebugLog("    ÕóÈݹ⻷ÊôÐÔ=%s" % lineupHaloAttrInfo, playerID)
    
    GameWorld.DebugLog("    Ö÷¹«µÈ¼¶ÊôÐÔ=%s" % lvAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«×°±¸ÊôÐÔ=%s" % equipAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«ËÞÔµÊôÐÔ=%s" % fatesAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«¹ÙÖ°ÊôÐÔ=%s" % realmAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«¹Å±¦ÊôÐÔ=%s" % gubaoAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷»Ã¾³¸óÊôÐÔ=%s" % hjgAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«×øÆïÊôÐÔ=%s" % horseAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«ºìÑÕÊôÐÔ=%s" % beautyAttrDict, playerID)
    GameWorld.DebugLog("    ¶¨¾üרÊôÊôÐÔ=%s" % dingjungeAttrDict, playerID)
    
    effCardAddPer = 0
    for effInfo in olPlayer.GetEffectiveCardDict().values():
        effCardAddPer += effInfo[0]
    effCardAddPer /= 10000.0
    GameWorld.DebugLog("    Ö÷¹«¿¨ÅƼӳÉ=%s" % effCardAddPer, playerID)
    
    PlayerLV = curPlayer.GetLV()
    OfficialLV = curPlayer.GetOfficialRank()
    GameWorld.DebugLog("    PlayerLV=%s,OfficialLV=%s" % (PlayerLV, OfficialLV), playerID)
    
    fpRatioIpyData = IpyGameDataPY.GetIpyGameData("FightPowerRatio", OfficialLV)
    
    lineupFightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
    for heroID, selfAttrDict in heroSelfAttrInfo.items():
        lineupHero = lineup.GetLineupHeroByID(heroID)
        if not lineupHero:
            continue
        lineupHero.heroBatAttrDict = {}
        lineupHero.fightPower = 0
        
        heroLVAttrDict = heroLVAttrInfo.get(heroID, {})
        starTalentAttrDict = heroStarTalentInfo.get(heroID, {})
        breakAttrDict = heroBreakAttrInfo.get(heroID, {})
        awakeTalentAttrDict = heroAwakeTalentInfo.get(heroID, {})
        fetterAttrDict = heroFetterAttrInfo.get(heroID, {})
        
        logAttrDict = {}
        fightPowerParamDict = {}
        for attrID in ChConfig.CalcBattleAttrIDList:
            attrPerID = ChConfig.AttrPerDict.get(attrID, 0) # ¶ÔÓ¦°Ù·Ö±ÈÌáÉýµÄÊôÐÔID
            
            lvValue = lvAttrDict.get(attrID, 0)
            equipValue = equipAttrDict.get(attrID, 0)
            
            cardPer = 0 # ¿¨ÅƼӳɣ¬½ö¶Ô»ù´¡ÈýάÓÐÓÃ
            if attrID in ChConfig.BaseAttrIDList:
                cardPer = effCardAddPer
                
            fatesValue = fatesAttrDict.get(attrID, 0)
            fatesPer = fatesAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            realmValue = realmAttrDict.get(attrID, 0)
            realmPer = realmAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            gubaoValue = gubaoAttrDict.get(attrID, 0)
            gubaoPer = gubaoAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            hjgValue = hjgAttrDict.get(attrID, 0)
            hjgPer = hjgAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            horseValue = horseAttrDict.get(attrID, 0)
            horsePer = horseAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            beautyValue = beautyAttrDict.get(attrID, 0)
            beautyPer = beautyAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            dingjungeValue = dingjungeAttrDict.get(attrID, 0)
            dingjungePer = dingjungeAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
                
            heroSelfValue, heroSelfPer = selfAttrDict.get(attrID, 0), 0 # Î佫×ÔÉí»ùÖµ
            inheritPer = 1 # ¼Ì³Ð±ÈÀý£¬Ä¬ÈÏ100%
            if attrID in ChConfig.AttrInheritPerDict:
                attrInheritPerID = ChConfig.AttrInheritPerDict[attrID] # ¼Ì³ÐID
                inheritPer = selfAttrDict.get(attrInheritPerID, 10000) # ¼Ì³Ð±ÈÀý´ÓÎ佫×ÔÉíÊôÐÔÖÐÈ¡
                inheritPer /= 10000.0
                
            lineupHaloValue, lineupHaloPer = lineupHaloAttrInfo.get(attrID, 0), 0
            fetterValue, fetterPer = fetterAttrDict.get(attrID, 0), 0
            heroLVValue, heroLVPer = heroLVAttrDict.get(attrID, 0), 0
            starTalentValue, starTalentPer = starTalentAttrDict.get(attrID, 0), 0
            breakLVValue, breakLVPer = breakAttrDict.get(attrID, 0), 0
            awakeTalentValue, awakeTalentPer = awakeTalentAttrDict.get(attrID, 0), 0
            if attrPerID:
                heroSelfPer = selfAttrDict.get(attrPerID, 0) / 10000.0
                lineupHaloPer = lineupHaloAttrInfo.get(attrPerID, 0) / 10000.0
                fetterPer = fetterAttrDict.get(attrPerID, 0) / 10000.0
                heroLVPer = heroLVAttrDict.get(attrPerID, 0) / 10000.0
                starTalentPer = starTalentAttrDict.get(attrPerID, 0) / 10000.0
                breakLVPer = breakAttrDict.get(attrPerID, 0) / 10000.0
                awakeTalentPer = awakeTalentAttrDict.get(attrPerID, 0) / 10000.0
                
            # ¼ÆËã
            attrParamDict = {"lvValue":lvValue, "equipValue":equipValue, "realmValue":realmValue, "realmPer":realmPer, "cardPer":cardPer,
                             "gubaoValue":gubaoValue, "gubaoPer":gubaoPer, "hjgValue":hjgValue, "hjgPer":hjgPer, "horseValue":horseValue, "horsePer":horsePer, 
                             "beautyValue":beautyValue, "beautyPer":beautyPer, "fatesValue":fatesValue, "fatesPer":fatesPer,
                             "dingjungeValue":dingjungeValue, "dingjungePer":dingjungePer,
                             "heroSelfValue":heroSelfValue, "heroSelfPer":heroSelfPer, "inheritPer":inheritPer, "heroLVValue":heroLVValue, "heroLVPer":heroLVPer,
                             "lineupHaloValue":lineupHaloValue, "lineupHaloPer":lineupHaloPer, "fetterValue":fetterValue, "fetterPer":fetterPer,
                             "starTalentValue":starTalentValue, "starTalentPer":starTalentPer, "breakLVValue":breakLVValue, "breakLVPer":breakLVPer,
                             "awakeTalentValue":awakeTalentValue, "awakeTalentPer":awakeTalentPer,
                             }
            
            if attrID in ChConfig.BaseAttrIDList:
                attrValue = FormulaControl.Eval("baseAttrFormula", baseAttrFormula, attrParamDict, toInt=False, ndigits=3)
            else:
                attrValue = FormulaControl.Eval("otherAttrFormula", otherAttrFormula, attrParamDict, toInt=False, ndigits=3)
            #GameWorld.DebugLog("    attrID=%s,attrValue=%s,attrParamDict=%s" % (attrID, attrValue, attrParamDict))
            
            attrIpyData = IpyGameDataPY.GetIpyGameData("PlayerAttr", attrID)
            attrName = attrIpyData.GetParameter() if attrIpyData else "%s" % attrID
            attrRatioName = "%sRatio" % attrName
            ratioValue = 0
            if attrValue and hasattr(fpRatioIpyData, "Get%s" % attrRatioName):
                ratioValue = getattr(fpRatioIpyData, "Get%s" % attrRatioName)()
            fightPowerParamDict[attrName] = attrValue
            fightPowerParamDict[attrRatioName] = ratioValue
            if attrValue:
                lineupHero.heroBatAttrDict[attrID] = attrValue
                logAttrDict["%s-%s" % (attrID, attrName)] = attrValue
            
        # ¼ÆËãÕ½Á¦
        fightPower = FormulaControl.Eval("fightPowerFormula", fightPowerFormula, fightPowerParamDict, toInt=True)
        
        GameWorld.DebugLog("    heroID=%s,fightPower=%s,heroSkillIDList=%s" % (heroID, fightPower, lineupHero.heroSkillIDList), playerID)
        skillTypeIDDict = {}
        for skillID in lineupHero.heroSkillIDList:
            skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
            if not skillData:
                continue
            skillTypeID = skillData.GetSkillTypeID()
            if skillTypeID not in skillTypeIDDict:
                skillTypeIDDict[skillTypeID] = skillData
            else:
                befSkillData = skillTypeIDDict[skillTypeID]
                befSkillID = befSkillData.GetSkillID()
                if befSkillID >= skillID:
                    continue
                skillTypeIDDict[skillTypeID] = skillData
                
        skillFightPower = 0
        lineupHero.heroSkillIDList = []
        for skillData in skillTypeIDDict.values():
            skillID = skillData.GetSkillID()
            lineupHero.heroSkillIDList.append(skillID)
            paramDict = {"SkillPower":skillData.GetFightPower(), "PlayerLV":PlayerLV, "OfficialLV":OfficialLV}
            sFightPower = FormulaControl.Eval("skillFPFormula", skillFPFormula, paramDict, toInt=True)
            skillFightPower += sFightPower
        GameWorld.DebugLog("    skillFightPower=%s,heroSkillIDList=%s" % (skillFightPower, lineupHero.heroSkillIDList), playerID)
        
        # ×îÖÕÕ½Á¦
        fightPowerTotal = fightPower + skillFightPower
        lineupHero.skillFightPower = skillFightPower
        lineupHero.fightPower = fightPowerTotal
        lineupFightPower += fightPowerTotal
        
        GameWorld.DebugLog("    Î佫×îÖÕÕ½Á¦: heroID=%s,fightPower=%s(%s+%s),%s,skillIDList=%s" 
                           % (heroID, fightPowerTotal, fightPower, skillFightPower, logAttrDict, lineupHero.heroSkillIDList), playerID)
        
    lineup.fightPower = lineupFightPower
    GameWorld.DebugLog("    ÕóÈÝ×îÖÕÕ½Á¦: lineupID=%s,lineupFightPower=%s,exclusiveMapID=%s" % (lineupID, lineupFightPower, exclusiveMapID), playerID)
    
    # ·ÇÖ÷ÏßÕóÈݲ»´¦ÀíÒÔÏÂÄÚÈÝ
    if lineupID != ShareDefine.Lineup_Main or exclusiveMapID:
        return
    
    PlayerControl.SetFightPower(curPlayer, lineupFightPower)
    
    mainFightMgr = TurnAttack.GetMainFightMgr(curPlayer)
    mainTurnFight = mainFightMgr.turnFight
    # Ö÷ÏßÕ½¶·Èç¹ûÓÐÔÚÕ½¶·ÖУ¬ÊµÊ±¸üÐÂ
    if mainTurnFight and mainTurnFight.isInFight():
        # Èç¹ûÊÇÕóÈݱ仯µÄ£¬ÖØпªÊ¼Õ½¶·
        if lineup.lineupChange:
            GameWorld.DebugLog("Ö÷ÕóÈݱ仯£¬ÖØпªÊ¼Õ½¶·", playerID)
            if mainTurnFight.mapID == ChConfig.Def_FBMapID_Main:
                TurnAttack.__doMainLevelWave(curPlayer, True)
                
        # ·ñÔòÖ»ÖØÐÂÉèÖÃÕ½¶·ÊôÐÔ
        else:
            GameWorld.DebugLog("Ö÷ÕóÈÝ¿¨ÅÆÊôÐÔ±ä¸ü£¬¸üÐÂÕ½¶·Î佫ÊôÐÔ", playerID)
            # lineup        Ϊ¿¨ÅƵÄÕóÈÝ£¬½öÓÐÕóÈÝÊôÐÔÏà¹Ø£¬Ã»ÓÐÕ½¶·¶ÔÏó
            # batLineup    Ϊ¿¨ÅÆÕóÈÝÌåÏÖµ½¾ßÌåÕ½¶·µÄÕ½¶·ÕóÈÝ£¬ÓоßÌåµÄÕ½¶·¶ÔÏó
            faction, num = ChConfig.Def_FactionA, 1 # Ö÷ÏßÕ½¶·Íæ¼Ò×Ô¼ºÄ¬ÈÏÕóÓªAµÄµÚ1¸öÕ½¶·ÕóÈÝ
            batLineup = mainTurnFight.getBatFaction(faction).getBatlineup(num)
            batObjMgr = BattleObj.GetBatObjMgr()
            for posNum, objID in batLineup.posObjIDDict.items():
                batObj = batObjMgr.getBatObj(objID)
                if not batObj:
                    continue
                lineupHero = lineup.GetLineupHero(posNum)
                if lineupHero.heroBatAttrDict:
                    batObj.UpdInitBatAttr(lineupHero.heroBatAttrDict, lineupHero.heroSkillIDList)
    else:
        GameWorld.DebugLog("Ö÷ÕóÈÝûÓÐÔÚÕ½¶·ÖУ¬²»ÐèÒª´¦Àí", playerID)
        
    PlayerFamily.RefreshFamilyMember(curPlayer) # ¸üй«»á
    # ¸üÐÂÅÅÐаñ
    
    return