Project_SG_ServerCode.git

#!/usr/bin/python 
# -*- coding: GBK -*- 
#------------------------------------------------------------------------------- 
# 
##@package Player.PlayerFamilyTaofa 
# 
# @todo:¹«»áÌÖ·¥ 
# @author hxp 
# @date 2025-10-24 
# @version 1.0 
# 
# ÏêÏ¸ÃèÊö: ¹«»áÌÖ·¥ 
# 
#------------------------------------------------------------------------------- 
#"""Version = 2025-10-24 19:00""" 
#------------------------------------------------------------------------------- 
 
import ChConfig 
import ShareDefine 
import IpyGameDataPY 
import NetPackCommon 
import ChPyNetSendPack 
import PlayerViewCache 
import ItemControler 
import PlayerControl 
import PlayerFamily 
import CrossPlayer 
import GameWorld 
import DBDataMgr 
 
import time 
 
ActionType = ShareDefine.Def_ActionType_Taofa 
ActionGlobalID = 1 # È«¾Ö¼ÇÂ¼ID 
 
# È«¾Ö¼ÇÂ¼ 
#Time        ÖØÖÃÊ±¼ä´Á£¬Ç°¶Ë¿ÉÓÃÓÚÅÐ¶ÏÊÇ·ñ±ä¸üÁË²»Í¬µÄÌÖ·¥£¬ÈçGMÃüÁî£¨±ä¸üºó£¬Ç°¶Ë¿ÉÖØÖÃ¹¦ÄÜÏà¹Ø»º´æÊý¾Ý£©£¬ºó¶ËÄ¬ÈÏOnDay±ä¸ü 
#Value1    ActionGlobalID 
def GetFABuzhenEndTime(gActionData): return gActionData.GetValue2() # ²¼Õó²ã¼¶µ½ÆÚÊ±¼ä´Á 
def SetFABuzhenEndTime(gActionData, gEndTime): return gActionData.SetValue2(gEndTime) 
def GetFABuzhenLayer(gActionData): return gActionData.GetValue3() # µ±Ç°ÓÐÐ§²¼Õó²ã¼¶ 
def SetFABuzhenLayer(gActionData, gLayer): return gActionData.SetValue3(gLayer) 
 
# ³ÉÔ±¼ÇÂ¼ 
#Time        ×îºóÒ»´Î¸üÐÂÊ±¼ä£¬¿ÉÄÜÊÇ²¼Õó»ò¹¥»÷£¬¿ÉÓÃÓÚ±¦Ïä¼ÇÂ¼µÄÅÅÐò 
def SetFAAtkTime(actionData, atkTime): return actionData.SetTime(atkTime) # ×îºóÒ»´Î¹¥»÷Ê±¼ä´Á 
def GetFAPlayerID(actionData): return actionData.GetValue1() # ³ÉÔ±ID 
def SetFAPlayerID(actionData, playerID): return actionData.SetValue1(playerID) 
def GetFABuzhenTime(actionData): return actionData.GetValue2() # Íæ¼Ò²¼ÕóÊ±¼ä´Á£¬Îª0Ê±½ö´ú±íÃ»ÓÐÔÚ¸Ã¹«»á²¼Õó£¬²»´ú±íÍæ¼ÒÎ´²¼Õó 
def SetFABuzhenTime(actionData, bzTime): return actionData.SetValue2(bzTime) 
def GetFAAtkCount(actionData): return actionData.GetValue3() # µ½±¾¹«»áºó¹¥»÷´ÎÊý 
def SetFAAtkCount(actionData, faAtkCnt): return actionData.SetValue3(faAtkCnt) 
def GetFAHurtTotal(actionData): return actionData.GetValue4() # µ½±¾¹«»áºóÀÛ¼ÆÉËº¦£¬ÇóÓàÒÚ²¿·Ö£¬¿ÉÓÃÓÚÕ½¼¨ÅÅÐò 
def SetFAHurtTotal(actionData, faHurtTotal): return actionData.SetValue4(faHurtTotal) 
def GetFAHurtTotalEx(actionData): return actionData.GetValue5() # µ½±¾¹«»áºóÀÛ¼ÆÉËº¦£¬Õû³ýÒÚ²¿·Ö 
def SetFAHurtTotalEx(actionData, faHurtTotalEx): return actionData.SetValue5(faHurtTotalEx) 
def GetFAContribBoxCnt(actionData): return actionData.GetValue6() # µ½±¾¹«»áºó¹±Ï×±¦ÏäÊý 
def SetFAContribBoxCnt(actionData, faContribBoxCnt): return actionData.SetValue6(faContribBoxCnt) 
AtkIndexs = ( 
AtkIndex_AtkTime, 
AtkIndex_ContribBoxCnt, 
AtkIndex_HurtValue, 
AtkIndex_AtkType, 
) = range(4) 
#UserDict {"atkList":[[atkTime, ±¾´Î¹±Ï×Ïä×ÓÊý, ±¾´Î×ÜÉËº¦, atkType], ...], ...} 
#atkList = actionData.GetUserDict().get("atkList", []) 
#actionData.GetUserDict().update({"atkList":atkList}) 
#UserDict ´æ´¢µÄkey¶¨Òå 
UserKey_AtkList = "atkList" # ¹¥»÷¼ÇÂ¼ 
UserKey_Info = "info" # Àë¿ªÍæ¼Ò»ù±¾ÐÅÏ¢ 
 
