#!/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 GameWorld
import DBDataMgr
import ObjPool

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        ×îºóÒ»´Î¸üÐÂʱ¼ä£¬¿ÉÄÜÊDz¼Õó»ò¹¥»÷£¬¿ÉÓÃÓÚ±¦Ïä¼Ç¼µÄÅÅÐò
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})

AtkType_Normal = 0 # ³£¹æնɱ
AtkType_Anger = 1 # Å­Æøնɱ

def OnDay(family):
    OnTaofaReset(family)     
    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_FamilyTaofaBoxTotalGetCnt, 0)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxLastTime, 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):
    familyID = curPlayer.GetFamilyID()
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID)
    RefreshPlayerAwardBoxCnt(curFamily, curPlayer, unSyncIDList=[curPlayer.GetPlayerID()])
    SyncTaofaInfo(curPlayer)
    PlayerFamily.SendFamilyActionInfo(curPlayer, familyID, ActionType)
    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 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_FamilyTaofaBoxTotalGetCnt, 0)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxLastTime, 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 OnFamilyMemberLeave(family, leavePlayerID, leavePlayer=None):
    ## ¹«»á³ÉԱɾ³ý£¬Õë¶Ô¹«»áµÄ´¦Àí
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(family.GetID(), ActionType)
    actionData = familyAction.GetActionDataByValue1(leavePlayerID, False)
    if not actionData:
        return
    memInfo = PlayerViewCache.GetPlayerBaseViewInfo(leavePlayerID, leavePlayer)
    actionData.GetUserDict().update({"info":memInfo})
    PlayerFamily.SendFamilyAction([actionData])
    return

def OnPlayerLeaveFamily(curPlayer):
    ## Íæ¼ÒÍ˳öÁ˹«»á£¬Õë¶ÔÍæ¼Ò¸öÈ˵Ĵ¦Àí
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaAnger, 0)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, 0)
    SyncTaofaInfo(curPlayer)
    return

def OnPlayerEnterFamily(curPlayer):
    ## Íæ¼Ò½øÈëй«»á
    familyID = curPlayer.GetFamilyID()
    PlayerFamily.SendFamilyActionInfo(curPlayer, familyID, ActionType)
    return

def RefreshFamilyBuZhenInfo(family):
    ## ˢй«»á¹«¹²²¼ÕóÐÅÏ¢
    familyID = family.GetID()
    curTime = int(time.time())
    bzDuration = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 4) * 60 # ÓÐЧʱ³¤Ãë
    maxLayer = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 3)
    
    gLayer = 0
    gEndTime = 0
    gActionData = None
    familyAction = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ActionType)
    for index in range(0, familyAction.Count()):
        actionData = familyAction.At(index)
        dataID = GetFAPlayerID(actionData)
        if dataID == ActionGlobalID:
            gActionData = actionData
            continue
        bzTime = GetFABuzhenTime(actionData)
        if not bzTime:
            continue
        endTime = bzTime + bzDuration
        if endTime <= curTime:
            continue
        
        if not maxLayer or gLayer < maxLayer:
            gLayer += 1
            
        if gEndTime < endTime:
            gEndTime = endTime
            
    GameWorld.DebugLog("ˢй«»á¹«¹²²¼ÕóÐÅÏ¢£º familyID=%s,gLayer=%s,gEndTime=%s" % (familyID, gLayer, GameWorld.ChangeTimeNumToStr(gEndTime)))
    if not gActionData:
        gActionData = familyAction.AddAction()
        SetFAPlayerID(gActionData, ActionGlobalID)
        
    SetFABuzhenEndTime(gActionData, gEndTime)
    SetFABuzhenLayer(gActionData, gLayer)
    PlayerFamily.SendFamilyAction(gActionData)
    return

def RefreshPlayerAwardBoxCnt(family, curPlayer=None, unSyncIDList=[]):
    ## Ë¢ÐÂÍæ¼Ò¿ÉÁìÈ¡µÄ±¦ÏäÊý
    # @param curPlayer: NoneʱˢÐÂËùÓгÉÔ±
    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
            
    awardBoxMax = IpyGameDataPY.GetFuncCfg("FamilyTaofaBox", 3)
    GameWorld.DebugLog("ˢй«»á³ÉÔ±¿ÉÁìÈ¡µÄ±¦ÏäÊý: familyID=%s,memContribDict=%s" % (familyID, memContribDict))
    if curPlayer:
        member = family.FindMember(curPlayer.GetPlayerID())
        if not member:
            return
        __doUpdPlayerAwardBoxCnt(curPlayer, member, memContribDict, awardBoxMax, unSyncIDList)
        return
    
    playerManager = GameWorld.GetPlayerManager()
    for index in xrange(family.GetCount()):
        member = family.GetAt(index)
        playerID = member.GetPlayerID()
        curPlayer = playerManager.FindPlayerByID(playerID)
        if not curPlayer:
            continue
        __doUpdPlayerAwardBoxCnt(curPlayer, member, memContribDict, awardBoxMax, unSyncIDList)
    return

