6459 【后端】【2.0】缥缈仙域开发单（设置充值成功SendDBFinishRecharge时机提前，在收到通知即设置，异常信息通过CTGErro...

hxp

2019-04-13 6b458bedb17a2b272e19bbd1ffab00ead6c6089d

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerControl.py

@@ -74,6 +74,7 @@
import PlayerMagicWeapon

import GameLogic_SealDemon

import GameLogic_ZhuXianBoss

import GameLogic_CrossDemonKing

import PlayerTJG

import PlayerVip

import PlayerRefineStove

@@ -1178,10 +1179,6 @@
    NPCCommon.ClearCollectNPC(curPlayer)

    #结束事件

    EventShell.DoExitEvent(curPlayer)

    
    # 结束摆摊/查看摆摊

    EventShell.ExitShopItem(curPlayer)

    EventShell.ExitWatchShopItem(curPlayer)



    #设置玩家的地图位置, 如果是副本, 离开副本

#    副本规则:

@@ -1447,11 +1444,6 @@
        

    curPlayer.SetChangeMapTakeTruck(takeTruck)

    

    # 如果在摆摊中，提示摆摊关闭

    playerShop = curPlayer.GetPlayerShop()

    if playerShop.GetIsStartShop():

        NotifyCode(curPlayer, "GeRen_admin_70569")

    
    #离开地图服务器

    __PlayerLeaveServerLogic(curPlayer, tick, False)

    

@@ -1595,9 +1587,12 @@


#---------------------------------------------------------------------



def PlayerEnterCrossServer(curPlayer, mapID):

def PlayerEnterCrossServer(curPlayer, mapID, lineID):

    playerID = curPlayer.GetPlayerID()

    GameWorld.Log("玩家请求进入跨服地图: mapID=%s" % (mapID), playerID)

    GameWorld.Log("玩家请求进入跨服地图: mapID=%s,lineID=%s" % (mapID, lineID), playerID)

    if mapID not in ChConfig.Def_CrossMapIDList:

        return

    
    if GameWorld.IsCrossServer():

        GameWorld.DebugLog("跨服服务器不允许该操作!")

        return

@@ -1620,6 +1615,30 @@
    

    if PlayerState.IsInPKState(curPlayer):

        NotifyCode(curPlayer, "SingleEnterPK", [mapID])

        return

    
    tick = GameWorld.GetGameWorld().GetTick()

    for mapIDList in ChConfig.Def_FB_MapID.values():

        if mapID not in mapIDList:

            continue

        if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):

            NotifyCode(curPlayer, "SingleEnterDefaul")

            return

        break

    
    # 需要动态分布线路的地图，发送到跨服服务器进行分配

    if mapID in ChConfig.Def_CrossDynamicLineMap:

        extendInfo = {}

        if mapID == ChConfig.Def_FBMapID_CrossDemonKing:

            bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(lineID)

            if not bossID:

                return

            extendInfo["BossID"] = bossID

            
        msgDict = {"PlayerID":curPlayer.GetPlayerID(), "DataMapID":mapID, "FuncLineID":lineID}

        if extendInfo:

            msgDict.update(extendInfo)

        GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_EnterFB, msgDict)

        return

    

    GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID)

@@ -1718,6 +1737,9 @@
            if enterCnt >= FBCommon.GetEnterFBMaxCnt(curPlayer, ChConfig.Def_FBMapID_ZhuXianBoss):

                if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ZhuXianBossHelpCnt):

                    extendParamList = [bossID, curPlayer.GetFamilyID()]

        elif mapID == ChConfig.Def_FBMapID_DemonKing:

            bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(lineID)

            extendParamList = [bossID]

            

        SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList)

        return

@@ -2985,10 +3007,6 @@
    # 绝版降临

    PlayerFairyCeremony.AddFCCostGold(curPlayer, costType, price)

    PlayerNewFairyCeremony.AddFCCostGold(curPlayer, costType, price)

    # 消费VIP

#    if costVIPGold < 0:

