#!/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 PlayerHero
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):
        self.playerID = playerID
        self.lineupID = lineupID
        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, syncLineup=True):
        '''±ä¸üÕóÈÝʱ¸üÐÂ
        @param heroItemDict: Î佫±³°üË÷ÒýÐÅÏ¢  {itemIndex:posNum, ...}
        @param shapeType: ÕóÐÍ
        @param refreshForce: ÊÇ·ñÇ¿ÖÆË¢ÊôÐÔ
        '''
        self.lineupChange = True
        self.shapeType = shapeType
        self.heroItemDict = heroItemDict
        GameWorld.DebugLog("¸üÐÂÕóÈÝ: lineupID=%s,%s" % (self.lineupID, heroItemDict), self.playerID)
        self.RefreshLineupAttr(refreshForce)
        if syncLineup and self.olPlayer.curPlayer:
            PlayerHero.Sync_Lineup(self.olPlayer.curPlayer, self.lineupID)
        return
    
    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 GetLineupInfo(self):
        ## »ñÈ¡ÕóÈÝÐÅÏ¢£¬¼´ÒªÓõ½¸ÃÕóÈÝÁË£¬ÈçÕ½¶·»òÕß±£´æ»º´æÐÅÏ¢µÈ
        self.DoRefreshLineupAttr() # È¡ÕóÈÝʱÏȼì²é
        return
    
    def SetNeedRefreshState(self):
        ## ÉèÖÃÐèҪˢÊôÐÔ
        self.__refreshState = 1
        return
    
    def RefreshLineupAttr(self, refreshForce=False):
        self.__refreshState = 1 # ±ê¼ÇҪˢÐÂ
        if refreshForce:
            self.DoRefreshLineupAttr()
        return
    
    def DoRefreshLineupAttr(self):
        if not self.__refreshState:
            return False
        doRefreshLineupAttr(self.olPlayer.curPlayer, self.olPlayer, self)
        self.lineupChange = False
        self.__refreshState = 0
        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.lineupDict = {} # ÉÏÕóÕóÈÝ {lineupID:Lineup, ...}
        
        # Ö÷ÏßÕ½¶·
        self.mainFight = TurnAttack.MainFight(playerID)
        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):
        lineup = None
        if lineupID in self.lineupDict:
            lineup = self.lineupDict[lineupID]
        else:
            lineup = Lineup(self.playerID, lineupID)
            self.lineupDict[lineupID] = lineup
        lineup.olPlayer = self
        return lineup
    
    def GetCalcAttr(self, calcIndex): return self.calcAttrDict.get(calcIndex, {})
    def SetCalcAttr(self, calcIndex, attrDict):
        ## ÉèÖÃij¸ö¹¦Äܵã¼ÆËãµÄÊôÐÔ
        self.calcAttrDict[calcIndex] = attrDict
        return
    
    def ReCalcAllAttr(self):
        ## ÖØÖÃËùÓй¦Äܵã¼ÆËãµÄÊôÐÔ£¬Ò»°ãµÇ¼µÄʱºòµ÷ÓÃÒ»´Î¼´¿É£¬ÆäËûµ¥¹¦ÄÜˢеĻ°Ò»°ãʹÓà RefreshRoleAttr
        curPlayer = self.curPlayer
        GameWorld.DebugLog("ReCalcAllAttr...", self.playerID)
        
        self.calcAttrDict = {}
        self.lineupDict = {}
        
        doCalcAllAttr(curPlayer)
        doReloadLineup(curPlayer, self)
        
        self.RefreshRoleAttr()
        return
    
    def RefreshRoleAttr(self, refreshForce=False, isAllLineup=False):
        '''Ë¢ÐÂÖ÷¹«ÊôÐÔ£¬Ó°ÏìÖ÷¹«ÊôÐԵŦÄܵãÊôÐԱ仯ʱͳһµ÷Óô˺¯Êý
        @param refreshForce: ÊÇ·ñÇ¿ÖÆÁ¢ÂíË¢ÐÂ
        @param isAllLineup: ÊÇ·ñֻͬ²½Ë¢ËùÓÐÕóÈÝÊôÐÔ£¬Èç¹ûÉèÖÃFalseÔòĬÈϽöË¢Ö÷ÕóÈÝÊôÐÔ
        '''
        GameWorld.DebugLog("ÇëÇóË¢ÊôÐÔ: refreshForce=%s" % (refreshForce), self.playerID)
        # Ö÷¹«ÊôÐÔË¢ÐÂʱ£¬ËùÓÐÕóÈݶ¼ÒªÍ¬²½Ë¢ÐÂ
        for lineup in self.lineupDict.values():
            lineup.SetNeedRefreshState()
            
        if refreshForce:
            self.DoRefreshRoleAttr(isAllLineup)
        return
    
    def DoRefreshRoleAttr(self, isAllLineup=False):
        '''Ö´ÐÐË¢ÊôÐÔ£¬Ä¬È϶îÍâË¢Ö÷ÕóÈÝ£¬ÆäËûÕóÈÝ¿ÉÒÔÓõ½µÄʱºòÔÙË¢ÐÂ
        @param isAllLineup: ÊÇ·ñË¢ËùÓÐÕóÈÝ£¬Èç¹ûÉèÖÃFalseÔòĬÈϽöË¢Ö÷ÕóÈÝÊôÐÔ
        @return: ÊÇ·ñÓÐË¢ÊôÐÔ£¬0-ÎÞ£»1-ÓÐ
        '''
        
        isRefresh = False
        # ͬ²½Ö´ÐÐÕóÈÝÊôÐÔË¢ÐÂ
        for lineupID, lineup in self.lineupDict.items():
            if not isAllLineup and lineupID != ShareDefine.Lineup_Main:
                continue
            if lineup.DoRefreshLineupAttr():
                isRefresh = True
                
        return isRefresh
    
    def OnHeroItemUpate(self, itemIndexList):
        '''Î佫ÎïÆ·Ñø³É¸üÐÂ
        @param itemIndexList: ±ä»¯Î佫ÎïÆ·ËùÔÚÎ佫±³°ü¸ñ×ÓË÷ÒýÁбí
        @param return: Ó°ÏìµÄÕóÈÝIDÁбí
        '''
        effLineupIDList = []
        
        for lineupID, lineup in self.lineupDict.items():
            for itemIndex in itemIndexList:
                if lineup.CheckHeroItemUpdate(itemIndex):
                    if lineupID not in effLineupIDList:
                        effLineupIDList.append(lineupID)
                        
        GameWorld.DebugLog("Î佫ÎïÆ·Ñø³É¸üÐÂË÷Òý: %s, Ó°ÏìÕóÈÝ:%s" % (itemIndexList, effLineupIDList), self.playerID)
        return effLineupIDList
    
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 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)
        
        # »ñÈ¡ÆäËû°ó¶¨¸ÃÕóÈݵŦÄÜ£¬ÈçºìÑÕ¡¢ÁéÊÞµÈ
        
        shapeType = lineShapeTypeDict.get(lineupID, 0)
        lineup.UpdLineup(heroItemDict, shapeType, syncLineup=False)
        
    PlayerHero.Sync_Lineup(curPlayer)
    return