def __doUpdPlayerAwardBoxCnt(curPlayer, member, memContribDict, awardBoxMax, unSyncIDList):
    playerID = curPlayer.GetPlayerID()
    joinTime = member.GetJoinTime()
    boxLastTime = max(curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxLastTime), joinTime) # Óë¼ÓÈëʱ¼äÈ¡×î´ó
    boxTotalGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxTotalGetCnt) # ÒÑÁìÈ¡±¦ÏäÊý
    boxUnGetCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt) # δÁìÈ¡±¦ÏäÊý
    canAddBoxMax = awardBoxMax - boxTotalGetCnt - boxUnGetCnt # »¹¿ÉÁìÈ¡µÄÏä×ÓÊý
    if canAddBoxMax <= 0:
        GameWorld.DebugLog("    ³ÉÔ±¿ÉÁìÈ¡±¦ÏäÒÑ´ïÉÏÏÞ²»Ë¢ÐÂ: playerID=%s,boxLastTime=%s,boxTotalGetCnt(%s)+boxUnGetCnt(%s) >= %s" 
                           % (playerID, boxLastTime, boxTotalGetCnt, boxUnGetCnt, awardBoxMax))
        return
    
    updBoxLastTime = boxLastTime
    addUnGetBox = 0
    for contribList in memContribDict.values():
        if addUnGetBox >= canAddBoxMax:
            break
        for atkTime, contribBoxCnt in contribList:
            if boxLastTime >= atkTime:
                continue
            updBoxLastTime = max(updBoxLastTime, atkTime)
            addUnGetBox += contribBoxCnt
            if addUnGetBox >= canAddBoxMax:
                break
            
    if addUnGetBox <= 0:
        GameWorld.DebugLog("    ³ÉÔ±µ±Ç°Ã»ÓпÉÁìÈ¡µÄ±¦Ï䲻ˢÐÂ: playerID=%s,boxLastTime=%s,boxTotalGetCnt=%s,boxUnGetCnt=%s,awardBoxMax=%s,canAddBoxMax=%s" 
                           % (playerID, boxLastTime, boxTotalGetCnt, boxUnGetCnt, awardBoxMax, canAddBoxMax))
        return
    updBoxUnGetCnt = boxUnGetCnt + addUnGetBox
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxUnGetCnt, updBoxUnGetCnt)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxLastTime, updBoxLastTime)
    GameWorld.DebugLog("    ³ÉÔ±¿ÉÁìÈ¡µÄ±¦ÏäÊý: playerID=%s,addUnGetBox=%s,updBoxUnGetCnt=%s,updBoxLastTime=%s,boxLastTime=%s,boxTotalGetCnt=%s,boxUnGetCnt=%s,awardBoxMax=%s,canAddBoxMax=%s" 
                       % (playerID, addUnGetBox, updBoxUnGetCnt, updBoxLastTime, boxLastTime, boxTotalGetCnt, boxUnGetCnt, awardBoxMax, canAddBoxMax))
    if not unSyncIDList or playerID not in unSyncIDList:
        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

#// 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    
    # ²¼Õó
    if opType == 1:
        __doBuzhen(curPlayer)
    # նɱ
    else:
        __doZhanshaAtk(curPlayer)
    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 __doBuzhen(curPlayer):
    ## ²¼Õó
    playerID = curPlayer.GetPlayerID()
    if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState):
        GameWorld.DebugLog("ÒѲ¼Õó¹ý!", playerID)
        return
    familyID = curPlayer.GetFamilyID()
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID)
    if not curFamily:
        return
    gLayer, gActionData = GetFamilyBuzhenLayer(familyID)
    bzDuration = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 4) * 60 # ÓÐЧʱ³¤Ãë
    maxLayer = IpyGameDataPY.GetFuncCfg("FamilyTaofaBuzhen", 3)
    gEndTime = int(time.time()) + bzDuration # Ö±½Ó¸²¸Ç¸üÐÂ
    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])
    
    # ¸öÈ˼Ǽ
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBuZhenState, 1)
    SyncTaofaInfo(curPlayer)
    return