AtkType_Normal = 0 # ³£¹æÕ¶É± 
AtkType_Anger = 1 # ÅÆøÕ¶É± 
 
def OnDay(family): 
    OnTaofaReset(family)      
    return 
 
def OnTaofaReset(family): 
    familyID = family.GetID() 
    actionMgr = DBDataMgr.GetFamilyActionMgr() 
    actionMgr.DelFamilyAction(familyID, ActionType) 
     
    familyAction = actionMgr.GetFamilyAction(familyID, ActionType) 
    gActionData = familyAction.AddAction() 
    SetFAPlayerID(gActionData, ActionGlobalID) 
    PlayerFamily.SendFamilyAction(gActionData) 
    return 
 
def OnCrossPlayerLogin(crossPlayer): 
    familyID = crossPlayer.GetFamilyID() 
    if not familyID: 
        return 
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID) 
    if not curFamily: 
        return 
    playerID = crossPlayer.GetPlayerID() 
    PlayerFamily.SendFamilyActionInfo(crossPlayer, familyID, ActionType) 
    memContribDict = GetMemContriBoxInfo(curFamily) 
    if memContribDict: 
        SyncMemContribInfo(curFamily, [playerID]) 
    return 
 
def OnCrossPlayerEnterFamily(crossPlayer): 
    ## Íæ¼Ò½øÈëÐÂ¹«»á 
    familyID = crossPlayer.GetFamilyID() 
    PlayerFamily.SendFamilyActionInfo(crossPlayer, familyID, ActionType) 
    return 
 
def OnFamilyMemberLeave(family, leavePlayerID): 
    ## ¹«»á³ÉÔ±É¾³ý£¬Õë¶Ô¹«»áµÄ´¦Àí 
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(family.GetID(), ActionType) 
    actionData = familyAction.GetActionDataByValue1(leavePlayerID, False) 
    if not actionData: 
        return 
    memInfo = PlayerViewCache.GetPlayerBaseViewInfo(leavePlayerID) 
    actionData.GetUserDict().update({UserKey_Info:memInfo}) 
    PlayerFamily.SendFamilyAction([actionData]) 
    return 
 
#// A6 13 ¹«»áÌÖ·¥ #tagCSFamilyTaofaOP 
# 
#struct    tagCSFamilyTaofaOP 
#{ 
#    tagHead     Head; 
#    BYTE    OpType;    // ²Ù×÷£º0-Õ¶É±¹¥»÷£»1-²¼Õó 
#}; 
def OnFamilyTaofaOP(index, clientData, tick): 
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index) 
    opType = clientData.OpType 
    playerID = curPlayer.GetPlayerID() 
    familyID = curPlayer.GetFamilyID() 
    if not familyID: 
        GameWorld.DebugLog("Ã»ÓÐÏÉÃËÎÞ·¨²Ù×÷!", playerID) 
        return 
     
    reqDataEx = {} 
     
    # ²¼Õó 
    if opType == 1: 
        if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState): 
            GameWorld.DebugLog("ÒÑ²¼Õó¹ý!", playerID) 
            return 
    # Õ¶É± 
    else: 
        _, _, maxAnger = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaAtk", 4) 
        anger = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaAnger) 
        atkType = AtkType_Anger if anger >= maxAnger else AtkType_Normal 
         
        atkCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaCnt) 
        if atkType == AtkType_Normal: 
            itemAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt) 
            freeCnt = IpyGameDataPY.GetFuncCfg("FamilyTaofaAtk", 1) 
            canAtkCnt = freeCnt + itemAddCnt - atkCnt 
            if canAtkCnt <= 0: 
                GameWorld.DebugLog("¹«»áÌÖ·¥Ã»ÓÐÕ¶É±´ÎÊý: atkCnt=%s >= freeCnt(%s) + itemAddCnt(%s)" % (atkCnt, freeCnt, itemAddCnt), playerID) 
                return 
             
        fightPower = PlayerControl.GetFightPower(curPlayer) 
        boxContribCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxContribCnt) 
        boxHurt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt) 
        boxHurtEx = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx) 
        boxHurtTotal = boxHurt + boxHurtEx * ChConfig.Def_PerPointValue 
        boxHurtHis = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHis) 
        boxHurtHisEx = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHisEx) 
        boxHurtTotalHis = boxHurtHis + boxHurtHisEx * ChConfig.Def_PerPointValue 
        reqDataEx = {"anger":anger, "atkType":atkType, "atkCnt":atkCnt, "fightPower":fightPower,  
                     "boxContribCnt":boxContribCnt, "boxHurtTotal":boxHurtTotal, "boxHurtTotalHis":boxHurtTotalHis} 
         
    PlayerFamily.FamilyPyPackForwarding(curPlayer, clientData, tick, "PlayerFamilyTaofa.__OnFamilyTaofaOP", True, 20, reqDataEx=reqDataEx) 
    return 