def doCalcAllAttr(curPlayer):
    ## ¼ÆËãËùÓÐÊôÐÔ
    GameWorld.DebugLog("doCalcAllAttr...", curPlayer.GetPlayerID())
    CalcRoleBase(curPlayer)
    ChEquip.CalcRoleEquipAttr(curPlayer)
    PlayerHero.CalcHeroAddAttr(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
    
    GameWorld.DebugLog("Ë¢ÐÂÕóÈÝÊôÐÔ: lineupID=%s" % lineupID, playerID)
    GameWorld.DebugLog("    itemIndex-posNum : %s" % lineup.heroItemDict, playerID)
    
    lineup.FreeLineupHero()
    
    # ÒòΪͬÕóÈݵÄÎ佫ID²»ÄÜÖظ´£¬ËùÒÔ×Öµäkey¿ÉÒÔÓÃÎ佫ID
    countryHeroInfo = {} # ¹ú¼ÒÎ佫ͳ¼Æ {country:[heroID, ...], ...}
    fetterHeroInfo = {} # ÕóÈÝî¿°íÎ佫ͳ¼ÆÐÅÏ¢ {fetterID:[heroID, ...], ...}
    heroSelfAttrInfo = {} # Î佫×ÔÉíÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroStarTalentInfo = {} # Î佫ÐǼ¶Ì츳ÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroBreakAttrInfo = {} # Î佫ͻÆÆDZÄÜÊôÐÔ {heroID:{attrID:value, ...}, ...}
    heroAwakeTalentInfo = {} # Î佫¾õÐÑÌ츳ÊôÐÔ {heroID:{attrID:value, ...}, ...}
    
    # ÉÏÕó¿¨ÅÆ¡¾³õʼ¼Ó³É+Éý¼¶¼Ó³É+Í»ÆƼӳÉ+ÍÌÊɼӳɡ¿
    InitAddPer, LVAddPer, BreakLVAddPer, StarAddPer = 0, 0, 0, 0
    
    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]
            
        InitAddPer += qualityIpyData.GetInitAddPer()
        LVAddPer += qualityIpyData.GetLVAddPer() * heroLV
        BreakLVAddPer += qualityIpyData.GetBreakLVAddPer() * breakLV
        StarAddPer += qualityIpyData.GetStarAddPer() * star
        
        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
        
        # ÐǼ¶Ì츳
        starTalentAttrDict = {}
        idCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
        lvCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
        for aIndex in range(min(idCount, lvCount)):
            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
        
        # Í»ÆÆDZÄÜ
        breakAttrDict = {}
        awakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroBreak", heroID)
        if awakeIpyDataList:
            for breakIpyData in awakeIpyDataList:
                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
        
        # ¾õÐÑÌ츳
        awakeTalentAttrDict = {}
        awakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
        if awakeIpyDataList:
            for awakeIpyData in awakeIpyDataList:
                if awakeIpyData.GetAwakeLV() > awakeLV:
                    break
                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
        
        # î¿°íͳ¼Æ
        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)
    
    lvAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_LV)
    equipAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_MainEquip)
    bookAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_HeroBook)

    GameWorld.DebugLog("    ¹ú¼ÒÎ佫ͳ¼Æ=%s" % countryHeroInfo, playerID)
    GameWorld.DebugLog("    î¿°íÎ佫ͳ¼Æ=%s" % fetterHeroInfo, playerID)
    GameWorld.DebugLog("    Î佫×ÔÉíÊôÐÔ=%s" % heroSelfAttrInfo, 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("    ÕóÈÝÉÏÕó¼Ó³É=InitAddPer=%s,LVAddPer=%s,BreakLVAddPer=%s,StarAddPer=%s" % (InitAddPer, LVAddPer, BreakLVAddPer, StarAddPer), playerID)
    
    GameWorld.DebugLog("    Ö÷¹«µÈ¼¶ÊôÐÔ=%s" % lvAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«×°±¸ÊôÐÔ=%s" % equipAttrDict, playerID)
    GameWorld.DebugLog("    Ö÷¹«Í¼¼øÊôÐÔ=%s" % bookAttrDict, playerID)
    
    lineupFightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
    InitAddPer, LVAddPer, BreakLVAddPer, StarAddPer = InitAddPer / 10000.0, LVAddPer / 10000.0, BreakLVAddPer / 10000.0, StarAddPer / 10000.0
    for heroID, selfAttrDict in heroSelfAttrInfo.items():
        lineupHero = lineup.GetLineupHeroByID(heroID)
        if not lineupHero:
            continue
        lineupHero.heroBatAttrDict = {}
        lineupHero.fightPower = 0
        
        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)
            bookValue = bookAttrDict.get(attrID, 0)
            bookPer = bookAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
            
            lineupInitAddPer, lineupLVAddPer, lineupBreakLVAddPer, lineupStarAddPer = 0, 0, 0, 0
            if attrID in ChConfig.BaseAttrIDList:
                lineupInitAddPer, lineupLVAddPer, lineupBreakLVAddPer, lineupStarAddPer = InitAddPer, LVAddPer, BreakLVAddPer, StarAddPer
                
            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
            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
                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, "bookValue":bookValue, "bookPer":bookPer, 
                             "lineupInitAddPer":lineupInitAddPer, "lineupLVAddPer":lineupLVAddPer, "lineupBreakLVAddPer":lineupBreakLVAddPer, "lineupStarAddPer":lineupStarAddPer,
                             "heroSelfValue":heroSelfValue, "heroSelfPer":heroSelfPer, "inheritPer":inheritPer,
                             "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)
            else:
                attrValue = FormulaControl.Eval("otherAttrFormula", otherAttrFormula, attrParamDict)
            #GameWorld.DebugLog("    attrID=%s,attrValue=%s,attrParamDict=%s" % (attrID, attrValue, attrParamDict))
            
            attrIpyData = IpyGameDataPY.GetIpyGameData("PlayerAttr", attrID)
            attrName = attrIpyData.GetParameter() if attrIpyData else "%s" % attrID
            fightPowerParamDict[attrName] = attrValue
            if attrValue:
                lineupHero.heroBatAttrDict[attrID] = attrValue
                logAttrDict["%s-%s" % (attrID, attrName)] = attrValue
                
        # ¼ÆËãÕ½Á¦
        fightPower = FormulaControl.Eval("fightPowerFormula", fightPowerFormula, fightPowerParamDict)
        
        GameWorld.DebugLog("    fightPower=%s,heroSkillIDList=%s" % (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)
            skillFightPower += skillData.GetFightPower()
        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" % (lineupID, lineupFightPower), playerID)
    
    # ·ÇÖ÷ÏßÕóÈݲ»´¦ÀíÒÔÏÂÄÚÈÝ
    if lineupID != ShareDefine.Lineup_Main:
        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)
            elif mainTurnFight.mapID == ChConfig.Def_FBMapID_MainBoss:
                TurnAttack.__doMainBossStart(curPlayer)
                
        # ·ñÔòÖ»ÖØÐÂÉèÖÃÕ½¶·ÊôÐÔ
        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)
    else:
        GameWorld.DebugLog("Ö÷ÕóÈÝûÓÐÔÚÕ½¶·ÖУ¬²»ÐèÒª´¦Àí", playerID)
        
    # ¸üÐÂÅÅÐаñ
    
    return