#        costVIPGold = price

    #PlayerCostVIP.AddCostVIPExp(curPlayer, costType, costVIPGold)

    

    # 事件汇报

    #===========================================================================

@@ -3411,16 +3429,21 @@
    curLV = curPlayer.GetLV()

    if curLV < openLV:

        return 0

    # 初始点+升级点+境界点

    setFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)

    
    addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})

    initFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)

    setFreePoint = initFreePoint

    for lv in xrange(openLV, curLV+1):

        setFreePoint += GameWorld.GetDictValueByRangeKey(addPointDict, lv, 0)

    for rangLVs, point in addPointDict.items():

        if curLV < rangLVs[0]:

            continue

        setFreePoint += point * (min(curLV, rangLVs[1]) - rangLVs[0] + 1)

    
    #境界提升点数

    setFreePoint += curPlayer.GetOfficialRank() * IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 3)

    return setFreePoint



def DoAddPointOpen(curPlayer):

    '''加点功能开启 处理给自由属性点及老号处理  
                    清除老服玩家未加点的点数（清零），以前加的加点属性不清除，属性不变，战力不减， 根据最新的加点开启等级和老服玩家的当前等级，相差的差值给予玩家对应的加点点数'''

    '''加点功能开启'''

    beforeFreePoint = curPlayer.GetFreePoint()

    

    setFreePoint = GetAllPointByLV(curPlayer)

@@ -3630,6 +3653,9 @@
    #  @remarks 玩家升级 加点 2010-05-26 adaws修改 原来有加技能点 现将升级加技能提出 

    def __DoLVUPAddPoint(self):

        curPlayer = self.__Player

        if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_AddPoint):

            # 未开启前不可加点，因为DoAddPointOpen会一次性补齐，避免意外情况多加了点数

            return



        curFreePoint = curPlayer.GetFreePoint()

        addPoint = GetLvUp_AddPoint(curPlayer)

@@ -3671,15 +3697,6 @@
        return True

    

    #---------------------------------------------------------------------

    ## 获取下一次转生所需等级

    def GetNextReincarnationLV(self, curPlayer):

        Reincarnation_ConditionDict = ReadChConfig.GetEvalChConfig("Reincarnation_Condition")

        curReinCnt = curPlayer.GetReincarnationLv() # 当前转生次数

        nextReinCnt = curReinCnt + 1

        nextReinLV = IpyGameDataPY.GetFuncCfg("PlayerMaxLV")

        if nextReinCnt in Reincarnation_ConditionDict:

            nextReinLV = Reincarnation_ConditionDict[nextReinCnt][0]

        return nextReinLV

    

    ## 加经验值 

    #  @param self 类实例

@@ -3710,7 +3727,6 @@
        if addExp == 0:

            # 不进入计算

            return addExp, expViewType

        #nextReinLV = self.GetNextReincarnationLV(curPlayer)

        

        #取得人物当前经验

        #curTotalExp = GetPlayerTotalExp(curPlayer)

@@ -3756,7 +3772,7 @@
        # if expViewType == ShareDefine.Def_ViewExpType_KillNPC:

        #    #mapID = GameWorld.GetMap().GetMapID()

        #    #if mapID in ChConfig.Def_FBMapID_BZZDAll:

        #    #    nobleVIPOuterRate = PlayerCostVIP.GetBZZDExpAddRate(curPlayer)

        #    #    nobleVIPOuterRate = ...

        #    #    #nobleVIPAddExp += 0 if not nobleVIPOuterRate else int(addExp * nobleVIPOuterRate / float(ChConfig.Def_MaxRateValue))

        #    #    nobleVIPAddExp += nobleVIPOuterRate

        #    