def __OnFamilyTaofaOP(crossPlayer, clientData, tick, fromServerID=0, reqDataEx=None): 
    opType = clientData.OpType 
    # ²¼Õó 
    if opType == 1: 
        __doBuzhen(crossPlayer) 
    else: 
        __doZhanshaAtk(crossPlayer, reqDataEx) 
         
    return True 
 
def __OnFamilyTaofaOP_Ret(curPlayer, clientData, isOK): 
    if not isOK: 
        return 
    SyncTaofaInfo(curPlayer) 
    return 
 
def __doBuzhen(crossPlayer): 
    ## ²¼Õó 
    playerID = crossPlayer.GetPlayerID() 
    familyID = crossPlayer.GetFamilyID() 
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID) 
    if not curFamily: 
        return 
    gLayer, gActionData = GetFamilyBuzhenLayer(familyID) 
    bzDuration = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 4) * 60 # ÓÐÐ§Ê±³¤Ãë 
    gEndTime = int(time.time()) + bzDuration # Ö±½Ó¸²¸Ç¸üÐÂ 
    gLayer += 1 # ²¼Õó²»ÏÞÖÆ´ÎÊý£¬Ö±½Ó¼Ó 
    #if not maxLayer or gLayer < maxLayer: 
    #    gLayer += 1 
     
    GameWorld.DebugLog("¹«»áÌÖ·¥²¼Õó: gLayer=%s,gEndTime=%s" % (gLayer, GameWorld.ChangeTimeNumToStr(gEndTime)), playerID) 
    # ¹«¹²ÐÅÏ¢ 
    SetFABuzhenEndTime(gActionData, gEndTime) 
    SetFABuzhenLayer(gActionData, gLayer) 
     
    # ³ÉÔ±ÐÅÏ¢ 
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType) 
    actionData = familyAction.GetActionDataByValue1(playerID, True) 
    SetFABuzhenTime(actionData, int(time.time())) 
     
    PlayerFamily.SendFamilyAction([gActionData, actionData]) 
     
    # ¸öÈË¼ÇÂ¼ 
    CrossPlayer.SetPlayerNomalDict(crossPlayer, {ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState:1}, True) 
    return 
 