def __doZhanshaAtk(curPlayer):
    ## նɱ¹¥»÷
    playerID = curPlayer.GetPlayerID()
    familyID = curPlayer.GetFamilyID()
    curFamily = DBDataMgr.GetFamilyMgr().FindFamily(familyID)
    if not curFamily:
        return
    
    atkCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaCnt)
    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
    
    atkTime = int(time.time())
    
    # ¼ÆËãÊôÐÔ
    gLayer, _ = GetFamilyBuzhenLayer(familyID)
    fightPower = PlayerControl.GetFightPower(curPlayer)
    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
        
    commAddAnger, superAddAnger, maxAnger = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaAtk", 4)
    anger = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTaofaAnger)
    
    GameWorld.DebugLog("---¹«»áÌÖ·¥Õ¶É±: fightPower=%s,gLayer=%s,superRate=%s,superRatio=%s,damRatio=%s,anger=%s/%s" 
                       % (fightPower, gLayer, superRate, superRatio, damRatio, anger, maxAnger), 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)
    
    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
    GameWorld.DebugLog("boxContribCnt=%s,boxHurtTotal=%s,boxHurtTotalHis=%s" % (boxContribCnt, boxHurtTotal, boxHurtTotalHis), playerID)
    
    atkType = AtkType_Normal
    calcHurtCnt = 1 # ¼ÆËãÉ˺¦´ÎÊý
    if anger >= maxAnger:
        anger -= maxAnger
        atkType = AtkType_Anger # Å­Æø¹¥»÷
        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)
    addContribCnt = 0
    if updContribBoxCnt > boxContribCnt:
        addContribCnt = updContribBoxCnt - boxContribCnt
        faContribBoxCnt += addContribCnt
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxContribCnt, updContribBoxCnt)
        GameWorld.DebugLog("¸üÐÂÔö¼Ó¹±Ï×±¦Ïä: addContribCnt=%s,updContribBoxCnt=%s,faContribBoxCnt=%s" % (addContribCnt, updContribBoxCnt, faContribBoxCnt), playerID)
        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaAnger, anger)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurt, boxHurtTotal % ChConfig.Def_PerPointValue)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtEx, boxHurtTotal / ChConfig.Def_PerPointValue)
    if boxHurtTotal > boxHurtTotalHis:
        boxHurtTotalHis = boxHurtTotal
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHis, boxHurtTotalHis % ChConfig.Def_PerPointValue)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaBoxHurtHisEx, boxHurtTotalHis / ChConfig.Def_PerPointValue)
        
    awardItemList = []
    # ³£¹æ¹¥»÷: ¸øնɱ¹¥»÷½±Àø£¬¼Ó´ÎÊý
    if atkType == AtkType_Normal:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyTaofaCnt, atkCnt + 1)
        atkItemAwardList = IpyGameDataPY.GetFuncEvalCfg("FamilyTaofaAtk", 2) # ÿ´Îնɱ»ñµÃ¸öÈ˽±ÀøÁбí [[ÎïÆ·ID,¸öÊý], ...]
        awardItemList += atkItemAwardList
        ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["FamilyTaofa", False, {}], 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("atkList", [])
    atkList.append([atkTime, addContribCnt, hurtTotal, atkType])
    actionData.GetUserDict().update({"atkList":atkList})
    PlayerFamily.SendFamilyAction([actionData])
    
    # ͬ²½£º ¹¥»÷ -> ±¦Ïä -> ÆäËû
    SyncTaofaAtkRet(curPlayer, atkType, hurtList, awardItemList)
    if addContribCnt:
        RefreshPlayerAwardBoxCnt(curFamily, unSyncIDList=[playerID])
    SyncTaofaInfo(curPlayer)
    return

def GMAddMemTaofaAtk(curPlayer, 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(curPlayer, "ÌÖ·¥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("atkList", [])
    atkList.append([atkTime, addContribCnt, hurtTotal, atkType])
    actionData.GetUserDict().update({"atkList":atkList})
    
    return actionData

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 = ObjPool.GetPoolMgr().acquire(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

def SyncTaofaAtkRet(curPlayer, atkType, hurtList, awardItemList):    
    atkHurtList = []
    objPool = ObjPool.GetPoolMgr()
    for totalHurt, isSuper in hurtList:
        atkHurt = objPool.acquire(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 = objPool.acquire(ChPyNetSendPack.tagSCFamilyTaofaAtkItem)
        item.ItemID = itemID
        item.Count = itemCount
        itemList.append(item)
        
    clientPack = objPool.acquire(ChPyNetSendPack.tagSCFamilyTaofaAtkRet)
    clientPack.AtkType = atkType
    clientPack.HurtList = atkHurtList
    clientPack.HurtCount = len(clientPack.HurtList)
    clientPack.ItemList = itemList
    clientPack.ItemCount = len(clientPack.ItemList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return