@@ -4051,8 +4067,10 @@
            pointFuncInfo[1](curPlayer, curPQLV)

            if not curPQLV:

                continue

            pqAttrID = ipyData.GetPointQualityAttrID()

            pqAttrValueList = ipyData.GetPointQualityAttrValueList()

            pqAttrIDDict = ipyData.GetPointQualityAttrIDDict()

            pqAttrID = pqAttrIDDict[curPlayer.GetJob()]

            pqAttrValueDict = ipyData.GetPointQualityAttrValueDict()

            pqAttrValueList = pqAttrValueDict[str(curPlayer.GetJob())]

            pqAttrValue = 0 if curPQLV > len(pqAttrValueList) else pqAttrValueList[curPQLV - 1]

            CalcAttrDict_Type(pqAttrID, pqAttrValue, lingGenQualityAttrList)

            #GameWorld.DebugLog("        属性点(%s)品阶等级属性: curPQLV=%s,pqAttrID=%s,pqAttrValue=%s" % (pointAttrID, curPQLV, pqAttrID, pqAttrValue))

@@ -4237,40 +4255,34 @@
    

    def RefreshPlayerAttrStateEx(self):

        ''' 本项目刷属性规则

                功能属性层级一(线性层级、非线性层级)

                功能属性层级二(线性层级、非线性层级)

                ...

                固定属性层级

              buff层级

              
            1. 初始化

                    属性：

            1.固定属性：如攻击+100

            2.百分比属性： 如攻击+5%，百分比加成基值仅为固定属性，百分比加成属性值不被除buff百分比外的任何百分比属性二次加成

            

            功能属性层级一、

            2.基础属性计算

            3.战斗属性计算

                线性层级属性:  基础层级属性 + 功能层级属性

                    基础层级属性：角色基础属性（等级提升 + 属性点提升） + 装备物品表基础属性 + 部位强化基础属性

                    功能层级属性：神兵 + 坐骑 + 全身部位强化星级累加 + 珍品 + 时装 + 套装 + 宝石 + 战盟科技 + 符文 + 守护 等

                    层级：

            1.属性层级：所有功能同一层级

            2.buff层级：百分比可对功能百分比加成的属性进行二次加成

            
                    功能模块：定义一个功能，比如灵根模块，一个模块可能包含多个功能点

                    功能点：某个模块下的各个属性功能点，如灵根模块可能包含 灵根基础、灵根品质 两个功能点属性

        
                    百分比加成值：百分比加成属性值不被除buff百分比外的任何百分比属性2次加成

            1.功能内部属性百分比加成：功能百分比属性对自己功能固定值加成

            2.功能交叉属性百分比加成：功能百分比属性对其他功能固定值加成

            3.功能固定属性百分比加成：功能百分比属性对所有功能固定值加成

            4.buff层级百分比：对所有属性进行二次加成

            
                    技能属性：固定值不享受固定百分比加成

                    

                                    注意：该层中还包含针对基础属性或功能属性的数值百分比提升，此提升值也是累加到线性层级属性

                                    如: 【基础攻击百分比】即对 基础属性 中攻击属性百分比提升

                                    【神兵生命属性百分比】即对 神兵功能属性 中生命属性百分比提升

                                    类似此类属性并不是真正意义上的非线性属性，仅是对某个功能或功能组的对应属性进行百分比提升，最终的提升值还是算如线性属性层

                    
                非线性层级属性: 即整体层级百分比增加属性

                    直接以当前属性为基值进行属性百分比提升

            功能属性层级二、

            ...

              
            4.固定属性:

                    附加的固定值属性，该属性在非线性计算之后，直接累加，不算入非线性属性的基值

        buff层级：

            1.不算战力

            2.先算百分比加成再加固定值

            

            5.计算以上所有属性的战斗力

            
            6.buff层级：

                    固定值buff， 直接累加数值

                    百分比buff： 真正的最最最外层，直接按百分比提升对应的属性值

                    注：该层提升的属性不算战斗力

                    属性算法：

                       模块固定属性    = 功能点A固定值 + 功能点B固定值 + ...

                        固定总属性        = 模块A固定值 + 模块B固定值 + ...

                        无buff总属性  = 固定总属性 + 内部百分比加成值 + 交叉百分比加成  + 固定总属性百分比加成   + 技能百分比对固定属性加成  + 技能固定值

                        含buff总属性  = 无buff总属性 * buff百分比加成  +  buff固定值

        '''

        curPlayer = self.__Player

        