def __doZhanshaAtk(crossPlayer, reqDataEx): 
    ## Õ¶É±¹¥»÷ 
    if not reqDataEx: 
        return 
    playerID = crossPlayer.GetPlayerID() 
    familyID = crossPlayer.GetFamilyID() 
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID) 
    if not curFamily: 
        return 
     
    commAddAnger, superAddAnger, maxAnger = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaAtk", 4) 
    atkTime = int(time.time()) 
     
    fightPower = reqDataEx.get("fightPower", 1) 
    anger = reqDataEx.get("anger", 0) 
    atkCnt = reqDataEx.get("atkCnt", 0) 
    atkType = reqDataEx.get("atkType", AtkType_Normal) 
    boxContribCnt = reqDataEx.get("boxContribCnt", 0) 
    boxHurtTotal = reqDataEx.get("boxHurtTotal", 0) 
    boxHurtTotalHis = reqDataEx.get("boxHurtTotalHis", 0) 
     
    # ¼ÆËãÊôÐÔ 
    gLayer, _ = GetFamilyBuzhenLayer(familyID) 
    maxLayer = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 3) 
    gLayer = min(gLayer, maxLayer) # ÏÞÖÆÉúÐ§µÄ×î´ó²¼Õó²ãÊý 
    superRate = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 1) 
    superRatio = IpyGameDataPY.GetFuncCfg("FamilyTaofaAtk", 3) # ±©»÷ÉËº¦±¶Öµ 
    addSuperRatePerLayer, addDamPerLayer = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaBuzhen", 2) 
    damRatio = 1 # ÉËº¦¼Ó³É 
    if gLayer > 0: 
        superRate += gLayer * addSuperRatePerLayer 
        damRatio += gLayer * addDamPerLayer / 10000.0 
     
    GameWorld.DebugLog("---¹«»áÌÖ·¥Õ¶É±: fightPower=%s,gLayer=%s,superRate=%s,superRatio=%s,damRatio=%s,anger=%s/%s,atkType=%s"  
                       % (fightPower, gLayer, superRate, superRatio, damRatio, anger, maxAnger, atkType), playerID) 
     
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType) 
    actionData = familyAction.GetActionDataByValue1(playerID, True) 
    faAtkCnt = GetFAAtkCount(actionData) 
    faContribBoxCnt = GetFAContribBoxCnt(actionData) 
    faHurtTotal = GetFAHurtTotal(actionData) + GetFAHurtTotalEx(actionData) * ChConfig.Def_PerPointValue 
    GameWorld.DebugLog("faAtkCnt=%s,faHurtTotal=%s,faContribBoxCnt=%s" % (faAtkCnt, faHurtTotal, faContribBoxCnt), playerID) 
     
    GameWorld.DebugLog("boxContribCnt=%s,boxHurtTotal=%s,boxHurtTotalHis=%s" % (boxContribCnt, boxHurtTotal, boxHurtTotalHis), playerID) 
     
    calcHurtCnt = 1 # ¼ÆËãÉËº¦´ÎÊý 
    if atkType == AtkType_Anger: # ÅÆø¹¥»÷ 
        anger -= maxAnger 
        calcHurtCnt = IpyGameDataPY.GetFuncCfg("FamilyTaofaAtk", 5) 
         
    hurtTotal = 0 # ±¾´Î×ÜÉËº¦ 
    hurtList = [] # ÉËº¦ÁÐ±í [ÉËº¦, ÊÇ·ñ±©»÷] 
    for i in range(calcHurtCnt): 
        isSuper = GameWorld.CanHappen(superRate) 
        # ¡¾×îÖÕÉËº¦¡¿= Õ½Á¦*£¨1+²¼ÕóÔöÉË£©* ±©»÷ÉËº¦±¶Öµ 
        hurtValue = int(fightPower * (superRatio if isSuper else 1) * damRatio) 
        hurtTotal += hurtValue 
        if atkType == AtkType_Normal: # ½ö³£¹æÕ¶É±¼ÓÅÆø 
            anger += (superAddAnger if isSuper else commAddAnger) 
        GameWorld.DebugLog("µÚ%s´ÎÉËº¦: isSuper=%s,hurtValue=%s,hurtTotal=%s,anger=%s,atkType=%s" % (i + 1, isSuper, hurtValue, hurtTotal, anger, atkType), playerID) 
        hurtList.append([hurtValue, isSuper]) 
         
    faAtkCnt += calcHurtCnt 
    faHurtTotal += hurtTotal 
    boxHurtTotal += hurtTotal 
    GameWorld.DebugLog("¸üÐÂÀÛ¼ÆÉËº¦: faAtkCnt=%s,faHurtTotal=%s,boxHurtTotal=%s" % (faAtkCnt, faHurtTotal, boxHurtTotal), playerID) 
     
    # ¼ÆËã¹±Ï×ºÐ×ÓÊý 
    updContribBoxCnt = 0 
    boxAwardHurtList = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaBox", 1) 
    contribBoxMax = min(IpyGameDataPY.GetFuncCfg("FamilyTaofaBox", 2), 1000) # ¿É¹±Ï×µÄ×î´óÏä×ÓÊý 
    for needHurt in boxAwardHurtList: 
        if boxHurtTotal < needHurt: 
            break 
        updContribBoxCnt += 1 
    finalAwardHurt = boxAwardHurtList[-1] # ×îºóÒ»µµ×î´óÉËº¦Öµ 
    loopNeedHurt = (finalAwardHurt - boxAwardHurtList[-2]) if len(boxAwardHurtList) > 1 else finalAwardHurt # ×îºóÒ»µµËùÐèÉËº¦Öµ 
    GameWorld.DebugLog("¼ÆËã³£¹æ¹±Ï×±¦Ïä: updContribBoxCnt=%s,boxHurtTotal=%s,finalAwardHurt=%s" % (updContribBoxCnt, boxHurtTotal, finalAwardHurt), playerID) 
    if boxHurtTotal > finalAwardHurt: 
        loopHurtTotal = boxHurtTotal - finalAwardHurt 
        loopContribBoxCnt = loopHurtTotal / loopNeedHurt 
        updContribBoxCnt = min(updContribBoxCnt + loopContribBoxCnt, contribBoxMax) 
        GameWorld.DebugLog("¼ÆËãÑ»·¹±Ï×±¦Ïä: updContribBoxCnt=%s,loopHurtTotal=%s,loopNeedHurt=%s,loopContribBoxCnt=%s,contribBoxMax=%s"  
                           % (updContribBoxCnt, loopHurtTotal, loopNeedHurt, loopContribBoxCnt, contribBoxMax), playerID) 
         
    setPlayerDict = {} # ¸üÐÂÍæ¼ÒÓÀ¾ÃµÄ×ÖµäÖµ 
    setPlayerDayDict = {} # ¸üÐÂÍæ¼ÒÃ¿ÈÕÖØÖÃµÄ×ÖµäÖµ 
    addContribCnt = 0 
    if updContribBoxCnt > boxContribCnt: 
        addContribCnt = updContribBoxCnt - boxContribCnt 
        faContribBoxCnt += addContribCnt 
        setPlayerDayDict[ChConfig.Def_Player_Dict_FamilyTaofaBoxContribCnt] = updContribBoxCnt 
        GameWorld.DebugLog("¸üÐÂÔö¼Ó¹±Ï×±¦Ïä: addContribCnt=%s,updContribBoxCnt=%s,faContribBoxCnt=%s" % (addContribCnt, updContribBoxCnt, faContribBoxCnt), playerID) 
         
    setPlayerDayDict[ChConfig.Def_Player_Dict_FamilyTaofaAnger] = anger 
    setPlayerDayDict[ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt] = boxHurtTotal % ChConfig.Def_PerPointValue 
    setPlayerDayDict[ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx] = boxHurtTotal / ChConfig.Def_PerPointValue 
    if boxHurtTotal > boxHurtTotalHis: 
        boxHurtTotalHis = boxHurtTotal 
        setPlayerDict[ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHis] = boxHurtTotalHis % ChConfig.Def_PerPointValue 
        setPlayerDict[ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHisEx] = boxHurtTotalHis / ChConfig.Def_PerPointValue 
         
    awardItemList = [] 
    # ³£¹æ¹¥»÷: ¸øÕ¶É±¹¥»÷½±Àø£¬¼Ó´ÎÊý 
    if atkType == AtkType_Normal: 
        setPlayerDayDict[ChConfig.Def_Player_Dict_FamilyTaofaCnt] = atkCnt + 1 
        atkItemAwardList = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaAtk", 2) # Ã¿´ÎÕ¶É±»ñµÃ¸öÈË½±ÀøÁÐ±í [[ÎïÆ·ID,¸öÊý], ...] 
        awardItemList += atkItemAwardList 
         
    CrossPlayer.SetPlayerNomalDict(crossPlayer, setPlayerDayDict, True) 
    if setPlayerDict: 
        CrossPlayer.SetPlayerNomalDict(crossPlayer, setPlayerDayDict, False) 
    if awardItemList: 
        CrossPlayer.GivePlayerResources(crossPlayer, awardItemList, eventName="FamilyTaofa", isNotifyAward=False) 
         
    # ¸üÐÂAction¼ÇÂ¼ 
    SetFAAtkTime(actionData, atkTime) 
    SetFAAtkCount(actionData, faAtkCnt) 
    SetFAHurtTotal(actionData, faHurtTotal % ChConfig.Def_PerPointValue) 
    SetFAHurtTotalEx(actionData, faHurtTotal / ChConfig.Def_PerPointValue) 
    SetFAContribBoxCnt(actionData, faContribBoxCnt) 
    atkList = actionData.GetUserDict().get(UserKey_AtkList, []) 
    atkList.append([atkTime, addContribCnt, hurtTotal, atkType]) 
    actionData.GetUserDict().update({UserKey_AtkList:atkList}) 
    PlayerFamily.SendFamilyAction([actionData]) 
     
    # Í¬²½£º ¹¥»÷ -> ±¦Ïä -> ÆäËû 
    SyncTaofaAtkRet(crossPlayer, atkType, hurtList, awardItemList) 
    if addContribCnt: 
        SyncMemContribInfo(curFamily) 
    return 
 
def SyncMemContribInfo(curFamily, onlyIDList=[]): 
    memContribDict = GetMemContriBoxInfo(curFamily) 
    if not memContribDict: 
        return 
    CrossPlayer.SendToFamilyPlayer(curFamily.GetID(), ShareDefine.C2S_TaofaMemContrib, {"memContribDict":memContribDict},  
                                   onlyIDList=onlyIDList, havePlayerCall=__doUpdPlayerAwardBoxCnt) 
    return 
 
def GetFamilyBuzhenLayer(familyID): 
    ## »ñÈ¡²¢Ë¢ÐÂµ±Ç°¹«»áÓÐÐ§²¼Õó²ãÊý 
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType) 
    gActionData = familyAction.GetActionDataByValue1(ActionGlobalID, True) 
    gEndTime = GetFABuzhenEndTime(gActionData) 
    gLayer = GetFABuzhenLayer(gActionData) 
    if (gEndTime or gLayer) and int(time.time()) > gEndTime: 
        SetFABuzhenEndTime(gActionData, 0) 
        SetFABuzhenLayer(gActionData, 0) 
        #PlayerFamily.SendFamilyAction(gActionData) Ê§Ð§²»ÓÃÍ¬²½£¬Ç°¶Ë¸ù¾ÝEndTimeÅÐ¶Ï¼´¿É 
        gEndTime = 0 
        gLayer = 0 
    return gLayer, gActionData 
 
def GetMemContriBoxInfo(family): 
    ## »ñÈ¡¹«»á³ÉÔ±¹±Ï×±¦Ïä¼ÇÂ¼ 
    if not family: 
        return {} 
    familyID = family.GetID() 
    memContribDict = {}       
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType) 
    for index in range(0, familyAction.Count()): 
        actionData = familyAction.At(index) 
        memID = GetFAPlayerID(actionData) 
        if memID == ActionGlobalID: 
            continue 
        contribList = [] 
        atkList = actionData.GetUserDict().get("atkList", []) 
        for atkInfo in atkList: 
            atkTime = atkInfo[AtkIndex_AtkTime] 
            contribBoxCnt = atkInfo[AtkIndex_ContribBoxCnt] 
            if contribBoxCnt > 0: 
                contribList.append([atkTime, contribBoxCnt]) 
        if contribList: 
            memContribDict[memID] = contribList 
    return memContribDict 
 