@@ -4296,7 +4308,7 @@
        notAttrList = [{} for _ in range(4)]

        

        # 1.初始化人物各项状态及属性

        self.InitPlayerState()        
        self.InitPlayerState()

        #self.PrintAttr(curPlayer, "初始化")

        

        # 功能属性层级一...

@@ -4304,21 +4316,19 @@
        #    2.1 获取所有功能计算点计算的属性值, 统计基础属性累加

        baseAttrDict = {}

        baseAttrNolineDict = {}

        funcAttrInfoList = []

        funcAttrLen = len(ChConfig.CalcAttrFuncList)

        funcAttrInfoList = [[{} for _ in range(4)]] * funcAttrLen

        funcInsidePerAttrList = [{}] * funcAttrLen # 功能内部百分比附加属性

        for funcIndex in ChConfig.CalcAttrFuncList:

            if funcIndex in ChConfig.CalcAttrExFuncListNoFightPower:

                # 此类功能不算战斗力

                funcAttrInfoList.append([{} for _ in range(4)]) # 只为防止后面访问列表元素时不越界, 功能点分类可无视编号顺序

                continue

            
            # 基础属性等功能汇总完后统一刷新，因为各功能可能会加属性点数

            if funcIndex in [ChConfig.Def_CalcAttrFunc_RoleBase, ChConfig.Def_CalcAttrFunc_LingGenQuailty]:

                funcAttrInfoList.append([{} for _ in range(4)])

                continue

            attrInfo = GetCalcAttrListValue(curPlayer, funcIndex)

            if attrInfo != notAttrList:

                GameWorld.DebugLog("功能点属性: %s, %s" % (funcIndex, attrInfo))

            funcAttrInfoList.append(attrInfo)

            attrInfo, insidePerAttrDict = GetCalcAttrListValue(curPlayer, funcIndex)

            if attrInfo == notAttrList and not insidePerAttrDict:

                continue

            GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (funcIndex, attrInfo, insidePerAttrDict))

            funcAttrInfoList[funcIndex] = attrInfo

            funcInsidePerAttrList[funcIndex] = insidePerAttrDict

            # 不同功能点间的数值累加，需使用支持衰减递增的计算方式

            AddAttrDictValue(baseAttrDict, attrInfo[ChConfig.CalcAttr_Base])

            AddAttrDictValue(baseAttrNolineDict, attrInfo[ChConfig.CalcAttr_BaseNoline])

@@ -4332,12 +4342,14 @@
            

        # 功能有加基础属性值，这里再重新刷新一下基础属性, 基础属性会影响战斗属性, 每次都刷新角色基础属性

        self.CalcRoleBaseAttr(curPlayer)

        roleBaseAttrInfo = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase)

        lingGenQualityAttrList = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty)

        roleBaseAttrInfo, roleInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase)

        lingGenQualityAttrList, lingGenQualityInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty)

        funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleBaseAttrInfo

        funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleInsidePerAttrDict

        funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] =  lingGenQualityAttrList

        GameWorld.DebugLog("功能点属性: %s, %s" % (ChConfig.Def_CalcAttrFunc_RoleBase, roleBaseAttrInfo))

        GameWorld.DebugLog("功能点属性: %s, %s" % (ChConfig.Def_CalcAttrFunc_LingGenQuailty, lingGenQualityAttrList))

        funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] =  lingGenQualityInsidePerAttrDict

        GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (ChConfig.Def_CalcAttrFunc_RoleBase, roleBaseAttrInfo, roleInsidePerAttrDict))

        GameWorld.DebugLog("功能点属性: %s, %s, 内层百分比附加: %s" % (ChConfig.Def_CalcAttrFunc_LingGenQuailty, lingGenQualityAttrList, lingGenQualityInsidePerAttrDict))

        

        #self.PrintAttr(curPlayer, "基础后")

        