def GMAddMemTaofaAtk(crossPlayer, curFamily, playerID, hurtValue, isAnger): 
    ## GMÌí¼Ó¼ÙµÄÌÖ·¥Êý¾Ý 
     
    familyID = curFamily.GetID() 
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType) 
    actionData = familyAction.GetActionDataByValue1(playerID, True) 
     
    faAtkCnt = GetFAAtkCount(actionData) 
    faContribBoxCnt = GetFAContribBoxCnt(actionData) 
    faHurtTotal = GetFAHurtTotal(actionData) + GetFAHurtTotalEx(actionData) * ChConfig.Def_PerPointValue 
     
    atkType = AtkType_Normal 
    calcHurtCnt = 1 # ¼ÆËãÉËº¦´ÎÊý 
    if isAnger: 
        atkType = AtkType_Anger # ÅÆø¹¥»÷ 
        calcHurtCnt = IpyGameDataPY.GetFuncCfg("FamilyTaofaAtk", 5) 
         
    hurtTotal = 0 # ±¾´Î×ÜÉËº¦ 
    for _ in range(calcHurtCnt): 
        hurtTotal += hurtValue 
         
    atkTime = int(time.time()) 
    faAtkCnt += calcHurtCnt 
     
    # ¼ÆËã¹±Ï×ºÐ×ÓÊý 
    boxAwardHurtList = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaBox", 1) 
    contribBoxMax = min(IpyGameDataPY.GetFuncCfg("FamilyTaofaBox", 2), 1000) # ¿É¹±Ï×µÄ×î´óÏä×ÓÊý 
    finalAwardHurt = boxAwardHurtList[-1] # ×îºóÒ»µµ×î´óÉËº¦Öµ 
    loopNeedHurt = (finalAwardHurt - boxAwardHurtList[-2]) if len(boxAwardHurtList) > 1 else finalAwardHurt # ×îºóÒ»µµËùÐèÉËº¦Öµ 
     
    # Ô×Ü¹±Ï×ºÐ×ÓÊý 
    boxContribCnt = 0 
    for needHurt in boxAwardHurtList: 
        if faHurtTotal < needHurt: 
            break 
        boxContribCnt += 1 
    if faHurtTotal > finalAwardHurt: 
        loopHurtTotal = faHurtTotal - finalAwardHurt 
        loopContribBoxCnt = loopHurtTotal / loopNeedHurt 
        boxContribCnt = min(boxContribCnt + loopContribBoxCnt, contribBoxMax) 
         
    # ÐÂ×Ü±¦ÏäºÐ×ÓÊý 
    faHurtTotal += hurtTotal 
    updContribBoxCnt = 0 
    for needHurt in boxAwardHurtList: 
        if faHurtTotal < needHurt: 
            break 
        updContribBoxCnt += 1 
    if faHurtTotal > finalAwardHurt: 
        loopHurtTotal = faHurtTotal - finalAwardHurt 
        loopContribBoxCnt = loopHurtTotal / loopNeedHurt 
        updContribBoxCnt = min(updContribBoxCnt + loopContribBoxCnt, contribBoxMax) 
         
    addContribCnt = 0 
    if updContribBoxCnt > boxContribCnt: 
        addContribCnt = updContribBoxCnt - boxContribCnt 
        faContribBoxCnt += addContribCnt 
         
    GameWorld.DebugAnswer(crossPlayer, "ÌÖ·¥ID:%s,ÉË:%s,Ïä:%s/%s,Å:%s" % (playerID, hurtValue, addContribCnt, updContribBoxCnt, int(isAnger))) 
     
    # ¸üÐÂAction¼ÇÂ¼ 
    SetFAAtkTime(actionData, atkTime) 
    SetFAAtkCount(actionData, faAtkCnt) 
    SetFAHurtTotal(actionData, faHurtTotal % ChConfig.Def_PerPointValue) 
    SetFAHurtTotalEx(actionData, faHurtTotal / ChConfig.Def_PerPointValue) 
    SetFAContribBoxCnt(actionData, faContribBoxCnt) 
    atkList = actionData.GetUserDict().get(UserKey_AtkList, []) 
    atkList.append([atkTime, addContribCnt, hurtTotal, atkType]) 
    actionData.GetUserDict().update({UserKey_AtkList:atkList}) 
     
    return actionData 
 
def SyncTaofaAtkRet(crossPlayer, atkType, hurtList, awardItemList):     
    atkHurtList = [] 
    for totalHurt, isSuper in hurtList: 
        atkHurt = ChPyNetSendPack.tagSCFamilyTaofaAtkHurt() 
        atkHurt.IsSuper = isSuper 
        atkHurt.HurtValue = totalHurt % ChConfig.Def_PerPointValue 
        atkHurt.HurtValueEx = totalHurt / ChConfig.Def_PerPointValue 
        atkHurtList.append(atkHurt) 
         
    itemList = [] 
    for itemID, itemCount in awardItemList: 
        item = ChPyNetSendPack.tagSCFamilyTaofaAtkItem() 
        item.ItemID = itemID 
        item.Count = itemCount 
        itemList.append(item) 
         
    clientPack = ChPyNetSendPack.tagSCFamilyTaofaAtkRet() 
    clientPack.AtkType = atkType 
    clientPack.HurtList = atkHurtList 
    clientPack.HurtCount = len(clientPack.HurtList) 
    clientPack.ItemList = itemList 
    clientPack.ItemCount = len(clientPack.ItemList) 
    CrossPlayer.SendFakePack(crossPlayer, clientPack) 
    return 
 
## -----------------------------------ÒÔÏÂÎªÓÎÏ··þµØÍ¼Âß¼------------------------------------------- 
 
def PlayerOnDay(curPlayer): 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaAnger, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaLeaveGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxContribCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx, 0) 
    SyncTaofaInfo(curPlayer) 
    return 
 
def OnPlayerLogin(curPlayer): 
    SyncTaofaInfo(curPlayer) 
    return 
 
def OnTaofaResetPlayer(curPlayer): 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaAnger, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaLeaveGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxContribCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHis, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHisEx, 0) 
    SyncTaofaInfo(curPlayer) 
    return 
 
def OnPlayerLeaveFamily(curPlayer): 
    ## Íæ¼ÒÍË³öÁË¹«»á£¬Õë¶ÔÍæ¼Ò¸öÈËµÄ´¦Àí 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaAnger, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, 0) 
    totalGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaLeaveGetCnt, totalGetCnt) 
    GameWorld.DebugLog("ÍË³ö¹«»á¼ÇÂ¼ÌÖ·¥ÒÑÀÛ¼ÆÁìÈ¡±¦ÏäÊý: totalGetCnt=%s" % totalGetCnt) 
    SyncTaofaInfo(curPlayer) 
    return 
 
def C2S_TaofaMemContrib(dataMsg): 
    familyID = dataMsg["familyID"] 
    playerIDList = dataMsg["playerIDList"] 
    playerManager = GameWorld.GetPlayerManager() 
    for playerID in playerIDList: 
        curPlayer = playerManager.FindPlayerByID(playerID) 
        if curPlayer == None: 
            continue 
        __doUpdPlayerAwardBoxCnt(curPlayer, familyID, dataMsg) 
    return 
 
def __doUpdPlayerAwardBoxCnt(curPlayer, familyID, dataMsg): 
    memContribDict = dataMsg["memContribDict"] 
    playerFamilyID = curPlayer.GetFamilyID() 
    playerID = curPlayer.GetPlayerID() 
    joinTime = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyJoinTime) 
    if not joinTime or not playerFamilyID or playerFamilyID != familyID or not memContribDict: 
        return 
     
    awardBoxMax = IpyGameDataPY.GetFuncCfg("FamilyTaofaBox", 3) 
    leaveGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaLeaveGetCnt) # ÉÏ´ÎÀë¿ª¹«»áÊ±ÀÛ¼ÆÁìÈ¡Êý 
    boxTotalGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt) # ÒÑÁìÈ¡±¦ÏäÊý 
    curFamilyGetCnt = boxTotalGetCnt - leaveGetCnt # À´µ½±¾¹«»áºóÀÛ¼ÆÁìÈ¡Êý 
    boxUnGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt) # Î´ÁìÈ¡±¦ÏäÊý 
    canAddBoxMax = awardBoxMax - boxTotalGetCnt - boxUnGetCnt # »¹¿ÉÁìÈ¡µÄÏä×ÓÊý 
    if canAddBoxMax <= 0: 
        GameWorld.DebugLog("    ³ÉÔ±¿ÉÁìÈ¡±¦ÏäÒÑ´ïÉÏÏÞ²»Ë¢ÐÂ: playerID=%s,boxTotalGetCnt(%s)+boxUnGetCnt(%s) >= %s"  
                           % (playerID, boxTotalGetCnt, boxUnGetCnt, awardBoxMax)) 
        return 
     
    curFamilyCanGet = 0 # ÔÚ±¾¹«»áÀÛ¼Æ¿ÉÁìÈ¡Ïä×ÓÊý 
    for contribList in memContribDict.values(): 
        for atkTime, contribBoxCnt in contribList: 
            if joinTime >= atkTime: 
                GameWorld.DebugLog("    ¼ÓÈë¹«»áÖ®Ç°µÄÏä×Ó²»ÄÜÁìÈ¡: joinTime=%s > atkTime(%s),contribBoxCnt=%s" % (joinTime, atkTime, contribBoxCnt)) 
                continue 
            curFamilyCanGet += contribBoxCnt 
             
    addUnGetBox = min(curFamilyCanGet - curFamilyGetCnt - boxUnGetCnt, canAddBoxMax) 
    if addUnGetBox <= 0: 
        GameWorld.DebugLog("    ³ÉÔ±µ±Ç°Ã»ÓÐ¿ÉÁìÈ¡µÄ±¦Ïä²»Ë¢ÐÂ: playerID=%s,curFamilyCanGet=%s,curFamilyGetCnt=%s(%s-%s),boxUnGetCnt=%s,awardBoxMax=%s,canAddBoxMax=%s"  
                           % (playerID, curFamilyCanGet, curFamilyGetCnt, boxTotalGetCnt, leaveGetCnt, boxUnGetCnt, awardBoxMax, canAddBoxMax)) 
        return 
    updBoxUnGetCnt = boxUnGetCnt + addUnGetBox 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, updBoxUnGetCnt) 
    GameWorld.DebugLog("    ³ÉÔ±¿ÉÁìÈ¡µÄ±¦ÏäÊý: playerID=%s,addUnGetBox=%s,updBoxUnGetCnt=%s,curFamilyCanGet=%s,curFamilyGetCnt=%s(%s-%s),boxUnGetCnt=%s,awardBoxMax=%s,canAddBoxMax=%s"  
                       % (playerID, addUnGetBox, updBoxUnGetCnt, curFamilyCanGet, curFamilyGetCnt, boxTotalGetCnt, leaveGetCnt, boxUnGetCnt, awardBoxMax, canAddBoxMax)) 
    SyncTaofaInfo(curPlayer) 
    return 
 