@@ -4364,7 +4376,7 @@
                           ChConfig.TYPE_Calc_WingHPPer:funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Wing],

                           }

        #    3.2 统计各功能之间非线性属性交叉影响累加

        funcAddAttrPerInfoDict = {} # 百分比交叉影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}

        funcCrossAttrPerInfoDict = {} # 百分比交叉影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}

        for i, funcAttrList in enumerate(funcAttrInfoList):

            battleNoLineAttrDict = funcAttrList[ChConfig.CalcAttr_BattleNoline] # 暂写死只取战斗非线性的

            if not battleNoLineAttrDict:

@@ -4390,80 +4402,90 @@
            if addAttrDict:

                # 增加的数值统计到百分比属性所属功能点

                # 如符文有个武器攻击百分比增加属性，增加的数值属于符文功能，不属于武器功能点的，只是基值使用了武器攻击     

                funcAddAttrPerInfoDict[i] = addAttrDict # 先都统计完后再累加到对应功能属性里，不然可能会导致功能基值变更

                funcCrossAttrPerInfoDict[i] = addAttrDict # 先都统计完后再累加到对应功能属性里，不然可能会导致功能基值变更

                

        GameWorld.DebugLog("交叉影响属性: %s" % funcAddAttrPerInfoDict)

        #        交叉提升的属性值累加到对应功能上

        for i, addAttrDict in funcAddAttrPerInfoDict.items():

            # 这里累加的是到相同的功能点，直接累加，不做衰减处理

            GameWorld.AddDictValue(funcAttrInfoList[i][ChConfig.CalcAttr_Battle], addAttrDict)

        GameWorld.DebugLog("交叉影响属性: %s" % funcCrossAttrPerInfoDict)

        
        #    3.3 统计所有功能固定属性影响累加

        allFixAttrDict = {} # 固定属性层级总属性基值

        for funcIndex, funcAttrList in enumerate(funcAttrInfoList):

            # 技能模块不算计入功能固定属性、不计战力

            if funcIndex in ChConfig.CalcAttrFuncSkillList:

                continue

            AddAttrDictValue(allFixAttrDict, funcAttrList[ChConfig.CalcAttr_Battle])

            

        #    3.3 累加以上已统计的所有属性（视为整体层级，即非线性属性所需要的基值）

        allFuncAttrIndexList = []

        allFuncAttrInfoList, attrInfoExList = [], [] # 整理功能层级属性信息列表, 额外附加固定值属性信息列表

        for funcIndex, attrInfo in enumerate(funcAttrInfoList):

            if funcIndex not in ChConfig.CalcAttrExFuncList:

                allFuncAttrIndexList.append(funcIndex)

                allFuncAttrInfoList.append(attrInfo)

            else:

                attrInfoExList.append(attrInfo)

        allAttrList = AddAttrListValue(allFuncAttrInfoList) # 不同功能点间的数值累加，需使用支持衰减递增的计算方式

        GameWorld.DebugLog("整体层级功能点: %s" % allFuncAttrIndexList)

        GameWorld.DebugLog("整体层级线性属性: %s" % allAttrList)

        
        #        第二层级属性

        allAttrExList = AddAttrListValue(attrInfoExList)

        GameWorld.DebugLog("附加层级功能点: %s" % ChConfig.CalcAttrExFuncList)

        GameWorld.DebugLog("附加层级线性属性: %s" % allAttrExList)

        
        #        初始化各功能点战斗力计算模块

        mfpObjAttrDict = {}

        for mfpType, attrFuncIndexList in ChConfig.MFPTypeAttrFuncIndexDict.items():

            if len(attrFuncIndexList) == 1:

                mfpAttrList = funcAttrInfoList[attrFuncIndexList[0]]

            else:

                mfpAttrList = AddAttrListValue([funcAttrInfoList[i] for i in attrFuncIndexList])

        fixAttrPerAddExDict = {} # 固定总属性百分比影响所提升的属性值 {功能属性编号:{提升的属性类型:数值, ...}, ...}

        for funcIndex, funcAttrList in enumerate(funcAttrInfoList):

            fixAddPerDict = funcAttrList[ChConfig.CalcAttr_BattleNoline]

            if not fixAddPerDict:

                continue

            addValueExDict = {}

            for fixAttrType, addPer in fixAddPerDict.items():

                if fixAttrType not in allFixAttrDict:

                    continue

                curFixValue = allFixAttrDict[fixAttrType]

                addValueEx = int(curFixValue * addPer / 10000.0)

                addValueExDict[fixAttrType] = addValueEx

            fixAttrPerAddExDict[funcIndex] = addValueExDict

            

            #GameWorld.DebugLog("模块线性属性: mfpType=%s,%s" % (mfpType, mfpAttrList))

            mfpObj = self.GetModuleFightPowerObj(mfpType)

            mfpObj.SetCalcMFPBattleAttr(mfpAttrList)

            mfpObjAttrDict[mfpObj] = mfpAttrList[ChConfig.CalcAttr_BattleNoline]

            
        #         不加战力，但是有算属性的功能属性，如一些被动技能（战力在技能表里配置）

        skillNoFightPowerAttrList = [{} for _ in range(4)]

        SkillShell.CalcPassiveAttr_Effect(curPlayer, skillNoFightPowerAttrList)  # 属性类技能与buff同层

        for funcIndex in ChConfig.CalcAttrExFuncListNoFightPower:

            skillNoFightPowerAttrList = AddAttrListValue([skillNoFightPowerAttrList, GetCalcAttrListValue(curPlayer, funcIndex)])    
        GameWorld.DebugLog("无战力被动属性: %s" % skillNoFightPowerAttrList)

        GameWorld.DebugLog("固定属性总和: %s" % allFixAttrDict)

        GameWorld.DebugLog("固定百分比附加属性: %s" % fixAttrPerAddExDict)

        

        # 总属性 = 整体功能层级固定值*(1+功能层级百分比+特殊固定层级百分比+永久技能层级百分比)+特殊固定层级固定值+永久技能层级固定值

        allNoLineAttrDict = {}

        AddAttrDictValue(allNoLineAttrDict, allAttrList[ChConfig.CalcAttr_BattleNoline])

        AddAttrDictValue(allNoLineAttrDict, allAttrExList[ChConfig.CalcAttr_BattleNoline])

        AddAttrDictValue(allNoLineAttrDict, skillNoFightPowerAttrList[ChConfig.CalcAttr_BattleNoline])

        GameWorld.DebugLog("最终非线性属性: %s" % allNoLineAttrDict)

        
        #        整体层级属性增加到玩家身上

        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, allAttrList[ChConfig.CalcAttr_Battle])

        #self.PrintAttr(curPlayer, "整体线")

        CalcNoLineEffect.ChangePlayerAttrInNoLineEffectList(curPlayer, allNoLineAttrDict, mfpObjAttrDict)

        #self.PrintAttr(curPlayer, "整非线")

        
        
        # 4.计算战力, 需在计算buff层之前计算

        # 4. 计算属性及战力, 需在计算buff层之前计算

        curLV = curPlayer.GetLV()

        fpParam = IpyGameDataPY.GetIpyGameData("FightPowerParam", curLV)

        mfpDict = {} # 模块战斗力

        for mfpObj in mfpObjAttrDict.keys():

            mfp = 0 if not fpParam else mfpObj.GetModuleFightPower(fpParam)

            mfp += curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpObj.mfpType)

            mfp += curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpObj.mfpType)

            mfpDict[mfpObj.mfpType] = mfp

        for mfpType, attrFuncIndexList in ChConfig.MFPTypeAttrFuncIndexDict.items():

            mfpAttrList = [{} for _ in range(4)]

            mfpAttrExDict = {}

            for funcIndex in attrFuncIndexList:

                funcAttrList = funcAttrInfoList[funcIndex]

                funcInsidePerAttrDict = funcInsidePerAttrList[funcIndex] # 功能点内部百分比加成属性

                funcCrossPerAttrDict = funcCrossAttrPerInfoDict.get(funcIndex, {}) # 功能点交叉百分比加成属性

                fixPerAttrDict = fixAttrPerAddExDict.get(funcIndex, {}) # 功能总固定属性百分比加成属性

                
                CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcAttrList[ChConfig.CalcAttr_Battle])

                CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcInsidePerAttrDict)

                CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, funcCrossPerAttrDict)

                CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, fixPerAttrDict)

                # 不算战力的

                if funcIndex in ChConfig.CalcAttrFuncNoFightPowerList or funcIndex in ChConfig.CalcAttrFuncSkillList:

                    continue

                mfpAttrList = AddAttrListValue([mfpAttrList, funcAttrList])

                AddAttrDictValue(mfpAttrExDict, funcInsidePerAttrDict)

                AddAttrDictValue(mfpAttrExDict, funcCrossPerAttrDict)

                AddAttrDictValue(mfpAttrExDict, fixPerAttrDict)

                
            mfpObj = self.GetModuleFightPowerObj(mfpType)

            mfpObj.SetCalcMFPBattleAttr(mfpAttrList)

            for attrIndex, value in mfpAttrExDict.items():

                mfpObj.AddCalcMFPAttr(attrIndex, value)

                
            mfpValue = 0 if not fpParam else mfpObj.GetModuleFightPower(fpParam)

            mfpSkill = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpObj.mfpType)

            mfpEx = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpObj.mfpType)

            mfpTotal = mfpValue + mfpSkill + mfpEx

            mfpDict[mfpObj.mfpType] = mfpTotal

            

        #        最后在附加上特殊附加层级线性属性、永久技能层级固定值

        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, allAttrExList[ChConfig.CalcAttr_Battle])

        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, skillNoFightPowerAttrList[ChConfig.CalcAttr_Battle])

        #self.PrintAttr(curPlayer, "固定层级")

        #GameWorld.DebugLog("整体层级线性属性: %s" % allAttrList)

        
        # 5.被动技能附加属性，不算战力

        passiveSkillAttrList = [{} for _ in range(4)]

        SkillShell.CalcPassiveAttr_Effect(curPlayer, passiveSkillAttrList)  # 属性类技能与buff同层

        for funcIndex in ChConfig.CalcAttrFuncSkillList:

            passiveSkillAttrList = AddAttrListValue([passiveSkillAttrList, funcAttrInfoList[funcIndex]])    
        GameWorld.DebugLog("无战力被动属性: %s" % passiveSkillAttrList)

        
        skillFixAttrExDict = {}

        skillFixAddPerDict = passiveSkillAttrList[ChConfig.CalcAttr_BattleNoline]

        for fixAttrType, addPer in skillFixAddPerDict.items():

            if fixAttrType not in allFixAttrDict:

                continue

            curFixValue = allFixAttrDict[fixAttrType]

            addValueEx = int(curFixValue * addPer / 10000.0)

            skillFixAttrExDict[fixAttrType] = addValueEx

        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, passiveSkillAttrList[ChConfig.CalcAttr_Battle])

        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, skillFixAttrExDict)

        

        #护盾值刷新

        self.__RefreshMaxProDef(beforeMaxProDef)