def AddTaofaCntByItem(curPlayer, addCnt): 
    ## ÎïÆ·Ôö¼Ó¸±±¾´ÎÊý 
    itemAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt, itemAddCnt + addCnt) 
    SyncTaofaInfo(curPlayer) 
    return 
 
def GetTaofaBoxAward(curPlayer): 
    boxUnGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt) 
    if not boxUnGetCnt: 
        GameWorld.DebugLog("µ±Ç°Ã»ÓÐ¿ÉÁìÈ¡µÄÌÖ·¥±¦Ïä!") 
        return 
    awardBoxMax = IpyGameDataPY.GetFuncCfg("FamilyTaofaBox", 3) 
    boxTotalGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt) 
    canGetBoxMax = max(awardBoxMax - boxTotalGetCnt, 0) # »¹¿ÉÁìÈ¡µÄÏä×ÓÊý 
    GameWorld.DebugLog("ÁìÈ¡±¦Ïä½±Àø: boxUnGetCnt=%s,canGetBoxMax=%s,boxTotalGetCnt=%s,awardBoxMax=%s" % (boxUnGetCnt, canGetBoxMax, boxTotalGetCnt, awardBoxMax)) 
    if boxUnGetCnt > canGetBoxMax: 
        boxUnGetCnt = canGetBoxMax 
        GameWorld.DebugLog("³¬¹ý¿ÉÁìÈ¡ÉÏÏÞ£¬ÐÞÕý¿ÉÁìÈ¡±¦ÏäÊý: boxUnGetCnt=%s" % (boxUnGetCnt)) 
         
    awardItemDict = {} 
    boxAwardWeightList = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaBox", 4) 
    for _ in range(boxUnGetCnt): 
        awardItem = GameWorld.GetResultByWeightList(boxAwardWeightList) 
        if not awardItem: 
            continue 
        itemID, itemCount = awardItem 
        awardItemDict[itemID] = awardItemDict.get(itemID, 0) + itemCount 
    awardItemList = [[itemID, itemCount] for itemID, itemCount in awardItemDict.items()] 
     
    updTotalGetCnt = boxTotalGetCnt + boxUnGetCnt 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, 0) 
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt, updTotalGetCnt) 
    GameWorld.DebugLog("ÁìÈ¡½á¹û: updTotalGetCnt=%s,awardItemList=%s" % (updTotalGetCnt, awardItemList)) 
    SyncTaofaInfo(curPlayer) 
    ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["FamilyTaofaBoxAward", False, {}]) 
    return 
 
def SyncTaofaInfo(curPlayer): 
    clientPack = ChPyNetSendPack.tagSCFamilyTaofaInfo() 
    clientPack.BuZhenState = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState) 
    clientPack.AtkCount = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaCnt) 
    clientPack.ItemAddCount = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaItemAddCnt) 
    clientPack.Anger = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaAnger) 
    clientPack.BoxUnGetCount = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt) 
    clientPack.BoxHurt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt) 
    clientPack.BoxHurtEx = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx) 
    clientPack.BoxHurtHis = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHis) 
    clientPack.BoxHurtHisEx = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHisEx) 
    NetPackCommon.SendFakePack(curPlayer, clientPack) 
    return