@@ -5379,35 +5401,6 @@
    if BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_LimitSuperBuff, tick):

    

        PlayerControl(curPlayer).RefreshPlayerAttrByBuff()



#---------------------------------------------------------------------

##清除生产采集BUF

# @param curPlayer 玩家实例

# @param tick 时间戳

# @param isLeaveServer 玩家是否离开服务器

# @return 返回值无意义

# @remarks 清除生产采集BUF

def DelProduceBuff(curPlayer, tick, isLeaveServer=False):

    
    if not isLeaveServer:

        if curPlayer.GetPlayerAction() != IPY_GameWorld.paProduce:

            #玩家当前状态不在生产采集，不处理

            return

    
    #清除生产buff(ID20021)

    BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_ProduceBuffID, tick)

    
    #清除活动无敌Buff

    BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_ActionWuDi, tick)

    
    if not isLeaveServer:

        #设置玩家空闲状态

        ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)

        #通知客户端

        curPlayer.Notify_ProductionState(ChConfig.Def_EndProduction)

        
        #PlayerControl(curPlayer).RefreshAllState()

    return

    

#---------------------------------------------------------------------

##特殊状态处理

@@ -6135,6 +6128,19 @@
        GameWorld.AddDictValue(attrDict, {i:value})

    return



def CalcAttrDict_TypeEx(attrType, value, allAttrDict):

    ## 统计玩家属性，累加

    if value == 0:

        return

    
    #[属性索引, 是否基础属性，(非)线性]

    attrInfo = ChConfig.ItemEffect_AttrDict.get(attrType, [])

    if attrInfo == []:

        return

    for i in attrInfo[0]:

        GameWorld.AddDictValue(allAttrDict, {i:value})

    return



#===============================================================================

# CalcAttr_Base,

# CalcAttr_BaseNoline,

@@ -6584,6 +6590,19 @@
def GetFuncDef(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CopyFuncAttr % (ChConfig.TYPE_Calc_AttrDEF - 1))

def SetFuncDef(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_CopyFuncAttr % (ChConfig.TYPE_Calc_AttrDEF - 1), value)



#普通攻击增伤：普通攻击附加的固定值伤害

def GetNormalHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NormalHurt)

def SetNormalHurt(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_NormalHurt, value)

#普通攻击加成：普通攻击附加的伤害百分比

def GetNormalHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NormalHurtPer)

def SetNormalHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_NormalHurtPer, value)

#法宝技能增伤：法宝技能攻击附加的固定值伤害

def GetFabaoHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FabaoHurt)

def SetFabaoHurt(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FabaoHurt, value)

#法宝技能加成：法宝技能攻击附加的伤害百分比

def GetFabaoHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FabaoHurtPer)

def SetFabaoHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FabaoHurtPer, value)



## 计算功能背包物品属性 

#  @param curPlayer 当前玩家

#  @param packType 背包类型

@@ -6626,7 +6645,7 @@
#-------------------------------------------------------------------------------



## 设置保存功能事先计算好的属性值

def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList):

def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList, insidePerAttrDict={}):

    # 设置值之前先清空重置

    ClearCalcAttrListValue(curPlayer, funcIndex)

    

@@ -6646,32 +6665,34 @@
    if playerID not in PyGameData.g_playerFuncAttrDict:

        PyGameData.g_playerFuncAttrDict[playerID] = {}

    funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]

    funcAttrDict[funcIndex] = allAttrList

    #GameWorld.DebugLog("保存功能点属性: funcIndex=%s, %s" % (funcIndex, allAttrList))

    funcAttrDict[funcIndex] = [allAttrList, insidePerAttrDict]

    #GameWorld.DebugLog("保存功能点属性: funcIndex=%s, %s, %s" % (funcIndex, allAttrList, insidePerAttrDict))

    return



def GetCalcAttrListValue(curPlayer, funcIndex):

    ## 获取功能点预先计算的所加属性值

    attrList = [{} for _ in range(4)]

    insidePerAttrDict = {}

    if isinstance(funcIndex, int):

        funcIndexList = [funcIndex]

    elif isinstance(funcIndex, list):

        funcIndexList = funcIndex

    else:

        return attrList

        return attrList, insidePerAttrDict

    

    playerID = curPlayer.GetPlayerID()

    if playerID not in PyGameData.g_playerFuncAttrDict:

        return attrList

        return attrList, insidePerAttrDict

    funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]

    for funcIndex in funcIndexList:

        if funcIndex not in funcAttrDict:

            continue

        funcAttrList = funcAttrDict[funcIndex]

        funcAttrList, funcInsidePerAttrDict = funcAttrDict[funcIndex]

        for i, attrDict in enumerate(attrList):

            curAttrDict = funcAttrList[i]

            AddAttrDictValue(attrDict, curAttrDict)

    return attrList

        AddAttrDictValue(insidePerAttrDict, funcInsidePerAttrDict)

    return attrList, insidePerAttrDict



## 重置缓存

def ClearCalcAttrListValue(curPlayer, funcIndex):