#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
##@package PlayerControl
# @todo: Íæ¼Ò¿ØÖÆÆ÷
#
# @author Alee
# @date 2010-02-20 16:30
# @version 1.0
#
#---------------------------------------------------------------------
#"""Version = 2017-07-17 15:00"""
#---------------------------------------------------------------------
import GameWorld
import ChEquip
import SkillShell
import ChConfig
import EventShell
import EffGetSet
import PlayerHorse
import PlayerTruck
import PlayerTrade
import PlayerTeam
import SkillCommon
import MirrorAttack
import GameMap
import FBLogic
import GameWorldProcess
import NPCCommon
import ItemCommon
import ReadChConfig
import PlayerGMOper
import BuffSkill
import PetControl
import OperControlManager
import PlayerFamily
import ShareDefine
import PlayerBillboard
import GameServerRefresh
import IPY_GameWorld
import PlayerGameWallow
import ChPyNetSendPack
import NetPackCommon
import DataRecordPack
import CalcNoLineEffect
import CalcLineEffect
import PlayerEquipDecompose
import FormulaControl
import PlayerDienstgrad
import PlayerPrestigeSys
import OpenServerCampaign
import PlayerGodWeapon
import PlayerExpandPackCfgMgr
import PlayerWorldAverageLv
import PlayerActivity
import FBCommon
import PlayerViewCacheTube
import PassiveBuffEffMng
import PlayerGameEvent
import EventReport
import PlayerGatherSoul
import PlayerGatherTheSoul
import PlayerSuccess
import PlayerPet
import PlayerGreatMaster
import ItemControler
import GameFuncComm
import IpyGameDataPY
import PlayerRune
import GameLogic_DuJie
import PyGameData
import PlayerMagicWeapon
import PlayerFeastTravel
import PlayerActTurntable
import GameLogic_SealDemon
import GameLogic_ZhuXianBoss
import GameLogic_CrossDemonKing
import PlayerTJG
import PlayerVip
import PlayerRefineStove
import PlayerFamilyTech
import PlayerFamilyZhenfa
import PlayerCostRebate
import PlayerActLunhuidian
import PlayerActGarbageSorting
import GY_Query_CrossRealmReg
import PlayerTongTianLing
import PlayerCrossRealmPK
import FunctionNPCCommon
import PlayerGoldInvest
import IPY_PlayerDefine
import CrossRealmPlayer
import CrossPlayerData
import NPCHurtManager
import ChNetSendPack
import PlayerLianTi
import PlayerCoat
import PlayerAssist
import PlayerState
import QuestCommon
import PlayerDogz
import PlayerFaQi
import PlayerLove
import PlayerGubao
import PlayerShentong
import PlayerCharm
import PlayerFace
import ChPlayer
import GMShell
import GameObj

import random
import types
import math
import time
import json
#---------------------------------------------------------------------
#ÐÅÏ¢ÌáʾÁбí
NotifyCodeList = IPY_GameWorld.IPY_NotifyCodeList()

#buff×Ö¶ÎDieContinueλ±íʾ±êʶ
Def_Buff_Clear_Die = 0x1  # ËÀÍöÇå³ýbuff
Def_Buff_Clear_Disconnect = 0x2  # ÏÂÏßÇå³ýbuff

#---------------------------------------------------------------------
##¿Í»§¶Ë·¢ËÍÒƶ¯·â°ü¼ì²é
# @param curPlayer Íæ¼ÒʵÀý
# @param clientWorldTick ÉÏ´ÎÒƶ¯Ê±¼ä´Á
# @return ·µ»ØÖµÕæ, ¿ÉÒÔÒƶ¯
# @remarks ¿Í»§¶Ë·¢ËÍÒƶ¯·â°ü¼ì²é
def PlayerMoveCheckClientWorldTick(curPlayer, clientWorldTick, sendPack_PosX, sendPack_PosY):
    gameWorldTick = GameWorld.GetGameWorld().GetTick()
    Def_Max_Move_Tick = 5000
 
    if abs(gameWorldTick - clientWorldTick) >= Def_Max_Move_Tick:
        curPlayer.Sync_ClientTick()
        #ʱ¼äÏà²î¹ý´ó£¬¿ÉÄÜÒòÍøÂçÒýÆð£¬À­»Ø
        GameWorld.DebugLog("PlayerMoveCheckClientWorldTick -- ·þÎñÆ÷tick %s-¿Í»§¶Ë%sʱ¼äÏà²î¹ý´ó£¬¿ÉÄÜÒòÍøÂçÒýÆð£¬À­»Ø" % (
                            gameWorldTick, clientWorldTick), curPlayer.GetID())
        return False
    
    if gameWorldTick - curPlayer.GetDictByKey("CheckTick") > 60000:
        # 1·ÖÖÓ¾ÀÕýÒ»´Îtick,ͬʱÓÃÓÚÕ½¶·ºÍÒƶ¯µÄ¼ì²é
        curPlayer.SetMoveCount(0)
        curPlayer.SetDict("CheckTick", gameWorldTick)
    
    lastMoveTick = curPlayer.GetClientMoveTick()
    if clientWorldTick < lastMoveTick:
        #and GameWorld.GetGameWorld().GetTick() - curPlayer.GetLoginTick() > 15000:
        #Íæ¼ÒµÇÈëʱ¼ä´óÓÚ15Ãë, ²Å»áÌß³öÍæ¼Ò
        #2009.4.16. bug:
        #Íæ¼ÒÇл»µØͼ, ·þÎñÆ÷»º´æ×ß··â°ü, µ½´ïеØͼ, »º´æÖеķâ°üÊÕµ½, ½á¹ûÌß³öÁËÍæ¼Ò
        GameWorld.DebugLog('---clientWorldTick < lastMoveTick: %s, TickÌ«Âý' % curPlayer.GetAccID())
        #curPlayer.Kick(IPY_GameWorld.disTickError)
        errCnt = curPlayer.GetMoveCount()
        curPlayer.SetMoveCount(errCnt + 1)
        if errCnt > 5:
            return False
    
    # ÑéÖ¤Á½´Îtick¼ä¿ÉÄܲúÉúµÄ×ø±ê²î
    dist = GameWorld.GetDist(curPlayer.GetPosX(), curPlayer.GetPosY(), sendPack_PosX, sendPack_PosY)
    canMoveDist = math.ceil((clientWorldTick - lastMoveTick) / float(curPlayer.GetSpeed())) + 2
    #if clientWorldTick - curPlayer.GetPlayerAttackTick() < GetAtkInterval(curPlayer):
    #    # ¹¥»÷²úÉúµÄλÒÆ¿ÉÄÜÒòΪ¹¥»÷Ëٶȸıä¶ø±ä¿ì£¬¹¥»÷ÆÚ¼äµÄÒƶ¯°üÔÊÐí¶àÒƶ¯1Ã×µÄËÙ¶È
    #    canMoveDist += 2
        
    if dist > canMoveDist:
        GameWorld.DebugLog("¾àÀë²î%s ×ø±êS/C:%s---ÑéÖ¤Á½´Îtick¼ä¿ÉÄܲúÉúµÄ×ø±ê²î%s %s - %s" % (dist, [curPlayer.GetPosX(),
                            curPlayer.GetPosY(), sendPack_PosX, sendPack_PosY], canMoveDist, clientWorldTick, lastMoveTick))
        errCnt = curPlayer.GetMoveCount()
        curPlayer.SetMoveCount(errCnt + 1)
        if errCnt > 5:
            return False
    
    #ʱ¼ä²î
#    curPlayer.UpdatePosByTick(gameWorldTick - clientWorldTick + gameWorldTick)
    #curPlayer.UpdatePos()
    return True


# notifyCnt ´ú±í¹ã²¥ÖÜΧÍæ¼ÒµÄÊýÁ¿£¬0Ϊȫ²¿¹ã²¥ -1Ϊָ¶¨ÁбíËæ»ú£¬ ÆäËûÊý×ÖΪָ¶¨Ö¸
def PyNotifyAll(curPlayer, sendPack, notifySelf=True, notifyCnt=0):
    if notifyCnt == -1:
        notifyCnt = 8
    #GameWorld.DebugLog("PyNotifyAll %s"%notifyCnt)

    curPlayer.NotifyAll(sendPack.GetBuffer(), sendPack.GetLength(), notifySelf, notifyCnt)
    
    
#---------------------------------------------------------------------
##Ö´ÐÐÍæ¼ÒÔÚÕÏ°­µãÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @return ²¼¶ûÖµ, FlaseΪÍæ¼Ò²»ÔÚÕÏ°­µãÖÐ
# @remarks Ö´ÐÐÍæ¼ÒÔÚÕÏ°­µãÂß¼­
def DoLogic_PlayerInBarrierPoint(curPlayer):
    curPlayerPosX = curPlayer.GetPosX()
    curPlayerPosY = curPlayer.GetPosY()
    curPlayerID = curPlayer.GetID()
    
    #---Íæ¼Ò²»ÔÚÕÏ°­µãÖÐ---
    if GameWorld.GetMap().CanMove(curPlayerPosX, curPlayerPosY):
        return False
    
    #---Íæ¼ÒÔÚÕÏ°­µãÖÐ---
    
    #ÔÚÕÏ°­µã¸½¼þ2¸ñÑ°ÕÒºÏÊÊλÖÃ
    curFindPos = GameMap.GetEmptyPlaceInArea(curPlayerPosX, curPlayerPosY, 3)
    curFindPosX = curFindPos.GetPosX()
    curFindPosY = curFindPos.GetPosY()
    
    #Íæ¼ÒÎÞ·¿É×ß
    if curFindPosX == curPlayerPosX and curFindPosY == curPlayerPosY:
        curPlayer.StopMove()
#===============================================================================
#            playerControl = PlayerControl(curPlayer)
#            playerControl.SetToBornPlace()
#===============================================================================
        GameWorld.Log("Íæ¼ÒÎÞ·¿É×ß, ´ò»ØÖØÉúµã!(%d,%d)" % (curPlayerPosX, curPlayerPosY), curPlayerID)
    #ÕÏ°­µãÖܱ߿ÉÒÔÒƶ¯, ½«Íæ¼ÒÖÃλ
    else:
        curPlayer.ResetPos(curFindPosX, curFindPosY)
        curPlayer.StopMove()
        GameWorld.Log("Íæ¼ÒÕ¾ÔÚÕÏ°­µãÖÐ, Í£Ö¹Òƶ¯ (%d,%d)" % (curPlayerPosX, curPlayerPosY), curPlayerID)
        
    return True
#---------------------------------------------------------------------
## ÏûÏ¢Ìáʾ
#  @param curPlayer ÌáʾµÄÍæ¼Ò
#  @param msgMark ÌáʾÐÅÏ¢Mark
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @return ÎÞ·µ»ØÖµ
#  @remarks 
def NotifyCode(curPlayer, msgMark, msgParamList=[]):
    if curPlayer == None:
        GameWorld.ErrLog('NotifyCode Player = None')
        return
      
    curPlayer.NotifyCode(msgMark, __GetNotifyCodeList(msgParamList))
    return
    
## ÊÀ½ç¹ã²¥
#  @param country ÌáʾµÄ¹ú¼Ò
#  @param msgMark ÌáʾÐÅÏ¢Mark
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @param lineID:Ïß·ID£¨Ä¬ÈÏ0£¬±íʾȫ·þ¹ã²¥£©
#  @param mergeMinOSD ¸ÃÌáʾÕë¶Ô¿ç·þ×Ó·þÓÐЧµÄ×îС¿ª·þÌì, >=0ʱÓÐÏÞÖÆ
#  @param mergeMaxOSD ¸ÃÌáʾÕë¶Ô¿ç·þ×Ó·þÓÐЧµÄ×î´ó¿ª·þÌì, >=0ʱÓÐÏÞÖÆ
#  @param mergeMapInfo ¸ÃÌáʾËùÊôµÄ¿ç·þ»î¶¯µØͼÐÅÏ¢, Ö÷ÒªÓÃÓÚ²»Í¬×Ó·þ¶ÔÓ¦Ëù¿çµÄ»î¶¯µØͼID
#  @return ÎÞ·µ»ØÖµ
def WorldNotify(country, msgMark, msgParamList=[], lineID=0, mergeMinOSD=-1, mergeMaxOSD=-1, mergeMapInfo=[]):
    GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(country, 0, msgMark, __GetNotifyCodeList(msgParamList), lineID)
    return

def GetCrossWorldNotifyInfo(country, msgMark, msgParamList=[]):
    return {"Type":ShareDefine.CrossNotify_World, "Params":[country, msgMark, msgParamList]}

def GetCrossFamilyNotifyInfo(familyID, msgMark, msgParamList=[]):
    return {"Type":ShareDefine.CrossNotify_Family, "Params":[familyID, msgMark, msgParamList]}

def CrossNotify(serverGroupIDList, crossNotifyList):
    ''' ¿ç·þ¹ã²¥ÐÅÏ¢Ìáʾ£¬Ö§³Öͬ²½¶àÌõ£¬Í¬Ê±Ò²½¨Òé¶àÌõÒ»Æðͬ²½
    @param serverGroupIDList: ÐèҪͬ²½µ½µÄÄ¿±ê·þÎñÆ÷×éIDÁбí
    @param crossNotifyList: ÐÅÏ¢ÌáʾÁÐ±í£¬Í¨¹ý GetCrossWorldNotifyInfo GetCrossFamilyNotifyInfo º¯Êý»ñµÃ·µ»ØÖµÌí¼Óµ½Áбí
    '''
    sendMsg = str([serverGroupIDList, crossNotifyList])
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "CrossNotify", sendMsg, len(sendMsg))
    return

#---------------------------------------------------------------------
## ¼Ò×å¹ã²¥
#  @param familyID ÌáʾµÄ¼Ò×åID
#  @param msgMark ÌáʾÐÅÏ¢Mark
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @return ÎÞ·µ»ØÖµ
#  @remarks 
def FamilyNotify(familyID, msgMark, msgParamList=[]):
    GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(0, familyID, msgMark, __GetNotifyCodeList(msgParamList))
    return

#---------------------------------------------------------------------
##±¾µØͼÄÚµÄ֪ͨ
#  @param msgMark ÌáʾÐÅÏ¢Mark
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @return ÎÞ·µ»ØÖµ
#  @remarks 
def FBNotify(msgMark, msgParamList=[]):
    GameWorld.GetMapCopyPlayerManager().BroadcastFB_NotifyCode(msgMark, __GetNotifyCodeList(msgParamList))
    return

def FBFactionNotifySelf(faction, msgMark, msgParamList=[]):
    ## ¸±±¾×Ô¼ºÕóÓª¹ã²¥
    copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
    for i in xrange(copyMapPlayerManager.GetPlayerCount()):
        curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
        if curPlayer == None or curPlayer.IsEmpty():
            continue
        if curPlayer.GetFaction() == faction:
            NotifyCode(curPlayer, msgMark, msgParamList)
    return

def FBFactionNotifyOther(faction, msgMark, msgParamList=[]):
    ## ¸±±¾ÆäËûÕóÓª¹ã²¥
    copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
    for i in xrange(copyMapPlayerManager.GetPlayerCount()):
        curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
        if curPlayer == None or curPlayer.IsEmpty():
            continue
        if curPlayer.GetFaction() != faction:
            NotifyCode(curPlayer, msgMark, msgParamList)
    return

def FBFactionNotify(faction, selfMsgMark, selfMsgParamList, otherMsgMark, otherMsgParamList):
    ## ¸±±¾¹ã²¥×Ô¼º¼°ÆäËûÕóÓª£¬Çø·Ö¹ã²¥ÐÅÏ¢
    copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
    for i in xrange(copyMapPlayerManager.GetPlayerCount()):
        curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
        if curPlayer == None or curPlayer.IsEmpty():
            continue
        if curPlayer.GetFaction() == faction:
            NotifyCode(curPlayer, selfMsgMark, selfMsgParamList)
        else:
            NotifyCode(curPlayer, otherMsgMark, otherMsgParamList)
    return

## ¶ÓÎé¹ã²¥
#  @param teamID ¶ÓÎéID
#  @param msgMark ÌáʾÐÅÏ¢Mark
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @return ÎÞ·µ»ØÖµ
def TeamNotify(teamID, msgMark, msgParamList=[]):
    if teamID == 0:
        return
    
    sendMsg = '("%s", %s)' % (msgMark, msgParamList)
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, teamID, 'TeamNotify', sendMsg, len(sendMsg))
    return

#---------------------------------------------------------------------
def SendMailBatch(mailTypeKey, batchPlayerIDList, batchAddItemList=[], batchParamList=[], batchGold=[], batchGoldPaper=[], batchSilver=[], batchDetail=[], moneySource=ChConfig.Def_GiveMoney_Mail, crossMail=False):
    '''ÅúÁ¿·¢ËÍÓʼþ, ÓÃÓÚ˲¼äÐèÒª·¢ËͶà·â£¨´óÁ¿£©ÓʼþµÄ£¬±ÈÈçһЩ¹«¹²¸±±¾»î¶¯µÈ½áËãʱ
    @param mailTypeKey: ÓʼþÄ£°åkey
    @param batchPlayerIDList: [playerIDList, playerIDList, ...]
    @param batchAddItemList: [addItemList, addItemList, ...]
    @param batchParamList: [paramList, paramList, ...]
    @param batchGold: [batchGold, batchGold, ...]
    @param batchGoldPaper: [batchGoldPaper, batchGoldPaper, ...]
    @param batchSilver: [batchSilver, batchSilver, ...]
    @param batchDetail: [¼Ç¼ÓʼþÁ÷ÏòÓÃ, ...]
    @param moneySource: »õ±ÒÀ´Ô´
    '''
    
    copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
    for i, playerIDList in enumerate(batchPlayerIDList):
        for playerID in playerIDList[::-1]:
            curPlayer = copyMapPlayerManager.FindPlayerByID(playerID)
            if curPlayer and not curPlayer.GetGameServerInitOK():
                bAddItemList = [batchAddItemList[i]] if len(batchAddItemList) > i else []
                bParamList = [batchParamList[i]] if len(batchParamList) > i else []
                bGold = [batchGold[i]] if len(batchGold) > i else []
                bGoldPaper = [batchGoldPaper[i]] if len(batchGoldPaper) > i else []
                bSilver = [batchSilver[i]] if len(batchSilver) > i else []
                bDetail = [batchDetail[i]] if len(batchDetail) > i else []
                AddUnLoginOKPlayerMailCache(playerID, "ByMailTemplate", [mailTypeKey, bAddItemList, bParamList, bGold, bGoldPaper, bSilver, bDetail, moneySource, crossMail])
                playerIDList.pop(playerIDList.index(playerID))
                continue
            
    msgInfo = str([mailTypeKey, batchPlayerIDList, batchAddItemList, batchParamList, batchGold, batchGoldPaper, batchSilver, batchDetail, moneySource, crossMail])
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "SendMailBatch", msgInfo, len(msgInfo))
    GameWorld.Log("SendMailBatch %s, batchPlayerIDList=%s, batchAddItemList=%s, batchParamList=%s, batchGold=%s, batchGoldPaper=%s, batchSilver=%s" 
                  % (mailTypeKey, batchPlayerIDList, batchAddItemList, batchParamList, batchGold, batchGoldPaper, batchSilver))
    return

def SendMailByKey(mailTypeKey, playerIDList, addItemList, paramList=[], gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail, crossMail=False):
    '''
    @param detail: ¼Ç¼ÓʼþÁ÷ÏòÓÃ
    '''
    if not mailTypeKey:
        mailTypeKey = ShareDefine.DefaultLackSpaceMailType
    
    content = "<MailTemplate>%s</MailTemplate>%s" % (mailTypeKey, json.dumps(paramList, ensure_ascii=False))
    SendMail("", content, 30, playerIDList, addItemList, gold, goldPaper, silver, detail, moneySource, crossMail)
    return

def SendCrossMail(serverGroupID, mailTypeKey, playerIDList, addItemList, paramList=[]):
    ## ·¢ËÍ¿ç·þÓʼþ
    if not serverGroupID:
        return
    dataMsg = {"MailTypeKey":mailTypeKey, "Player":playerIDList}
    if addItemList:
        dataMsg["Item"] = CombineMailItem(addItemList)
    if paramList:
        dataMsg["Param"] = paramList
    GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_SendMail, dataMsg, [serverGroupID])
    return

def SendEntireMail(mailTypeKey, getDays, limitLV, limitLVType, addItemList=[], paramList=[], \
                   gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail):
    ''' ·¢ËÍÈ«·þÓʼþ
    @param mailTypeKey: ÓʼþÄ£°åkey
    @param getDays: ÓÐЧÌìÊý
    @param limitLV: ÁìÈ¡×îµÍµÈ¼¶ÏÞÖÆ
    @param limitLVType: µÈ¼¶²»×ãµÄÉý¼¶ºóÊÇ·ñ¿ÉÁì 0-²»¿É£¬1-¿ÉÒÔ
    '''
    
    # ÓÐЧÌìÊýÏÞÖÆ
    if not mailTypeKey or getDays <= 0:
        return
    
    # ¿ç·þ·þÎñÆ÷²»ÔÊÐí·¢ËÍÓʼþ
    if GameWorld.IsCrossServer():
        return
    
    combineItemList = CombineMailItem(addItemList)
    cmdList = [mailTypeKey, getDays, limitLV, limitLVType, combineItemList, paramList, gold, goldPaper, silver, detail, moneySource]
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "SendEntireMail", '%s' % (cmdList), len(str(cmdList)))
    GameWorld.Log("·¢ËÍÈ«·þÓʼþ: %s,getDays=%s,limitLV=%s,limitLVType=%s,combineItemList=%s,paramList=%s,gold=%s,goldPaper=%s,silver=%s,detail=%s,moneySource=%s" % 
                  (mailTypeKey, getDays, limitLV, limitLVType, combineItemList, paramList, gold, goldPaper, silver, detail, moneySource))
    return

## ¹¦ÄÜ·¢·ÅÎïÆ·²¹³¥/½±ÀøÓʼþ
#  @param addItemList [(itemID, itemCnt, ÊÇ·ñÅÄÆ·), {»òÎïÆ·ÐÅÏ¢×Öµä}, ...]
#  @return
def SendMail(title, content, getDays, playerIDList, addItemList, gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail, crossMail=False):
    if not playerIDList:
        return
    
#    if not addItemList:
#        return
    
    # ÓÐЧÌìÊýÏÞÖÆ
    if getDays <= 0:
        return
    
    # ¿ç·þ·þÎñÆ÷²»ÔÊÐí·¢ËÍÓʼþ
    if GameWorld.IsCrossServer() and not crossMail:
        return
    
    sendPlayerIDList = []
    copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
    for playerID in playerIDList:
        curPlayer = copyMapPlayerManager.FindPlayerByID(playerID)
        if curPlayer and not curPlayer.GetGameServerInitOK():
            AddUnLoginOKPlayerMailCache(playerID, "ByMailContent", [title, content, getDays, addItemList, gold, goldPaper, silver, detail, moneySource])
            continue
        sendPlayerIDList.append(playerID)
        
    combineItemList = CombineMailItem(addItemList)
    cmdList = [title, content, getDays, sendPlayerIDList, combineItemList, gold, goldPaper, silver, detail, moneySource, crossMail]
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "SendMail", '%s' % (cmdList), len(str(cmdList)))
    return True

def AddUnLoginOKPlayerMailCache(playerID, cacheType, mailInfo):
    ''' Ìí¼ÓδµÇ¼³É¹¦µÄÍæ¼Ò¸öÈËÓʼþ·¢ËÍ»º´æ
    '''
    if playerID not in PyGameData.g_unLoginOKPlayerMailInfo:
        PyGameData.g_unLoginOKPlayerMailInfo[playerID] = []
    mailList = PyGameData.g_unLoginOKPlayerMailInfo[playerID]
    if [cacheType, mailInfo] in mailList:
        GameWorld.Log("###Öظ´Ìí¼ÓGetGameServerInitOKδµÇ¼³É¹¦µÄÍæ¼Ò¸öÈËÓʼþ·¢ËÍ»º´æ! ²»Ìí¼Ó! mailCount=%s, mailInfo=%s" 
                      % (len(mailList), str(mailInfo)), playerID)
        return
    if len(mailList) >= 30: # ×ö¸öÏÞÖÆ£¬·ÀÖ¹³öÎÊÌâË¢Óʼþ
        GameWorld.Log("###ÏÞÖÆÌí¼ÓGetGameServerInitOKδµÇ¼³É¹¦µÄÍæ¼Ò¸öÈËÓʼþ·¢ËÍ»º´æ! ³¬³ö×î´ó¿ÉÌí¼ÓÊý£¬²»Ìí¼Ó! mailCount=%s, mailInfo=%s" 
                      % (len(mailList), str(mailInfo)), playerID)
        return
    mailList.append([cacheType, mailInfo])
    # curPlayer.GetGameServerInitOK()
    GameWorld.Log("Ìí¼ÓGetGameServerInitOKδµÇ¼³É¹¦µÄÍæ¼Ò¸öÈËÓʼþ·¢ËÍ»º´æ! µÈ´ý·¢ËÍ! mailCount=%s, mailInfo=%s" 
                  % (len(mailList), str(mailInfo)), playerID)
    return

def SendUnLoginOKPlayerMailCache(curPlayer):
    ## δµÇ¼³É¹¦µÄÍæ¼Ò¸öÈËÓʼþ·¢ËÍ»º´æ  - µÇ¼³É¹¦ºó´¦Àí
    if not curPlayer.GetGameServerInitOK():
        return
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_unLoginOKPlayerMailInfo:
        return
    mailList = PyGameData.g_unLoginOKPlayerMailInfo.pop(playerID)
    for cacheType, mailInfo in mailList:
        playerIDList = [playerID]
        GameWorld.Log("·¢ËÍδµÇ¼³É¹¦Ê±»º´æµÄ´ý·¢ËÍÓʼþ! cacheType=%s, mailInfo=%s" % (cacheType, str(mailInfo)), playerID)
        if cacheType == "ByMailContent":
            title, content, getDays, addItemList, gold, goldPaper, silver, detail, moneySource = mailInfo
            SendMail(title, content, getDays, playerIDList, addItemList, gold, goldPaper, silver, detail, moneySource)
        elif cacheType == "ByMailTemplate":
            mailTypeKey, bAddItemList, bParamList, bGold, bGoldPaper, bSilver, bDetail, moneySource, crossMail = mailInfo
            SendMailBatch(mailTypeKey, [playerIDList], bAddItemList, bParamList, bGold, bGoldPaper, bSilver, bDetail, moneySource, crossMail)
    return

def CombineMailItem(addItemList):
    ## ºÏ²¢ÓʼþÎïÆ·
    itemCountDict = {}
    combineItemList = [] # ºÏ²¢ºóµÄÎïÆ·Áбí
    for mailItem in addItemList:
        if isinstance(mailItem, dict):
            combineItemList.append(mailItem)
            continue
        
        if len(mailItem) != 3:
            continue
        
        itemID, itemCnt, isAuctionItem = mailItem
        
        if ItemControler.GetAppointItemRealID(itemID):
            # ¶¨ÖÆÎïƷת»¯ÎªÎïÆ·ÐÅÏ¢×Öµä
            appointItemObj = ItemControler.GetItemByData(ItemControler.GetAppointItemDictData(itemID, isAuctionItem))
            if not appointItemObj:
                GameWorld.ErrLog("Óʼþ¶¨ÖÆÎïƷת»¯Ê§°Ü£¡itemID, itemCnt, isAuctionItem" % (itemID, itemCnt, isAuctionItem))
                continue
            combineItemList.append(ItemCommon.GetMailItemDict(appointItemObj))
            appointItemObj.Clear()
        elif isAuctionItem:
            combineItemList.append((itemID, itemCnt, isAuctionItem))
        else:
            key = (itemID, isAuctionItem)
            itemCountDict[key] = itemCountDict.get(key, 0) + itemCnt
            
    for key, itemCnt in itemCountDict.items():
        itemID, isAuctionItem = key
        combineItemList.append((itemID, itemCnt, isAuctionItem))
    return combineItemList

## ¹¹½¨ÏµÍ³Ìáʾ²ÎÊýÁбí
#  @param msgParamList ÐÅÏ¢²ÎÊýÁбí
#  @return ϵͳÌáʾ²ÎÊýÁбí IPY_NotifyCodeList
#  @remarks 
def __GetNotifyCodeList(msgParamList):
    #ÏûÏ¢ÌáʾÁбí, ÏÈÇåÔÚÌí¼Ó
    global NotifyCodeList
    NotifyCodeList.Clear()
    
    if not msgParamList:
        return NotifyCodeList
    
    for msg in msgParamList:
        itemPythonType = type(msg)
        
        if itemPythonType is types.IntType:
            #PythonÒªÑéÖ¤ÕûÐͺͳ¤ÕûÐÍ
            NotifyCodeList.AddInt(msg)
        elif itemPythonType is types.LongType:
            NotifyCodeList.AddStr(str(msg))
        else:
            NotifyCodeList.AddStr(msg)

    return NotifyCodeList
#---------------------------------------------------------------------
##»ñµÃÍæ¼Òµ±Ç°ÀۼƵÄÀëÏß·ÖÖÓÊý
# @param curPlayer Íæ¼ÒʵÀý
# @return ÀۼƵķÖÖÓÊý
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
def GetPlayerLeaveServerMinute(curPlayer):
    #µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
    logoffTimeStr = curPlayer.GetLogoffTime()

    if logoffTimeStr == "" or logoffTimeStr == '0':
        return 0

    logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr)
    loginTime = GameWorld.GetDateTimeByStr(GameWorld.GetCurrentDataTimeStr())

    return GameWorld.GetDiff_Minute(loginTime, logoffTime)

##»ñµÃÍæ¼Òµ±Ç°ÀۼƵÄÀëÏßÃëÊý
# @param curPlayer Íæ¼ÒʵÀý
# @return ÀۼƵÄÃëÊý
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
def GetPlayerLeaveServerSecond(curPlayer):
    #µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
    logoffTimeStr = curPlayer.GetLogoffTime()

    if logoffTimeStr == "" or logoffTimeStr == '0':
        return 0

    logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr)
    loginTime = GameWorld.GetDateTimeByStr(GameWorld.GetCurrentDataTimeStr())

    diff_Time = loginTime - logoffTime
    #ÌìÊý * 24Сʱ * 60 ·ÖÖÓ + Ãë
    return diff_Time.days * 24 * 60 * 60 + diff_Time.seconds


##»ñµÃÍæ¼Òµ±Ç°Ê±¼ä¾àÀëÉÏ´ÎÀëÏßʱ¼äµÄÌìÊý
# @param curPlayer Íæ¼ÒʵÀý
# @return 
def GetPlayerLastLeaveServerPastDay(curPlayer):
    #µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
    logoffTimeStr = curPlayer.GetLogoffTime()

    if logoffTimeStr == "" or logoffTimeStr == '0':
        return 0
    
    logoffTimeStr = logoffTimeStr.split()[0]
    loginTimeStr = GameWorld.GetCurrentDataTimeStr().split()[0]
    
    logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr, ChConfig.TYPE_Time_Format_Day)
    loginTime = GameWorld.GetDateTimeByStr(loginTimeStr, ChConfig.TYPE_Time_Format_Day)
    
    diffTime = loginTime - logoffTime
    
    return diffTime.days
    
#---------------------------------------------------------------------
## ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔ´«ËÍ
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @return ²¼¶ûÖµ
#  @remarks ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔ´«ËÍ
def CheckPlayerTransport(curPlayer):
    #ËÀÍö²»¿ÉʹÓÃ
    if GameObj.GetHP(curPlayer) <= 0:
        return False
    
#    if curPlayer.GetPKValue() > 0:
#        #PK_lhs_161795
#        NotifyCode(curPlayer, "PK_lhs_161795")
#        return False
    
    #¼ì²éÍæ¼Ò״̬
    if not CheckTransState(curPlayer):
        return False
    
#    #Ñ£ÔÎʱ£¬²»¿É´«ËÍ
#    if curPlayer.GetAbnormalState() == IPY_GameWorld.sctFaint:
#        return False
    
    #=========================================================================================================
    # #À­ïÚ³µÖУ¬È˲»ÔÚïÚ³µÖÐÒ²²»ÄÜ´«ËÍ
    # if curPlayer.GetTruck() != None:
    #    NotifyCode(curPlayer, "HaveTruck_No_Trans")
    #    return False
    #=========================================================================================================
    
#    #±»¹¥»÷ʱºò, ÎÞ·¨Ê¹ÓÃ
#    if curPlayer.IsBattleState():
#        NotifyCode(curPlayer, "CannotAtk09")
#        return False
#    
#    #¶ÔÖÅÖÐ, ÎÞ·¨Ê¹ÓÃ
#    if curPlayer.GetIsConfronting():
#        NotifyCode(curPlayer, "CannotAtk09")
#        return False
    
    #¼ì²éÍæ¼ÒÊÇ·ñÔÚÆÕͨµØͼ
    if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
        #²¿·Ö¸±±¾ÔÊÐí´«ËͳöÈ¥
        if GameWorld.GetMap().GetMapID() not in IpyGameDataPY.GetFuncEvalCfg('DungeonDeliver', 1):
            NotifyCode(curPlayer, "Carry_lhs_844170") 
            return False
        
    if not GameWorld.IsCrossServer() and GetCrossMapID(curPlayer):
        NotifyCode(curPlayer, "CrossMap10") 
        return False
    
    if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
        GameWorld.Log("¿Í»§¶Ë×Ô¶¨Ò峡¾°ÏÂÎÞ·¨´«ËÍ!", curPlayer.GetPlayerID())
        return False
    
    return True


##µØͼÌØÊâÏÞÖƼì²é, ×°±¸¼ì²é
# @param curPlayer
# @return bool
def CheckEquipCanTrans(curPlayer, destMapID):
    if destMapID != 10060:
        return True
    
    #Óгá°ò¿ÉÒÔÉÏÌì¿Õ
    playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    curEquip = playerEquip.GetAt(IPY_GameWorld.retWing)
    if curEquip and not curEquip.IsEmpty():
        return True
    
    #GeRen_lhs_861048
    NotifyCode(curPlayer, "GeRen_lhs_861048", [destMapID])
    return False

#---------------------------------------------------------------------
##֪ͨ¿Í»§¶Ë, Íæ¼ÒLoading¿ªÊ¼
# @param curPlayer Íæ¼ÒʵÀý
# @param prepareTime Loadingʱ¼ä
# @param prepareType LoadingÀàÐÍ
# @param prepareID LoadingNPCID, ĬÈÏΪ0, ²»ÉèÖÃ
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ֪ͨ¿Í»§¶Ë, Íæ¼ÒLoading¿ªÊ¼
# ÌØÊâ˵Ã÷ChangePlayerAction -> SetPlayerAction ÖÐ ÔÚÀ­Ìõ״̬»á֪ͨ Sync_PrepareEnd£¬Ä¬ÈϽø¶ÈÌõÀàÐÍ
# Sync_PrepareEnd ֪ͨ0²ÅËã½ø¶ÈÌõ³É¹¦£¬ÆäËûΪʧ°Ü£¬×Ôµ÷ÓÃÂß¼­Ê±Çë×¢Òâ
def Sync_PrepareBegin(curPlayer, prepareTime, prepareType, prepareID=0):
    #ÖжÏÕ½¶·¶ÔÖÅ
    ExitPlayerConfronting(curPlayer)
    #´ò¶ÏÒƶ¯
    curPlayer.StopMove()
    #ÉèÖü¤»îÍæ¼Ò
    SetIsNeedProcess(curPlayer, True)
    #¿ªÊ¼Í¨ÖªLoading
    curPlayer.SetPrepareTime(prepareTime)
    curPlayer.SetPrepareState(prepareType)
    curPlayer.SetPrepareID(prepareID)
    curPlayer.Sync_PrepareBegin()
    
    #¿ÕÏÐת±äΪÆäËû״̬Ôòɾ³ýÓÐÏÞÎÞµÐBUFF
    tick = GameWorld.GetGameWorld().GetTick()
    DelLimitSuperBuff(curPlayer, tick)
    return

#---------------------------------------------------------------------
##Íæ¼Ò״̬¸Ä±ä
# @param curPlayer Íæ¼ÒʵÀý
# @param changeAction Çл»µÄ״̬
# @param forceChange ÊÇ·ñÇ¿ÖÆת»»
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò״̬¸Ä±ä
def ChangePlayerAction(curPlayer, changeAction, forceChange=False):
    curPlayerAction = curPlayer.GetPlayerAction()
    
    if curPlayerAction == changeAction:
        return
    
    #״̬±ä¸üҪ֪ͨվÁ¢
    DoPlayerStand(curPlayer)
    
    #ÖжÏÕ½¶·¶ÔÖÅ
    if changeAction in ChConfig.Def_PlayerCancelConfronting:
        ExitPlayerConfronting(curPlayer)
    
    #ʼþ״̬²»Çл», ±ÜÃâ¶Ô»°¿¨×¡
    if curPlayerAction == IPY_GameWorld.paEvent and not forceChange:
        if changeAction in [IPY_GameWorld.paNull, IPY_GameWorld.paAttack]:
            GameWorld.DebugLog("²»Ç¿ÖÆת»»×´Ì¬ %s" % changeAction, curPlayer.GetID())
            return
    
    # ²É¼¯Çл»
    if curPlayerAction == IPY_GameWorld.paPreparing:
        DoExitPreparing(curPlayer)
    
    curPlayer.SetPlayerAction(changeAction)
    
    if changeAction == IPY_GameWorld.paNull:
        return
    
    #¿ÕÏÐת±äΪÆäËû״̬Ôòɾ³ýÓÐÏÞÎÞµÐBUFF
    tick = GameWorld.GetGameWorld().GetTick()
    DelLimitSuperBuff(curPlayer, tick)
    
    return

##Í˳ö²É¼¯
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
def DoExitPreparing(curPlayer):
    NPCCommon.ClearCollectNPC(curPlayer)
    tagObj = curPlayer.GetActionObj()
    
    if tagObj == None:
        #ûÓÐÄ¿±ê
        GameWorld.Log("DoExitPreparing -> ûÓÐÄ¿±ê", curPlayer.GetPlayerID())
        return
            
    if tagObj.GetGameObjType() != IPY_GameWorld.gotNPC:
        #̸»°¶ÔÏ󲻶Ô
        GameWorld.Log("DoExitPreparing -> ²É¼¯¶ÔÏ󲻶Ô", curPlayer.GetPlayerID())
        return
    
    curNPC = GameWorld.GetNPCManager().GetNPCByIndex(tagObj.GetIndex())
    if curNPC == None:
        #ûÓÐÕâ¸öNPC
        GameWorld.Log("DoExitPreparing ->ûÓÐÕâ¸öNPC", curPlayer.GetPlayerID())
        return
    
    curNPC_HurtList = curNPC.GetPlayerHurtList()
    curNPC_HurtList.Clear()
    return

## Íæ¼Ò״̬¸Ä±ä(½Å±¾×Ô¶¨Òåö¾Ù)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param changeAction Çл»µÄ״̬
#  @return None
def ChangePyPlayerAction(curPlayer, changeAction):
    if GetPyPlayerAction(curPlayer, changeAction):
        #ÒѾ­ÊÇÕâ¸ö״̬
        return
    
    state = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PyPlayerAction)
    state = state | pow(2, changeAction)
    
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PyPlayerAction, state)
    return


## »ñÈ¡ÊÇ·ñÓиÃ״̬
#  @param curPlayer Íæ¼ÒʵÀý
#  @param changeAction Çл»µÄ״̬
#  @return ÊÇ·ñÓиÃ״̬
def GetPyPlayerAction(curPlayer, action):
    receiveState = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PyPlayerAction)
    
    state = receiveState & pow(2, action) 
    #GameWorld.DebugLog("receiveState = %s, state = %s" % (receiveState, state))
    return state != 0


#---------------------------------------------------------------------
##ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î
# @param curPlayer Íæ¼ÒʵÀý
# @param isNeedProcess ÊÇ·ñ¼¤»î
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î
def SetIsNeedProcess(curPlayer, isNeedProcess):
    curPlayerIsNeedProcess = curPlayer.GetIsNeedProcess()
    
    if curPlayerIsNeedProcess == isNeedProcess:
        return
    
    curPlayer.SetIsNeedProcess(isNeedProcess)
    GameWorld.GodLog(curPlayer, 'ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î:%s' % isNeedProcess)
    return

#---------------------------------------------------------------------
##Íæ¼ÒÊÇ·ñÔÚÕ½¶·×´Ì¬.
# @param curPlayer Íæ¼ÒʵÀý
# @return ²¼¶ûÖµ
# @remarks Íæ¼ÒÊÇ·ñÔÚÕ½¶·×´Ì¬
def IsPlayerInFight(curPlayer):
#    #Ö÷¶¯¶ÔÖÅÖÐ
#    if curPlayer.GetIsConfronting():
#        return True
    
    # ¹¥»÷ÖÐ
    if curPlayer.GetPlayerAction() == IPY_GameWorld.paAttack:
        return True
    
#    # ½øÈëÕ½¶·×´Ì¬
#    if curPlayer.IsBattleState():
#        return True

    return False
#---------------------------------------------------------------------
##×Ô¶¯½øÈëÕ½¶·¶ÔÖÅ //ÕâÀï²»¼ÓÏêϸÑéÖ¤
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ×Ô¶¯½øÈëÕ½¶·¶ÔÖÅ //ÕâÀï²»¼ÓÏêϸÑéÖ¤
def AutoEnterPlayerConfronting(curPlayer):
#    
#    if curPlayer.GetIsConfronting():
#        return
#    
#    actObj = curPlayer.GetActionObj()
#    
#    if not actObj:
#        return
#    
#    curPlayer.SetIsConfronting(True)
#    #֪ͨ¿Í»§¶Ë //0½øÈë;ÆäËûÍ˳ö
#    curPlayer.View_PlayerBattle(actObj.GetID(), actObj.GetGameObjType(), 0)
#    
#    #Ìí¼Ó²âÊÔÐÅÏ¢
#    GameWorld.GodLog(curPlayer, 'Server×Ô¶¯½øÈëÕ½¶·¶ÔÖųɹ¦')
    return

#---------------------------------------------------------------------
##//¶ÔÍâ½Ó¿Ú, Öж϶ÔÖÅ
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks //¶ÔÍâ½Ó¿Ú, Öж϶ÔÖÅ
def ExitPlayerConfronting(curPlayer):
#    if not curPlayer.GetIsConfronting():
#        return
#    
#    #Í˳ö¶ÔÖÅ
#    curPlayer.SetIsConfronting(False)
#    #֪ͨ¿Í»§¶Ë //0½øÈë;ÆäËûÍ˳ö
#    curPlayer.View_PlayerBattle(0, 0, 1)
#    
#    #Çå³ýÕ½³è³ðºÞ
#    PetControl.ClearFightPetAngry(curPlayer)
#    
#    #Ìí¼Ó²âÊÔÐÅÏ¢
#    GameWorld.GodLog(curPlayer, 'Í˳öÕ½¶·¶ÔÖųɹ¦')
    return

#---------------------------------------------------------------------
##²É¼¯´ò¶Ï
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ²É¼¯´ò¶Ï
def BreakPlayerCollect(curPlayer):
#    #²É¼¯¶¼²»´ò¶Ï
#    return
    
    if curPlayer.GetPlayerAction() != IPY_GameWorld.paPreparing:
        return
    #GameWorld.Log('    ²É¼¯´ò¶Ï curPlayer.GetPrepareState()=%s'%curPlayer.GetPrepareState())
    if curPlayer.GetPrepareState() not in [IPY_GameWorld.pstMissionCollecting, ShareDefine.Def_PstProduce]:
        #¼´²»ÊÇÈÎÎñ²É¼¯Ò²²»ÊÇÉú²ú²É¼¯
        return
    
    #¸±±¾Öв»´ò¶Ï
    #if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
    #    return
    
    tagObj = curPlayer.GetActionObj()
    
    if tagObj == None:
        #ûÓÐÄ¿±ê
        #GameWorld.Log("BreakPlayerCollect -> ûÓÐÄ¿±ê", curPlayer.GetPlayerID())
        return
            
    if tagObj.GetGameObjType() != IPY_GameWorld.gotNPC:
        #²É¼¯¶ÔÏ󲻶Ô
        #GameWorld.Log("BreakPlayerCollect -> ²É¼¯¶ÔÏ󲻶Ô", curPlayer.GetPlayerID())
        return
    
    curNPC = GameWorld.GetNPCManager().GetNPCByIndex(tagObj.GetIndex())
    if curNPC == None:
        #ûÓÐÕâ¸öNPC
        #GameWorld.Log("BreakPlayerCollect ->ûÓÐÕâ¸öNPC", curPlayer.GetPlayerID())
        return
    
    npcID = curNPC.GetNPCID()
    collectNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("CollectNPC", npcID)
    if not collectNPCIpyData:
        return
    
    if not collectNPCIpyData.GetCanBreakCollect():
        return
    
    #È¡Ïû²É¼¯×´Ì¬
    ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)
    
    if curPlayer.GetActionObj() != None:
        curPlayer.SetActionObj(None)
    return

#---------------------------------------------------------------------
##Íæ¼Ò´ò×ø
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò´ò×ø
def DoPlayerSit(curPlayer, tick):
    #ÒѾ­ÔÚ´ò×ø״̬ÁË
    if curPlayer.GetPlayerAction() == IPY_GameWorld.paSit:
        return
    
    #ֹ֪ͨͣÒƶ¯
    curPlayer.StopMove()
    #¼¤»îÍæ¼Ò״̬, »Ø¸´CDÊÇ3Ãë, Íæ¼Ò´ôÖÍΪ5Ãë, Òª¼¤»îÒ»ÏÂ
    SetIsNeedProcess(curPlayer, True)
    #Íæ¼Ò×øÏÂ
    curPlayer.Sit()
    
    #ÉèÖÃÕæÆø¿ªÊ¼»Ö¸´Ê±¼ä
    #curPlayer.SetDict(ChConfig.Def_PlayerKey_SitForZhenQi, tick)
    #ÉèÖøßЧÁ·¹¦¿ªÊ¼Ê±¼ä
    #curPlayer.SetDict(ChConfig.Def_PlayerKey_EfficientSit, tick)
    return

#---------------------------------------------------------------------
##Íæ¼ÒÕ¾Æð
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÕ¾Æð
def DoPlayerStand(curPlayer):
    #²»ÔÚ´ò×ø״̬
    if curPlayer.GetPlayerAction() != IPY_GameWorld.paSit:
        return
    
    curPlayer.Stand()
    
    
    return
#---------------------------------------------------------------------
##Íæ¼Ò²¥·Å±íÇé
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò²¥·Å±íÇé
def DoPlayerShowPlayerFace(curPlayer, faceType):
    #Çå¿ÕÍæ¼Òµã»÷
    curPlayer.SetActionObj(None)
    #֪ͨÖжÏÕ½¶·¶ÔÖÅ
    ExitPlayerConfronting(curPlayer)
    #ֹ֪ͨͣÒƶ¯
    curPlayer.StopMove()
    #֪ͨ¿Í»§¶Ë²¥·Å±íÇé
    curPlayer.View_ShowPlayerFace(faceType)
    return

#---------------------------------------------------------------------
##Íæ¼ÒËÀÍö
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒËÀÍö
def DoPlayerDead(curPlayer):
    
    #ֹ֪ͨͣÒƶ¯
    curPlayer.StopMove()

    #Íæ¼ÒËÀÍö
    curPlayer.SetDead(curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerID),
                      curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerType))
    return
#---------------------------------------------------------------------
##Íæ¼ÒË¢ÐÂ×ø±ê
# @param curPlayer Íæ¼ÒʵÀý
# @param checkObj ¼ì²é¶ÔÏó
# @param posX Æðµã×ø±êX
# @param posY Æðµã×ø±êY
# @param canChangeClientPos ÊÇ·ñÖØÖõ½¿Í»§¶Ë×ø±êµã
# @return ·µ»ØÖµÕæ, ˢгɹ¦
# @remarks Íæ¼ÒË¢ÐÂ×ø±ê
def PlayerRefreshPos(curPlayer, checkObj, posX, posY, canChangeClientPos=True):
    if not curPlayer.GetMapLoadOK():
        #Ë¢ÐÂʧ°Ü
        #×¢Òâ: Ò»¶¨ÒªÅжÏ, ÒòΪÔÚÍæ¼ÒʹÓü¼ÄܵÄʱºò»áË¢ÐÂÕâÀï
        #Èç¹ûÍæ¼Ò¶ÁȡûÓгɹ¦, ¾Í²»´¦ÀíÕâ¸ö·â°ü
        GameWorld.Log('µØͼûÓжÁÈ¡³É¹¦, Ë¢ÐÂʧ°Ü', curPlayer.GetPlayerID())
        return False
    
    if not curPlayer.GetSpeed():
        GameWorld.Log("ûÓÐËٶȲ»ÄÜË¢ÐÂ×ø±ê!", curPlayer.GetPlayerID())
        return False
    
    curMap = GameWorld.GetMap()
    
    #¼ì²éÍæ¼ÒͣϵÄ×ø±êÊÇ·ñÕýÈ·
    needResetPos = False
    
    if curMap.CanMove(posX, posY) != True:
        #ÌßÍæ¼ÒÏÂÏß
        #curPlayer.Kick(IPY_GameWorld.disPlayerPosError)
        #°ÑÍæ¼Ò´ò»ØÖØÉúµã
#        playerControl = PlayerControl(curPlayer)
#        playerControl.SetToBornPlace()
        #ÒÔÉÏ´¦ÀíÌ«¹ýÑϸñ, Ä¿Ç°²»Åж¨
        #-----------------------------------------
        #ÔÚÍæ¼ÒÖÜΧÕÒµ½Ò»¸ö¿É×ߵĵã, °ÑËû·Å¹ýÈ¥
        resultPos = GameMap.GetEmptyPlaceInArea(posX, posY, ChConfig.Def_DropItemDist)

        if resultPos.GetPosX() == posX and resultPos.GetPosY() == posY:
            #Íæ¼ÒÖØÖÃλÖÃʧ°Ü
            GameWorld.Log('Íæ¼ÒÖØÖÃλÖÃʧ°Ü, °ÑÍæ¼Ò´ò»ØÖØÉúµã posX = %s posY = %s' \
                          % (posX, posY), curPlayer.GetPlayerID())
#===============================================================================
#            playerControl = PlayerControl(curPlayer)
#            playerControl.SetToBornPlace()
#===============================================================================
            #ÔÝʱÍêÈ«ÐÅÈοͻ§¶Ë×ø±ê£¬±ÜÃâ±ßÔµ»¯ÎÞ·¨¹¥»÷ÎÊÌâ
            return False
        
        GameWorld.Log("×ø±ê´íÎ󣬼ì²éÍæ¼ÒͣϵÄ×ø±êÊÇ·ñÕýÈ· posX = %d, posY = %d, ÖØÖÃλÖÃ:posX = %d, posY = %d" \
                      % (posX, posY, resultPos.GetPosX(), resultPos.GetPosY()), curPlayer.GetPlayerID())
        
        posX = resultPos.GetPosX()
        posY = resultPos.GetPosY()
        
        #±ßÔµÕÏ°­µãÈÿͻ§¶ËÐÐ×ߣ¬·þÎñ¶Ë¸Ä±äλÖò»Í¨Öª
        #needResetPos = True
        #checkObj.ResetPos(posX, posY)
    
    #µ±Ç°¶ÔÏó×ø±ê
    objPosX = checkObj.GetPosX()
    objPosY = checkObj.GetPosY()
#    objDestPosX = checkObj.GetDestPosX()
#    objDestPosY = checkObj.GetDestPosY()
#    objStartX = checkObj.GetStartPosX()
#    objStartY = checkObj.GetStartPosY()
    #¼ÆËãÍæ¼Ò·¢¹ýÀ´µÄֹͣλÖúͷþÎñÆ÷ÒÑÓÐ×ø±êµÄ¾àÀë
    dist = GameWorld.GetDist(posX, posY, objPosX, objPosY)
    
    #Òƶ¯µÄÌص㣺¿Í»§¶ËÒƶ¯Îª1Ã×С¼ä¸ô·¢°ü£¬·þÎñ¶ËµÄUpdatePos ¾­³£ δִÐе¼ÖÂÎÞ·¨Òƶ¯£¬Òƶ¯ÐÐΪ±ä³É  __FixPlayerPos-¡·ChangePos¿ØÖÆ
    #Íâ²ãÒƶ¯tick ¿ØÖƼä¸ô·ÀÖ¹Íâ¹Ò°ü
    if dist <= 3:
        #µÚÒ»ÖÖÇé¿ö:¿Í»§¶ËºÍ·þÎñÆ÷¶Ë¾àÀë²î¾à·ûºÏÒªÇó
        #λÖÿÉÒÔ½ÓÊÜ
        __FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
        return True
    else:
        #¾àÀëÆ«²îÌ«´ó£¬À­»ØλÖò»×öÌßÈËÂß¼­
        needResetPos = True
        GameWorld.DebugLog('Client=(%s,%s), Server=(%s,%s), ²îÒì¾àÀë=%s' \
                     % (posX, posY, objPosX, objPosY, dist))
        posX = objPosX
        posY = objPosY
        __FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
        return False
    
    # ʵ¼Ê´Ëº¯ÊýÔÚ¶Ô»°  ¹¥»÷ Òƶ¯¶¼»á×ß½øÀ´Åж¨
    #===========================================================================
    # curPlayer.SetMoveCount(curPlayer.GetMoveCount() + 1)
    # if curPlayer.GetMoveCount() >= 10:
    #    curPlayer.SetMoveCount(0)
    #    curPlayer.SetMoveDistDiff(0)
    #    needResetPos = True
    #    
    # if curPlayer.GetMoveDistDiff() >= 30:
    #    curPlayer.SetMoveCount(0)
    #    curPlayer.SetMoveDistDiff(0)
    #    needResetPos = True
    #===========================================================================
    __FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)

    return True
#    curPlayer.SetMoveCount(curPlayer.GetMoveCount() + 1)
#    
#    #Def_PlayerMoveCheckClearCount:
#    #Íæ¼ÒÒƶ¯¶àÉÙ´ÎÇå¿ÕÕâ¸öÀۼƴíÎó        
#    if curPlayer.GetMoveCount() >= ReadChConfig.GetEvalChConfig('Def_PlayerMoveCheckClearCount'):
#        curPlayer.SetMoveCount(0)
#        curPlayer.SetMoveDistDiff(0)
#    
#    #¾àÀë(Æðµã-¿Í»§¶ËλÖÃ-·þÎñÆ÷¶ËλÖÃ-ÖÕµã)
#    severDist = GameWorld.GetDist(objPosX, objPosY, objDestPosX, objDestPosY)
#    severTotalDist = GameWorld.GetDist(objStartX, objStartY, objDestPosX, objDestPosY)
#    clientDist = GameWorld.GetDist(posX, posY, objDestPosX, objDestPosY)
#    
#    clientSlow = False
#    
#    if clientDist >= severDist and clientDist <= severTotalDist:
#        #·½Ïò
#        severDir = GameWorld.GetAngle(objStartX, objStartY, objDestPosX, objDestPosY) 
#        clientDir = GameWorld.GetAngle(posX, posY, objDestPosX, objDestPosY)
#    
#        clientSlow = True    
##===============================================================================
##        #2011-1-19 ´ËÖÖÇé¿öÒ²Òª¼ÆËãÎó²î
##        #Èç¹û½Ç¶È²î±ð10¶È, ÔòÈÏΪ¿ÉÒÔ½ÓÊÜ
##        dirDiff = 10
##        dirDiffValue = abs(severDir - clientDir)
##        
##        if dirDiffValue <= dirDiff:
##            #µÚ¶þÖÖÇé¿ö:·þÎñÆ÷±È¿Í»§¶Ë¿ì
##            #¿ÉÒÔ½ÓÊÜ
##            __FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
##            return True
##===============================================================================
#    #·þÎñÆ÷±È¿Í»§¶ËÂý#ChConfig.Def_AcceptPlayerStopPlaceDist:
#    if dist > ReadChConfig.GetEvalChConfig('Def_AcceptPlayerStopPlaceDist'):
#        return False
#        #ÌßÍæ¼ÒÏÂÏß
#        if clientSlow:
#            GameWorld.ErrLog("³¬´óÎó²î, ¿Í»§¶Ë±È·þÎñÆ÷Âý %d" % dist, curPlayer.GetPlayerID())
#        else:
#            GameWorld.ErrLog("³¬´óÎó²î, ·þÎñÆ÷±È¿Í»§¶ËÂý %d" % dist, curPlayer.GetPlayerID())
#            #·þÎñÆ÷¶Ë±È¿Í»§¶ËÂý¿ÉÒÔ½ÓÊÜ
#            return False
#        
#        #GameWorld.GodLog(curPlayer, '³¬´óÎó²î, Ôݲ»´¦Àí, clientSlow = %s, dist = %s'%(clientSlow, dist))
#        
#        #³¬´óÎó²î·âÍ£Õ˺Åʱ¼ä
#        closeAccIDTime = ReadChConfig.GetEvalChConfig('Def_BigErrorDistCloseAccTime')
#    
#        if closeAccIDTime > 0:
#            #³¬´óÎó²î·âÍ£Íæ¼Ò
#            PlayerGMOper.ClosePlayerByAccID(curPlayer, closeAccIDTime, 'BigErrorDist = %s Kick' % (dist))
#        else:
#            #³¬´óÎó²îÌß³öÍæ¼Ò
#            curPlayer.Kick(IPY_GameWorld.disPlayerMoveToFar)
#    
#        return False
#    
#    #ֹͣλÖÿɽÓÊÜ,µ±Ðè¼Ç¼
#    curMoveDistDiff = curPlayer.GetMoveDistDiff() + dist
#    curPlayer.SetMoveDistDiff(curMoveDistDiff)
#    
#    #ÐÂÔöÒƶ¯×ø±ê²îÖµDebugÌáʾÐÅÏ¢,·½±ã¿Í»§¶Ë²éѯ
#    GameWorld.GodLog(curPlayer, 'Client=(%s,%s), Server=(%s,%s), ÀÛ¼Ó¾àÀë=%s, ÀÛ¼Ó×ÜÖµ=%s' \
#                     % (posX, posY, objPosX, objPosY, dist, curPlayer.GetMoveDistDiff()))
#    
#    #Íæ¼ÒÒƶ¯100´Î¼ì²éÒ»´Î
#    if curPlayer.GetMoveCount() >= ReadChConfig.GetEvalChConfig('Def_PlayerMoveCheckCount'):
#        maxMoveDistDiff = ReadChConfig.GetEvalChConfig('Def_PlayerMoveCheckDist')
#        #2009/07/15 Òò¸±±¾À­ÈË˲¼ä¾àÀë¹ý´ó£¬¸±±¾Åж¨¾àÀëË«±¶
#        if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
#            maxMoveDistDiff = maxMoveDistDiff * 2
#        
#        if curMoveDistDiff >= maxMoveDistDiff:
#            return False
#            GameWorld.Log("Íæ¼ÒÒƶ¯´íÎó´ÎÊý = %s, Òƶ¯ÀۼƾàÀë = %s, ÌßÍæ¼ÒÏÂÏß" \
#                          % (curPlayer.GetMoveCount(), curMoveDistDiff), curPlayer.GetPlayerID())
#            
#            closeAccIDTime = ReadChConfig.GetEvalChConfig('Def_MoveDistErrorCloseAccTime')
#            
#            if closeAccIDTime > 0:
#                PlayerGMOper.ClosePlayerByAccID(curPlayer, closeAccIDTime, 'MoveCheckKick, ErrDist = %s' \
#                                                % (curMoveDistDiff))
#            else:
#                curPlayer.Kick(IPY_GameWorld.disPlayerMoveAddUpError)
#
#            return False
#
#    #µÚ3ÖÖÇé¿ö:¼Ç¼²¢½ÃÕý×ø±ê
#    __FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
#    return True

#---------------------------------------------------------------------
##½ÃÕýÍæ¼Ò×ø±ê
# @param checkObj ¼ì²éµÄ¶ÔÏó
# @param changePosX ½ÃÕýµÄ×ø±êX
# @param changePosY ½ÃÕýµÄ×ø±êY
# @param needResetServerPos  ÊÇ·ñ°´·þÎñÆ÷λÖÃÖØÖÃ
# @param needChangeClientPos ÊÇ·ñ°´¿Í»§¶ËλÖÃÖØÖÃ
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ½ÃÕýÍæ¼Ò×ø±ê
def __FixPlayerPos(checkObj, changePosX, changePosY, needResetServerPos, needChangeClientPos):
    #---°´·þÎñÆ÷λÖÃÖØÖÃ---
    if needResetServerPos:
        checkObj.ResetPos(changePosX, changePosY)
        return
    
    #---°´¿Í»§¶ËλÖÃÖØÖÃ---
    if needChangeClientPos:
        checkObj.ChangePos(changePosX, changePosY)
        return
    
    return
#---------------------------------------------------------------------
def OnDelayDeleteMirror(curPlayer, tick):
    addTick = curPlayer.GetDictByKey("DelayDeleteMirror")
    if not addTick:
        return
    if tick - addTick < 10000: # 10sºó»ØÊÕ
        return
    DeleteMirror(curPlayer, False)
    return True

def DeleteMirror(curPlayer, isDelay=False):
    ''' »ØÊÕ¾µÏñÍæ¼Ò
    '''
    if not curPlayer.GetRealPlayerID():
        return
    playerID = curPlayer.GetPlayerID()
    if isDelay:
        #ÓÉÓÚϵͳ³¡´Î¿ìËÙÕ½¶·Ô­Òò£¬Èç¹ûÁ¢Âí»ØÊÕ¿ÉÄܵ¼ÖÂij¸ö¹¦ÄܳöÏÖÎÊÌâ
        #Èç±»¶¯¼¼ÄÜЧ¹û£¬Ö´ÐÐ˳ÐòµÄÔ­Òò£¬Èç»÷ɱºó -> ½áËã -> »ØÊÕÍæ¼Ò -> ´¥·¢±»¶¯¼¼ÄÜ£¬µ¼ÖÂÒì³£
        GameWorld.DebugLog("¾µÏñÍæ¼ÒÉèÖÃÑÓ³Ù»ØÊÕ!", playerID)
        SetPlayerSightLevel(curPlayer, playerID)
        tick = GameWorld.GetGameWorld().GetTick()
        curPlayer.SetDict("DelayDeleteMirror", tick)
        return
    GameWorld.DebugLog("¾µÏñÍæ¼Ò»ØÊÕ!", playerID)
    #ɱËÀËùÓÐÕÙ»½µÄÁé
    KillPlayerSummonNPC(curPlayer)
    #ÕÙ»½»Ø³öÕ½µÄ³èÎï
    PetControl.ReCallFightPet(curPlayer)
    curPlayer.DeleteMirror()
    return

##ɱËÀÍæ¼ÒËùÓеÄÕÙ»½ÊÞËÀÍö
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ɱËÀÍæ¼ÒËùÓеÄÕÙ»½ÊÞËÀÍö
def KillPlayerSummonNPC(curPlayer):
    #½«Éæ¼°µ½C++ÖÐÁбíɾ³ýµÄ¹¦ÄÜ,ͳһ¸Ä³É -> ¸´ÖÆPyÁбíºó,È»ºó½øÐÐɾ³ýÂß¼­ (ÒòWhileÓм¸Âʽ«µ¼ÖÂËÀËø)
    summon_List = []
    for index in range(curPlayer.GetSummonCount()):
        curSummonNPC = curPlayer.GetSummonNPCAt(index)
        summon_List.append(curSummonNPC)
    
    for summonNPC in summon_List:
        NPCCommon.SetDeadEx(summonNPC)    
    return
#---------------------------------------------------------------------
##¼ì²éÍæ¼ÒͨÓõÄ״̬ת»»
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÕæ, ÔÊÐíÇл»×´Ì¬
# @remarks ¼ì²éÍæ¼ÒͨÓõÄ״̬ת»»
def PlayerCanStateTransfer(curPlayer):
    curPlayerAction = curPlayer.GetPlayerAction()
    #Èç¹ûÍæ¼ÒÊÇ×øÏÂ״̬, ×Ô¶¯×ª»»ÎªÕ¾Á¢×´Ì¬
    #DoPlayerStand(curPlayer)
        
    return (curPlayerAction in ChConfig.Def_Player_Can_Transfer_State)

#------------------------------Íæ¼ÒÀ뿪·þÎñÆ÷µÄÂß¼­------------------------------------
#---------------------------------------------------------------------
##ïÚ³µÏÂÏßÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ïÚ³µÏÂÏßÂß¼­
def __TruckPlayerDisconnect(curPlayer):
    return

    #ÔÚïÚ³µ
    if PlayerTruck.GetHaveAutoTruck(curPlayer):
        curPlayerTruck = curPlayer.GetTruck()
        curPlayerTruck.SetOwner(None)
        PlayerTruck.PlayerTruckDown(curPlayer, curPlayerTruck)
        
    return
#---------------------------------------------------------------------
##ÆïÂíÏÂÏßÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ÆïÂíÏÂÏßÂß¼­
def __RidingHorsePlayerDisconnect(curPlayer):
    #ÔÚÆïÂí
    if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse:
        #Ö´ÐÐÏÂÂíÂß¼­
        PlayerHorse.PlayerRideHorseDown(curPlayer, False)
        
    return
#---------------------------------------------------------------------
##Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼­
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼­
def __PlayerLeaveServerLogic(curPlayer, tick, isDisconnect):
    #¸øÓèÍæ¼Ò²¹³¥
    #PlayerExpiation.GivePlayerExpiation(curPlayer, tick)
    
    #ÔËÐÐÀëÏßxml
    EventShell.EventResponse_OnLeaveMap(curPlayer)
    
    #Èç¹ûÍæ¼ÒÓÐæô³µ, °Ñæô³µµÄÖ÷ÈËÉèÖÃΪNone
    curPlayerTruck = curPlayer.GetTruck()
    
    if curPlayerTruck != None:
        curPlayerTruck.SetOwner(None)

    #ˢм¼ÄÜÊ£Óàʱ¼ä
    SkillCommon.RefreshAllSkillRemainTime(curPlayer, tick)
    
    #Èç¹ûÔÚ½»Ò×״̬,È¡Ïû½»Ò×Ë«·½µÄ½»Ò×״̬²¢½â³ý½»Ò×À¸ÖÐÎïÆ·Ëø¶¨×´Ì¬
    PlayerTrade.LeaveTrade(curPlayer, 0)
    
    #¶ÓÎéÍæ¼ÒÍ˳öµØͼ
    PlayerTeam.TeamPlayerLeaveMap(curPlayer, tick, isDisconnect)

    #Í˳ö²É¼¯
    NPCCommon.ClearCollectNPC(curPlayer)
    #½áÊøʼþ
    EventShell.DoExitEvent(curPlayer)

    #ÉèÖÃÍæ¼ÒµÄµØͼλÖÃ, Èç¹ûÊǸ±±¾, À뿪¸±±¾
#    ¸±±¾¹æÔò:
#    1. Ò»¸ö¶ÓÎéÖ»ÓÐÒ»¸ö¸±±¾, Èç¹ûÓжÓÔ±µÄ¸±±¾ºÍ¶ÓÎ鸱±¾²»Ò»ÖÂ, Ôò´Ó¸±±¾ÖÐÌß³ö´Ë¶ÓÔ±
#    2. Íæ¼ÒÏÂÏßÔÙÉÏ, ¾ÍÀ뿪¸±±¾
#    3. Èç¹ûûÓÐÍæ¼Ò´æÔÚ, ¸±±¾»ØÊÕ
    if GameWorld.GetMap().GetMapFBType() != 0:
        #À뿪¸±±¾
        fbIndex = GameWorld.GetGameWorld().GetCurGameWorldIndex()
        exitFBType = 1 if isDisconnect else 2
        PyGameData.g_lastExitFBType[fbIndex] = [exitFBType, tick]
        #GameWorld.DebugLog("Íæ¼ÒÀ뿪¸±±¾£ºfbIndex=%s,exitFBType=%s, %s" % (fbIndex, exitFBType, PyGameData.g_lastExitFBType), curPlayer.GetPlayerID())
        FBLogic.DoExitFBLogic(curPlayer, tick)
    
    #Çå¿ÕËùÓв»ÊôÓÚ×Ô¼ºµÄ¹â»·
    #__ClearNoMeAuraBuff(curPlayer)
    
    #Çå¿ÕËùÓÐÀ뿪µØͼ²»ÐèÒª±£´æµÄBuff
    __ClearLeaveNoSaveBuff(curPlayer)
    
    #---±£´æÍæ¼ÒÔÚÏßʱ¼ä(°´ÃëËã)---
    UpdateOnLineTime(curPlayer, tick)
    
    PassiveBuffEffMng.OnPlayerLeaveMap(curPlayer)
    
    MirrorAttack.OnPlayerLeaveMap(curPlayer)
    
    #À뿪µØͼÇå¿Õ¶ñÒâ¹¥»÷×Ô¼ºÍæ¼ÒÐÅÏ¢
    if curPlayer.GetPlayerID() in PyGameData.g_maliciousAttackDict:
        PyGameData.g_maliciousAttackDict.pop(curPlayer.GetPlayerID())
        
    PyGameData.g_needRefreshMapServerState = True # ÓÐÍæ¼ÒÀ뿪µØͼÉèÖÃÐèҪˢÐÂ
    
    PlayerSuccess.FinishDelayAddSuccessProgress(curPlayer, tick)
    playerID = curPlayer.GetPlayerID()
    if not isDisconnect:
        CrossPlayerData.ClearCrossSyncDataCache(curPlayer)
        PyGameData.g_fbBuyBuffTimeDict.pop(playerID, None)
    #Çå³ýµØͼÍæ¼Ò»º´æ
    PyGameData.g_playerFuncAttrDict.pop(playerID, None)
    PyGameData.g_playerEquipPartAttrDict.pop(playerID, None)
    PyGameData.g_equipChangeClassLVInfo.pop(playerID, None)
    NPCCommon.ClearPriWoodPile(curPlayer)
    #ÒƳýµØͼ»º´æµÄ¾³½çÄѶÈÍæ¼ÒIDÐÅÏ¢
    for playerIDList in PyGameData.g_realmDiffPlayerDict.values():
        if playerID in playerIDList:
            playerIDList.remove(playerID)
    return

##¸üб£´æÍæ¼ÒÔÚÏßʱ¼ä
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ätick
# @return 
def UpdateOnLineTime(curPlayer, tick):
    #---±£´æÍæ¼ÒÔÚÏßʱ¼ä(°´ÃëËã)---
    lastCalcTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcOLTimeTick)
    if lastCalcTick <= 0:
        curPlayer.SetDict(ChConfig.Def_PlayerKey_CalcOLTimeTick, tick)
        return
    
    curPlayer.SetDict(ChConfig.Def_PlayerKey_CalcOLTimeTick, tick)
    
    diffSec = (tick - lastCalcTick) / 1000
    if diffSec > 0:
        curPlayer.SetWeekOnlineTime(curPlayer.GetWeekOnlineTime() + diffSec)
        curPlayer.SetOnlineTime(curPlayer.GetOnlineTime() + diffSec)
        SyncOnLineTimeTotal(curPlayer)
        
    return

##ͬ²½ÔÚÏßʱ¼ä
# @param curPlayer Íæ¼ÒʵÀý
# @return 
def SyncOnLineTimeTotal(curPlayer):
    sendPack = ChPyNetSendPack.tagMCOnLineTimeTotal()
    sendPack.Clear()
    sendPack.OnLineTimeTotal = curPlayer.GetOnlineTime()
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

##ͬ²½×îºóÒ»´Î±³°ü¿ª¸ñÔÚÏßʱ¼ä
# @param curPlayer Íæ¼ÒʵÀý
# @param packType ±³°üÀàÐÍ
# @return 
def SyncOnLineTimeLastOpenPack(curPlayer, packType):
    return
    sendPack = ChPyNetSendPack.tagMCOnlineTimeLastOpenPack()
    sendPack.Clear()
    sendPack.PackType = packType
    sendPack.LastOnLineTime = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick % packType)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

##À뿪µØͼÇå¿Õ²»±£´æµÄBuff
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks À뿪µØͼÇå¿Õ²»±£´æµÄBuff
def __ClearLeaveNoSaveBuff(curPlayer):
    #×°±¸BuffºÍ±»¶¯BuffÕâÀï²»Çå, Çл»µØͼºó»áÖØмÆËã
    
    #Çå¿ÕËùÓг¡¾°ÀàBuff
    curPlayer.GetMapBuff().Clear()
    
    #2011-01-28 ÐÞ¸ÄΪ¿É±£´æ£¬¹Ê´Ë´¦²»É¾³ý
    #Çå¿ÕËùÓпØÖÆÀàBUFF
    #BUG: ¿ØÖÆÀàBUFF²»´æÊý¾Ý¿â£¬ÇеØͼºó²»Í¨ÖªÏûʧ£¬¿Í»§¶ËÎÞ·¨É¾³ý
    #curPlayer.GetActionBuffManager().Clear()
    return


## Çå³ýÏÂÏßÏûʧµÄbuff, ÔÚ¸üÐÂÅÅÐаñ֮ǰ
#  @param curPlayer: Íæ¼ÒʵÀý
#  @return 
def __DisconnectClearBuff(curPlayer, tick):

    #ÐèÒª¿¼ÂÇbuff,deBuff,aura,incBuff,mapBuff,³ýÁËequipBuff²»¿¼ÂÇ
    PlayerClearBuff_Single(curPlayer, curPlayer.GetBuffState(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetDeBuffState(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetAura(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetIncBuff(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetMapBuff(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetActionBuffManager(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessBuffState(), ClearBuffByDisconnect, tick)
    PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessDeBuffState(), ClearBuffByDisconnect, tick)
    
    #BUFFЧ¹ûÔÚÍâ²ã¼ÆËã
    #SkillShell.RefreshPlayerBuffOnAttrAddEffect(curPlayer)
    return

#---------------------------------------------------------------------
##Íæ¼ÒÀ뿪·þÎñÆ÷
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÀ뿪·þÎñÆ÷
def PlayerLeaveServer(curPlayer, tick):
    #³èÎïÏÂÏßÂß¼­, ÕâÀïÒª½øÐÐÅÅÐаñ, ÓÅÏÈ×ö, ±ÜÃâÍæ¼Ò¹â»·µÈÊôÐÔÓ°Ïì³èÎïÊôÐÔʧЧ
    PetControl.DoLogic_PetInfo_OnLeaveServer(curPlayer, tick)
    
    #Çå³ýÏÂÏßÏûʧµÄbuff, ÔÚ¸üÐÂÅÅÐаñ֮ǰ
    __DisconnectClearBuff(curPlayer, tick)
    
    #Çå³ý»ØÊÕÕ½
    #DelRecylcePack(curPlayer)
    
    #ÖØÐÂˢнÇÉ«ÊôÐÔ
    playerControl = PlayerControl(curPlayer)
    playerControl.RefreshAllState()
            
    #Íæ¼ÒÏÂÏ߸üÐÂÅÅÐаñ
    PlayerBillboard.UpdatePlayerBillboardOnLeaveServer(curPlayer) #ÅÅÐаñÒÑʵʱ¸üУ¬¹ÊÏÂÏß²»ÔÙͬ²½
    
    #Íæ¼ÒÏÂÏß֪ͨgameserver¼Ç¼»º´æ£¨·ÅÔÚÏÂÏ߸üÐÂÅÅÐаñÖ®ºó£¬·½±ãGameserverÅжÏÊÇ·ñÐèÒª´æÈëÊý¾Ý¿âÖУ©
    PlayerViewCacheTube.OnPlayerLogOut(curPlayer, tick)
    
    #Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼­
    __PlayerLeaveServerLogic(curPlayer, tick, True)
    #ÆïÂíÍæ¼ÒÏÂÏßÂß¼­
    __RidingHorsePlayerDisconnect(curPlayer)
    #ïÚ³µÏÂÏßÂß¼­
    __TruckPlayerDisconnect(curPlayer)
    #ÕÙ»½ÊÞËÀÍö
    KillPlayerSummonNPC(curPlayer)
    #¸üдӱ¾µØͼÀëÏßÐÅÏ¢
    PyGameData.g_disconnectPlayer[curPlayer.GetPlayerID()] = [tick, curPlayer.GetPosX(), curPlayer.GetPosY()]
    GameWorld.DebugLog("Íæ¼Ò´Ó±¾µØͼÀëÏß: %s" % PyGameData.g_disconnectPlayer, curPlayer.GetPlayerID())
    return

def GetPlayerLeaveServerTick(playerID):
    # »ñÈ¡Íæ¼Ò´Ó±¾µØͼÖÐÀëÏßʱµÄtick, ×î´óÖ§³Ö1Сʱ, Èç¹ûÓÐÐèÒª´óÓÚ1СʱµÄÇëµ÷Õû³¬Ê±ÏÞÖÆ
    # ×¢: ·µ»ØֵΪ0ʱ£¬Ö»ÄÜ´ú±íÍæ¼Ò²»ÊÇÔÚ±¾µØͼÀëÏß1СʱÄÚ£¬²¢²»ÄÜ´ú±íÍæ¼Òµ±Ç°ÊÇ·ñÔÚÏß״̬£¬¿ÉÄÜÔÚÆäËûµØͼ
    if playerID not in PyGameData.g_disconnectPlayer:
        return 0
    return PyGameData.g_disconnectPlayer[playerID][0]

def GetPlayerLeaveServerPos(playerID):
    # »ñÈ¡Íæ¼Ò´Ó±¾µØͼÖÐÀëÏßʱµÄ×ø±ê
    # ×¢£ºÊ¹Óñ¾º¯Êýʱ£¬Ò»¶¨ÒªÏÈʹÓú¯Êý GetPlayerLeaveServerTick È·±£ÊÇ´Ó±¾µØͼÖÐÀëÏߵIJſÉʹÓÃ
    # @return: posX, posY
    if playerID not in PyGameData.g_disconnectPlayer:
        return 0, 0
    return PyGameData.g_disconnectPlayer[playerID][1:3]

def RemoveTimeoutLeaveServerPlayerInfo(tick):
    # Ôݶ¨Ã¿ÌìÁ賿5µãÖ´ÐÐÒ»´Î
    for playerID, leaveInfo in PyGameData.g_disconnectPlayer.items():
        leaveTick = leaveInfo[0]
        if tick - leaveTick > 3600000: # Çå³ý³¬Ê±1СʱµÄ¼Ç¼
            PyGameData.g_disconnectPlayer.pop(playerID)
    return

def RemoveLeaveServerPlayerInfo(playerID):
    # ÉÏÏßÒƳýÔÚ±¾µØͼÏÂÏߵļǼ
    if playerID in PyGameData.g_disconnectPlayer:
        PyGameData.g_disconnectPlayer.pop(playerID)
        GameWorld.DebugLog("½øÈë±¾µØͼ£¬ÒƳýÉÏ´ÎÔÚ±¾µØͼÀëÏ߼Ǽ!", playerID)
    return


##Çå³ý»ØÊÕÕ½
# @param None
# @return None
def DelRecylcePack(curPlayer):
    backPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptRecycle)
    
    for i in range(backPack.GetCount()):
        curItem = backPack.GetAt(i)
        
        if not curItem or curItem.IsEmpty():
            continue
        
        curItem.Clear()
    
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_DelPackIndex, 0)
    return


##Çл»µØͼïÚ³µÉ趨
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÕæ,¿ÉÒÔ´øÉÏïÚ³µÇл»µØͼ
# @remarks Çл»µØͼïÚ³µÉ趨
def __GetCanChangeMapSetTruck(curPlayer):
    curTruck = curPlayer.GetTruck()
    #GameWorld.Log("Íæ¼Ò æô³µ Çл»µØͼÂß¼­")
    if curTruck == None:
        #GameWorld.Log("Íæ¼Ò ûÓÐ æô³µ")
        return False
    
    dist = GameWorld.GetDist(curTruck.GetPosX(), curTruck.GetPosY(),
                             curPlayer.GetPosX(), curPlayer.GetPosY())
    if dist > ChConfig.Def_PlayerTruckEventDist:
        #GameWorld.Log("Íæ¼ÒºÍæô³µ¾àÀë¹ýÔ¶, æô³µ²»Çл»  %d" %dist)
        return False
    
#    #Íæ¼ÒÏÂæô³µ
#    if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvTruck :
#        PlayerTruck.PlayerTruckDown(curPlayer,curTruck)
    #GameWorld.Log("Íæ¼ÒºÍæô³µÒ»ÆðÇл»µØͼ")
    #1. ÔÚ¶Ô·½µØͼ´´½¨æô³µ
    #curTruck.ResetWorldPos(mapID, targetPosX, targetPosY)
    #2. Ïûʧ±¾µØͼæô³µ
    
    return True

#---------------------------------------------------------------------
##Íæ¼Ò¿ªÊ¼Çл»µØͼ
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò¿ªÊ¼Çл»µØͼ
def DoPlayerResetWorldPos(curPlayer, tick):
    NotifyStartChangeMap(curPlayer) # ֪ͨ¿ªÊ¼Çл»µØͼ
    #Ôڴ˺¯ÊýÖв»¿ÉÖжÏ, Ò»¶¨Òªµ÷ÓÃDoResetWorldPosAndClearº¯Êý
    #·ñÔò, »áÔÚBalanceServerÖп¨×¡
    takeTruck = curPlayer.GetChangeMapTakeTruck()
    
    #Èç¹ûÓÐæô³µ, ´øÉÏæô³µ
    if takeTruck == True:
        if not __GetCanChangeMapSetTruck(curPlayer):
            takeTruck = False
            
    #Èç¹û²»Èôøæô³µ, ²¢ÇÒÍæ¼ÒÔÚÈËïÚºÏһ״̬, ÄÇôÈÃÍæ¼Òϳµ
    if takeTruck == False and curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvTruck:
        curTruck = curPlayer.GetTruck()
        if curTruck:
            PlayerTruck.PlayerTruckDown(curPlayer, curTruck)
        
    curPlayer.SetChangeMapTakeTruck(takeTruck)
    
    #À뿪µØͼ·þÎñÆ÷
    __PlayerLeaveServerLogic(curPlayer, tick, False)
    
    FBLogic.DoPlayerChangeMapLogic(curPlayer, tick)
    #summonList = list()
    #ÕٻسèÎï
    PetControl.ReCallFightPet(curPlayer)
    #1. ɾ³ý×Ô¼º²»ÐèÒªµÄÕÙ»½ÊÞ(»ðÑæÖ®ÁéµÈ)
    #±ØÐëÓÃwhile, ÒòΪÔÚÑ­»·ÖÐҪɾ³ý
    # ÕÙ»½ÊÞÇеØͼ²»´ø¹ýÈ¥
    while curPlayer.GetSummonCount():
        summonNPC = curPlayer.GetSummonNPCAt(0)
        NPCCommon.SetDeadEx(summonNPC)

#    summonIndex = 0
#    while summonIndex < curPlayer.GetSummonCount():
#        summonNPC = curPlayer.GetSummonNPCAt(summonIndex)
#        
#        #2009.4.21, Èç¹ûÕÙ»½ÊÞµÄËÙ¶ÈΪ0, ´ú±íÕâ¸öÕÙ»½ÊÞΪÕÈ×Ó
#        #Çл»µØͼ²»¿É´ø¹ýÈ¥
#        #֮ǰÓÃÓ²Åж¨µÄ
#        if summonNPC.GetSpeed() == 0:
#            #Çл»µØͼ²»ÄÜ´ø¹ýÈ¥
#            NPCCommon.SetDeadEx(summonNPC)
#            continue
#            
#        #Çл»µØͼ¿ÉÒÔ´ø¹ýÈ¥ , Çå¿ÕÕÙ»½ÊÞ³ðºÞ,ÉËѪÁбí
#        summonNPCControl = NPCCommon.NPCControl(summonNPC)
#        summonNPCControl.ClearNPCAngry()
#        summonNPCControl.ClearNPCHurtList()
#        summonList.append(summonNPC)
#        summonIndex += 1
        
    changeMapID = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID)
    # ¸üÐÂ×îºóÒ»´ÎÀ뿪µÄ·ÇÖÐÁ¢³£¹æµØͼ, ´ÓÖÐÁ¢µØͼÍ˳öʱÐèÒª»Øµ½¸ÃµØ·½£¬±ØÐëÔÚ DoResetWorldPosAndClear ֮ǰ¸üÐÂ
    if GameWorld.GetMap().GetMapFBType() == IPY_GameWorld.fbtNull and curPlayer.GetMapID() not in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4):
        mapID = curPlayer.GetMapID()
        posX = curPlayer.GetPosX()
        posY = curPlayer.GetPosY()
        lineID = curPlayer.GetClientLineID() # ³£¹æµØͼÓ÷ÖÏßID
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromMapID, mapID)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromPosX, posX)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromPosY, posY)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromLineID, lineID)
        GameWorld.DebugLog("×îºóÒ»´ÎÀ뿪µÄ·ÇÖÐÁ¢³£¹æµØͼ¸üÐÂ!mapID=%s,lineID=%s,Pos(%s,%s)" % (mapID, lineID, posX, posY))
    # µ±Ç°ÊÇ¿É·µ»ØµÄ¸±±¾µØͼ ÇÒ Ä¿±êµØͼΪ¸±±¾
    elif curPlayer.GetMapID() in ChConfig.Def_CanBackFBMap and curPlayer.GetMapID() != changeMapID \
        and GameWorld.GetMap().GetMapFBTypeByMapID(changeMapID) != IPY_GameWorld.fbtNull:
        mapID = curPlayer.GetMapID()
        posX = curPlayer.GetPosX()
        posY = curPlayer.GetPosY()
        lineID = GetFBFuncLineID(curPlayer) # ¸±±¾Óù¦ÄÜÏß·ID
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBMapID, mapID)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBPosX, posX)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBPosY, posY)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBLineID, lineID)
        GameWorld.DebugLog("½øÈ븱±¾Ê±£¬×îºóÒ»´ÎÀ뿪µÄ¿É·µ»ØµÄ¸±±¾ID¸üÐÂ!mapID=%s,lineID=%s,Pos(%s,%s)" % (mapID, lineID, posX, posY))
        
    # À뿪µØͼ
    PlayerAssist.OnPlayerLeaveMap(curPlayer)
    
    # ´Ó¸±±¾ÖÐÇÐͼ
    if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
        #ĬÈÏ»ØÂúѪ
        if GameObj.GetHP(curPlayer) > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie and GameObj.GetHP(curPlayer) < GameObj.GetMaxHP(curPlayer):
            GameObj.SetHPFull(curPlayer)
            
    #2. µ÷ÓÃÇл»µØͼ½Ó¿Ú
    curPlayer.DoResetWorldPosAndClear()
    
    #3. Íæ¼ÒÒѾ­´«Ë͹ýÈ¥ÁË, ɾ³ýÕâ¸öÍæ¼ÒµÄ¸½¼ÓÕÙ»½ÊÞ(æô³µ, »òÕß»ÆȪʹÕß)
    #for curSummon in summonList:
    #    NPCCommon.SetDeadEx(curSummon)
        
    if takeTruck == True:
        curTruck = curPlayer.GetTruck()
        
        if curTruck != None:
            curPlayer.SetTruck(None)
            curTruck.Disappear()
            
    return

#---------------------------------------------------------------------
##Íæ¼ÒÀ뿪¸±±¾
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÀ뿪¸±±¾
def PlayerLeaveFB(curPlayer):
    if not curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_RouteServerInitOK):
        #RouteServerδ³õʼ»¯²»ÔÊÐíÇл»µØͼ, »º´æ´¦Àí
        GameServerRefresh.Set_PlayerRouteServerInitOK_OnLeaveFB(curPlayer, 1)
        return
    
    GameWorld.Log("PlayerLeaveFB...", curPlayer.GetPlayerID())
    if GameWorld.IsCrossServer():
        CrossRealmPlayer.PlayerExitCrossServer(curPlayer)
        return
    
    funcLineID = 0
    enterFBFree = False
    #ÖÐÁ¢µØͼ»Øµ½ÉÏÒ»´Î·ÇÖÐÁ¢³£¹æµØͼ    
    if curPlayer.GetMapID() in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4) or curPlayer.GetMapID() in ChConfig.Def_CanBackFBMap:
        mapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromMapID)
        posX = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromPosX)
        posY = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromPosY)
        lineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromLineID)
        # ÖØÖÃ
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromMapID, 0)
        # ÀϺÅÖ§³Ö£¬±¾À´¾ÍÔÚÖÐÁ¢µØͼµÄ£¬·µ»ØÐÂÊÖ´å
        if not mapID:
            # {Ö°Òµ:[dataMapID,posX,posY], ...}
            createRoleMapDict = IpyGameDataPY.GetFuncEvalCfg("CreateRoleMap", 1, {})
            if not createRoleMapDict:
                return
            job = curPlayer.GetJob()
            lineID = 0
            if job in createRoleMapDict:
                mapID, posX, posY = createRoleMapDict[job]
            else:
                mapInfoList = createRoleMapDict.values()
                mapID, posX, posY = mapInfoList[0]
    #À뿪¸±±¾
    else:
        fromFBMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBMapID)
        # »Øµ½ÉÏÒ»´Î¿É·µ»ØµÄ¸±±¾Àï
        if fromFBMapID:
            mapID = fromFBMapID
            posX = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBPosX)
            posY = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBPosY)
            lineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBLineID)
            funcLineID = lineID # »Ø¸±±¾µÄÒªÖ¸¶¨¹¦ÄÜÏß·ID
            enterFBFree = True # ·µ»ØµÄÃâ·Ñ½øÈë
            # ÖØÖÃ
            NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBMapID, 0)
            GameWorld.DebugLog("À뿪¸±±¾£¬·µ»Ø¿É֮ǰ¿É·µ»ØµÄ¸±±¾! fromFBMapID=%s,lineID=%s,posXY(%s,%s)" % (mapID, lineID, posX, posY))
        else:
            mapID = curPlayer.GetFromMapID()
            posX = curPlayer.GetFromPosX()
            posY = curPlayer.GetFromPosY()
            lineID = curPlayer.GetFromLineID()
            
    if mapID == curPlayer.GetMapID():
        # Èç¹ûÔÚͬһÕŵØͼ, È¡DBÖØÉúµã, ÆÕͨµØͼÏÂÏßÖØÉÏʱFromMapID»á±»ÉèÖÃΪ±¾µØͼ
        gameMap = GameWorld.GetMap()
        mapID, posX, posY = gameMap.GetRebornMapID(), gameMap.GetRebornMapX(), gameMap.GetRebornMapY()
        #posX, posY = GameMap.GetNearbyPosByDis(posX, posY, ChConfig.Def_RebornPos_Area_Range)
        
    #copyMapID = curPlayer.GetCopyMapID()
    GameWorld.Log("PlayerLeaveFB MapID = %d, PosX = %d, PosY = %d" % (mapID, posX, posY), curPlayer.GetPlayerID())
    
    if GameWorldProcess.IsNoPlayerNeedCloseFB() and GameWorld.GetGameWorld().GetMapCopyPlayerManager().GetPlayerCount() == 1:
        #Èç¹û¸±±¾ÖÐÖ»ÓÐÕâÒ»¸öÈË, ÄÇô°ÑÕâ¸ö¸±±¾ÉèÖÃΪÍæ¼Ò°²È«ÏÂÏß, ¹Ø±Õ¸±±¾
        gameFB = GameWorld.GetGameFB()
        gameFB.SetIsSafeClose(1)
    
    #===============================================================================================
    # #Èç¹ûÍæ¼ÒÊÇËÀÍö״̬£¬ÔòÏȸ´»î£¬ÊÖÓβ߻®²»Ï븴»îÍ˳ö
    # if curPlayer.GetPlayerAction() == IPY_GameWorld.paDie:
    #    curPlayer.Reborn(ChConfig.rebornType_System)
    #    GameObj.SetHPFull(curPlayer)
    #    ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)
    #===============================================================================================
    
    PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, False, lineID, funcLineID=funcLineID, enterFBFree=enterFBFree)
    
    #ÔÚ¿ÕÏлòÕßÒƶ¯×´Ì¬ÏÂ,²ÅÄÜËøËÀÍæ¼Ò
    if curPlayer.GetPlayerAction() in [IPY_GameWorld.paNull] or curPlayer.IsMoving():
        #°ÑÍæ¼ÒËøËÀ
        curPlayer.BeginEvent()
    
    return

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

def PlayerEnterCrossServer(curPlayer, mapID, lineID):
    playerID = curPlayer.GetPlayerID()
    GameWorld.Log("Íæ¼ÒÇëÇó½øÈë¿ç·þµØͼ: mapID=%s,lineID=%s" % (mapID, lineID), playerID)
    if mapID not in ChConfig.Def_CrossMapIDList:
        return
    
    tick = GameWorld.GetGameWorld().GetTick()
    lastRequestTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RequestEnterCrossServerTick)
    if lastRequestTick and tick - lastRequestTick < 5000:
        GameWorld.DebugLog("    ÇëÇó½øÈë¿ç·þCDÖÐ!", playerID)
        NotifyCode(curPlayer, "RequestEnterCrossServerCD")
        return
    
    crossRegisterMap = curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_CrossRegisterMap)
    if crossRegisterMap:
        GameWorld.ErrLog("¿ç·þÒѾ­ÔÚÉÏ´«Êý¾Ý£¬²»Öظ´Ìá½»!crossRegisterMap=%s,mapID=%s" % (crossRegisterMap, mapID), playerID)
        return
    
    if GameWorld.IsCrossServer():
        GameWorld.DebugLog("¿ç·þ·þÎñÆ÷²»ÔÊÐí¸Ã²Ù×÷!")
        return
    
    if GetCrossMapID(curPlayer):
        GameWorld.ErrLog("Íæ¼Òµ±Ç°Îª¿ç·þ״̬£¬²»ÔÊÐíÔÙ´ÎÇëÇó½øÈë¿ç·þ!", curPlayer.GetPlayerID())
        return
    
    if not CrossRealmPlayer.IsCrossServerOpen():
        NotifyCode(curPlayer, "CrossMatching18")
        return
    
    if GameObj.GetHP(curPlayer) <= 0:
        NotifyCode(curPlayer, "CrossMap4")
        return
    
    if PlayerState.IsInPKState(curPlayer):
        NotifyCode(curPlayer, "SingleEnterPK", [mapID])
        return
    
    fbIpyData = FBCommon.GetFBIpyData(mapID)
    if fbIpyData:
        fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, lineID, False)
        if not fbLineIpyData:
            GameWorld.DebugLog("¸±±¾±íÕÒ²»µ½¸±±¾¶ÔÓ¦¹¦ÄÜÏß·!mapID=%s,lineID=%s" % (mapID, lineID))
            return
        ret = FBCommon.CheckCanEnterFBComm(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData)
        if ret != ShareDefine.EntFBAskRet_OK:
            return
        
        if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):
            GameWorld.DebugLog("    OnEnterFBEvent False!", curPlayer.GetPlayerID())
            if mapID in [ChConfig.Def_FBMapID_CrossBattlefield]:
                NotifyCode(curPlayer, "GeRen_chenxin_268121")
            else:
                NotifyCode(curPlayer, "SingleEnterDefaul")
            return
        
    # ÐèÒª¶¯Ì¬·Ö²¼Ïß·µÄµØͼ£¬·¢Ë͵½¿ç·þ·þÎñÆ÷½øÐзÖÅä
    if mapID in ChConfig.Def_CrossDynamicLineMap:
        extendInfo = {}
        if mapID == ChConfig.Def_FBMapID_CrossDemonKing:
            bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(mapID, lineID)
            if not bossID:
                return
            extendInfo["BossID"] = bossID
            
        msgDict = {"PlayerID":curPlayer.GetPlayerID(), "MapID":mapID, "FuncLineID":lineID, "LV":curPlayer.GetLV()}
        if extendInfo:
            msgDict.update(extendInfo)
        GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_EnterFB, msgDict)
    else:
        isSend = GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID, lineID=lineID)
        if not isSend:
            return
    curPlayer.SetDict(ChConfig.Def_PlayerKey_RequestEnterCrossServerTick, tick)
    return

##Íæ¼Ò½øÈ븱±¾
# @param curPlayer Íæ¼ÒʵÀý
# @param mapID µØͼID
# @param posX ×ø±êX
# @param posY ×ø±êY
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Òµ¥¶À½øÈ븱±¾
def PlayerEnterFB(curPlayer, mapID, lineID, posX=0, posY=0):
    mapID = FBCommon.GetRecordMapID(mapID)
    GameWorld.Log("Íæ¼ÒÇëÇó½øÈ븱±¾! mapID=%s,lineID=%s,posX=%s,posY=%s" 
                  % (mapID, lineID, posX, posY), curPlayer.GetPlayerID())
    
    # µ±ÈÕ»»Õ½Ã˲»¿É½øÈëµÄµØͼ, ¸ÄΪ°´Ð¡Ê±Ëã
    #if mapID in ChConfig.Def_ChangeFamilyCanNotEnterMap:
    #    if PlayerFamily.GetPlayerChangeFamilyPastHour(curPlayer) < 24:
    #        NotifyCode(curPlayer, 'jiazu_xyj_671654')
    #        return
        
#    #¿ç·þ»î¶¯ÈËÊý·ÖÁ÷´¦Àí
#    if GameWorld.IsCrossServer():
#        reqMapID = mapID
#        mapID = __GetMergeFBPlayerMapID(curPlayer, reqMapID)
#        if not mapID:
#            GameWorld.ErrLog("ÕÒ²»µ½¿É·ÖÅä½øÈëµÄ¿ç·þ»î¶¯µØͼID! reqMapID=%s" % reqMapID)
#            return
      
    #¹ýÂË·â°üµØͼID
    if not GameWorld.GetMap().IsMapIDExist(mapID):
        GameWorld.ErrLog('###·Ç·¨µØͼÊý¾Ý£¬mapID: %s' % (mapID), curPlayer.GetID())
        return
 
#    if not GameWorld.GetMap().CanMove(curPlayer.GetPosX(), curPlayer.GetPosY()):
#        # ×ø±ê²»¿ÉÒƶ¯Ôò²»ÄÜ´«ËÍ£¬²»È»»áµ¼ÖÂÍ˳ö¸±±¾ÎÞ·¨ÍË»ØÀ´Ô´µØ
#        GameWorld.ErrLog("Ô­ÕÏ°­µãÎÞ·¨Çл»µØͼ %s" % ([curPlayer.GetPosX(), curPlayer.GetPosY()]))
#        return
 
    #½øÈ븱±¾Í¨Óüì²é
    fbIpyData = FBCommon.GetFBIpyData(mapID)
    fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, lineID)
    sceneMapID = mapID if not fbLineIpyData else fbLineIpyData.GetMapID()
    tick = GameWorld.GetGameWorld().GetTick()
    if CheckMoveToFB(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, tick) != ShareDefine.EntFBAskRet_OK:
        return
#    if mapID == ChConfig.Def_FBMapID_XMZZ:
#        #ÏÉħ֮Õù
#        GameLogic_XMZZ.XMZZStartFight(curPlayer)
#        return
    if posX == 0 and posY == 0:
        ipyEnterPosInfo = FBCommon.GetFBLineEnterPosInfo(mapID, lineID, fbLineIpyData)
        retPos = FBLogic.OnGetFBEnterPos(curPlayer, mapID, lineID, ipyEnterPosInfo, tick)
        
        if not retPos:
            GameWorld.ErrLog("δÕÒµ½½øÈ븱±¾×ø±ê£¡mapID=%s,lineID=%s" % (mapID, lineID))
            return
        
        posX, posY = retPos
        
    #===============================================================================================
    # if not EventShell.DoLogic_EnterFbGameEvent(curPlayer, mapID, tick):
    #    GameWorld.Log("DoLogic_EnterFbGameEvent False£¡mapID=%s,lineID=%s" % (mapID, lineID))
    #    return 
    #===============================================================================================
    
    if curPlayer.IsMoving():
        curPlayer.StopMove()
    
    fbID = 0 # ºó¶ËµÄÐéÄâÏß·
    isSendToGameServer = False
    mapFBType = GameWorld.GetMap().GetMapFBTypeByMapID(sceneMapID) # ÅжÏÊÇ·ñ×é¶Ó±¾ÐèÒªÒÔ³¡¾°µØͼÅжϣ¬ÒòΪ²ß»®¿ÉÄÜÉ趨²»Í¬¹¦ÄÜÏß·IDµÄ¸±±¾ÀàÐͲ»Ò»Ñù£¬±ÈÈçС¾³½ç¡¢´ó¾³½ç
    if mapFBType == IPY_GameWorld.fbtTeam and curPlayer.GetTeamID():
        if curPlayer.GetTeamLV() != IPY_GameWorld.tmlLeader:
            GameWorld.Log("·Ç¶Ó³¤£¬ÎÞ·¨·¢Æð½øÈë×é¶Ó¸±±¾ÇëÇó!", curPlayer.GetPlayerID())
            return
        isSendToGameServer = True
    if isSendToGameServer or mapID in ChConfig.Def_MapID_SendToGameServer \
        or mapID in ReadChConfig.GetEvalChConfig("MapID_SendToGameServer"):
        extendParamList = []
        if mapID == ChConfig.Def_FBMapID_SealDemon:
            newbielineList = IpyGameDataPY.GetFuncEvalCfg('SealDemonNewbieLine', 1)
            # ÐÂÊÖÏß·ÌØÊâ´¦Àí£¬Ö±½Ó½øÈë
            if lineID in newbielineList:
                GameWorld.DebugLog("·âħ̳ÐéÄâÏß·ֻÄÜͨ¹ý×Ô¶¨Ò峡¾°½øÈëÌôÕ½£¡")
                #PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, False, fbID, funcLineID=lineID)
                return
            else:
                bossID = GameLogic_SealDemon.CurFBLineBOSSID(lineID)
                extendParamList = [bossID]
        elif mapID == ChConfig.Def_FBMapID_ZhuXianBoss:
            bossID = GameLogic_ZhuXianBoss.CurFBLineBOSSID(lineID)
            extendParamList = [bossID, -1]
            enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_EnterFbCntDay % ChConfig.Def_FBMapID_ZhuXianBoss)
            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(mapID, lineID)
            extendParamList = [bossID]
        elif mapID in ChConfig.Def_MapID_LineIDToPropertyID:
            enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_EnterFbCntDay % mapID)
            extendParamList = [enterCnt]
        SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList)
        return
    
    PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, False, fbID, funcLineID=lineID)
    return

##·¢Ë͵½GameServerÇëÇó½øÈ븱±¾
#@param curPlayer Íæ¼Ò
#@param mapID µØͼid
#@param lineID Ïß·id
#@param tick ʱ¼ä´Á
#@return ·µ»ØÖµÎÞÒâÒå
def SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList=[]):
    #lineID = FBLogic.GetPlayerFBLineID(curPlayer, mapID, tick)
    
    GameWorld.Log("SendToGameServerEnterFB mapID=%s,lineID=%s,extendParamList=%s" 
                  % (mapID, lineID, extendParamList), curPlayer.GetID())
    # »ñÈ¡Íæ¼ÒËùÊô·ÖÏß
    if lineID == None:
        lineID = FBLogic.GetPlayerFBLineID(curPlayer, mapID, tick)
        
    #GameWorld.DebugLog("send GameServer_QueryPlayerByID")
    # ÇëÇóGameServerÄ¿±ê¸±±¾GameWorldË÷Òý
    sendMsg = [mapID, lineID]
    sendMsg.extend(extendParamList)
    sendMsg = "%s" % sendMsg
    curPlayer.GameServer_QueryPlayerByID(ChConfig.queryType_EnterFB, 0, 'EnterFB', sendMsg, len(sendMsg))
    return
    
##¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔÒƶ¯µ½¸±±¾
#@param curPlayer Íæ¼ÒʵÀý
#@return ·µ»ØÖµÎÞÒâÒå
#@remarks ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔÒƶ¯µ½¸±±¾
def CheckMoveToFB(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, tick, isNotify=True, isTeamAsk=False):
    '''ÅжϿɷñ½øÈ븱±¾£¬°üº¬ÊÖ¶¯¼°Æ¥Åä
    @param isTeamAsk: ÊÇ·ñÊǶÓÎé½øÈëÇëÇóµÄ£¬Ò»°ãÊǶÓÎé״̬Ï£¬¶Ó³¤·¢Æð½øÈ븱±¾£¬ÐèÒª¼ì²é¶ÓÔ±¿É·ñ½øÈ룬´ËʱΪTrue£¬¿É×öһЩ¸½¼Ó´¦Àí
    @note: ²ß»®ÒªÇóÌáʾ°´ÓÅÏȼ¶À´£¬¸±±¾×ÔÉíµÄÌõ¼þÏÞÖÆÓÅÏÈÌáʾ£¬ÆäËû¸½¼ÓÌáʾÓÅÏȼ¶½ÏµÍ
    '''
    ret = FBCommon.CheckCanEnterFBComm(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, 1, isNotify, isTeamAsk)
    if ret != ShareDefine.EntFBAskRet_OK:
        return ret
    
    if GameObj.GetHP(curPlayer) <= 0:
        GameWorld.Log("Íæ¼ÒÒѾ­ËÀÍö, ÎÞ·¨½øÈ븱±¾!")
        return ShareDefine.EntFBAskRet_Dead
    
    if PlayerTJG.GetIsTJG(curPlayer):
        if isNotify:
            NotifyCode(curPlayer, "SingleEnterDefaul", [mapID])
        return ShareDefine.EntFBAskRet_TJG
    
    ## ¶ÓÎé¼ì²éµÄÇé¿ö£¬¶Ó³¤²»´¦Àí£¬Ö»´¦Àí¶ÓÔ±
    if isTeamAsk and curPlayer.GetTeamLV() != IPY_GameWorld.tmlLeader:
        # ºó¶ËÖ»×öboss״̬Ï£¬±»¶¯½øÈ븱±¾ÏÞÖÆ£¬·ÀÖ¹´òbossÖб»À­½øÈ¥¸±±¾
        # boss״̬µÄÆäËû´«ËÍÏÞÖÆÓÉÇ°¶Ë¿ØÖÆ£¬ÒòΪ²ß»®Òª¸ù¾Ý½çÃæÀ´´¦Àí£¬ÓÐЩ½çÃæÔÊÐí´«ËÍ£¬ÓÐЩ²»ÔÊÐí
        if PlayerState.IsInBossState(curPlayer):
            return ShareDefine.EntFBAskRet_BossState
        
    ## PK״̬¼ì²é
    if PlayerState.IsInPKState(curPlayer):
        if isNotify:
            NotifyCode(curPlayer, "SingleEnterPK", [mapID])
        return ShareDefine.EntFBAskRet_PKState
    
    ## ¿ç·þµØͼÖÐ
    if GetCrossMapID(curPlayer) and mapID not in ChConfig.Def_CrossMapIDList:
        if isNotify:
            NotifyCode(curPlayer, "CrossMap5", [mapID])
        return ShareDefine.EntFBAskRet_InCrossMap
    
    #===============================================================================================
    # # ÕâÀï²»×ö״̬ÏÞÖÆ£¬ÓÉÇ°¶Ë´¦Àí£¬ÒòΪ²ß»®Òª¸ù¾Ý½çÃæÀ´´¦Àí£¬Í¬Ò»´«Ë͹¦ÄÜÓпÉÄÜÔÚ²»Í¬½çÃæ
    # # PK״̬¼ì²é
    # if PlayerState.IsInPKState(curPlayer):
    #    if isNotify:
    #        NotifyCode(curPlayer, "SingleEnterPK", [mapID])
    #    return ShareDefine.EntFBAskRet_PKState
    # 
    # # ´òboss״̬¼ì²é
    # if PlayerState.IsInBossState(curPlayer):
    #    if isNotify:
    #        NotifyCode(curPlayer, "SingleEnterBoss", [mapID])
    #    return ShareDefine.EntFBAskRet_BossState
    #===============================================================================================
    
    playerAction = curPlayer.GetPlayerAction()
    if playerAction == IPY_GameWorld.paPreparing:
        if isNotify:
            NotifyCode(curPlayer, "SingleEnterGather", [mapID])
        return ShareDefine.EntFBAskRet_Preparing
    
    if playerAction == IPY_GameWorld.paSit:
        if isNotify:
            NotifyCode(curPlayer, "Carry_lhs_697674")
        return ShareDefine.EntFBAskRet_Sit
    
    if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
        if isNotify:
            NotifyCode(curPlayer, "Carry_lhs_697674")
        GameWorld.Log("¿Í»§¶Ë×Ô¶¨Ò峡¾°ÏÂÎÞ·¨½øÈ븱±¾!", curPlayer.GetPlayerID())
        return ShareDefine.EntFBAskRet_Other
    
    if playerAction in ChConfig.Def_Player_Cannot_TransState:
        #Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
        if isNotify:
            NotifyCode(curPlayer, "Carry_lhs_697674")
        return ShareDefine.EntFBAskRet_Other
    
    for index in ChConfig.Def_Player_NotCan_EnterFbPyGameEvenState:
        if GetPyPlayerAction(curPlayer, index):
            #Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
            if isNotify:
                NotifyCode(curPlayer, "Carry_lhs_697674")
            return ShareDefine.EntFBAskRet_Other
        
    #Òƶ¯Öв»Ö´Ðд˲Ù×÷
#    if curPlayer.IsMoving():
#        #NotifyCode(curPlayer, "GeRen_lhs_0")
#        return False

#    #À­ïÚÖÐÎÞ·¨´«Ë͵½¸±±¾
#    if curPlayer.GetTruck():
#        #NotifyCode(curPlayer, "Convey_Duplicate_Lost01")
#        return False

    #Õ½¶·×´Ì¬ÖÐÎÞ·¨´«Ë͵½¸±±¾
    #if curPlayer.IsBattleState():
    #    NotifyCode(curPlayer, "Carry_lhs_202580")
    #    return False

    #µ±Ç°µØͼ²»ÊÇÆÕͨµØͼ
    if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
        canFBMoveToOther = False
        fbEnableTransportMap = ReadChConfig.GetEvalChConfig("FBEnableTransportMap")
        curMapID = GameWorld.GetMap().GetMapID()
        if curMapID in fbEnableTransportMap and mapID in fbEnableTransportMap[curMapID]:
            canFBMoveToOther = True
        if curMapID in ChConfig.Def_CanBackFBMap:
            canFBMoveToOther = True
        toMapFBType = GameWorld.GetMap().GetMapFBTypeByMapID(mapID)
        if toMapFBType == IPY_GameWorld.fbtNull:
            if curMapID in IpyGameDataPY.GetFuncEvalCfg('DungeonDeliver', 1):
                canFBMoveToOther = True
        elif FBCommon.GetRecordMapID(curMapID) == FBCommon.GetRecordMapID(mapID):
            if FBLogic.CanChangeSameDataMapFB(curPlayer, mapID, lineID):
                canFBMoveToOther = True
                
        if not canFBMoveToOther:
            if isNotify:
                NotifyCode(curPlayer, "SingleEnterDungeon", [mapID])
            return ShareDefine.EntFBAskRet_InFB
    
    if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):
        GameWorld.DebugLog("    OnEnterFBEvent False!", curPlayer.GetPlayerID())
        if isNotify:
            NotifyCode(curPlayer, "SingleEnterDefaul")
        return ShareDefine.EntFBAskRet_Other
    
    return ShareDefine.EntFBAskRet_OK
#---------------------------------------------------------------------
##Ë¢ÐÂÍæ¼ÒʱÖÓ£¬ÇеØͼÍæ¼ÒʱÖӼǼÇå¿Õ£¬´¦ÀíÏàÓ¦Âß¼­
# @param curPlayer Íæ¼Ò
# @return ÎÞÒâÒå
# @remarks Ë¢ÐÂÍæ¼ÒʱÖÓ£¬ÇеØͼÍæ¼ÒʱÖӼǼÇå¿Õ£¬´¦ÀíÏàÓ¦Âß¼­
def RefreshPlayerTick(curPlayer):
    tick = GameWorld.GetGameWorld().GetTick()
    
    #·À³ÁÃÔÇÐÏßʱ¼ä
    PlayerGameWallow.DoLogic_WallowOnlineTime(curPlayer, tick)
    return


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

def PlayerResetWorldPosFBLineID(curPlayer, mapID, posX, posY, funcLineID):
    '''Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾¶ÔÓ¦µÄ¹¦ÄÜÏß·ID£¬ÊÊÓÃÓڶೡ¾°ºÏ²¢Ò»ÕŵØͼµÄÇé¿ö£¬ºó¶ËÐèÔÚͬһÕÅÎïÀíµØͼ²ÅÄÜʹÓøú¯Êý
    ÓÉÓÚÇ°¶ËµØͼºÏ²¢µÄ³¡¾°¼ÓÔØÊÇ·Ö¿ªµÄ£¬ËùÒÔÔÚÇг¡¾°µÄʱºò²»ÄÜÖ±½ÓÉèÖÃ×ø±ê£¬ÒòΪǰ¶Ëʵ¼ÊÉϲ»´æÔÚ¸Ã×ø±ê
    Íæ¼ÒÖ±½ÓÔÚµØͼÖÐÇл»¹¦ÄÜÏß·ID£¬´Ëʱǰ¶ËÐèÒª×ßÕý³£µÄÇÐͼÁ÷³Ì²ÅÄܼÓÔØÄ¿±ê¹¦ÄÜÏß·ID¶ÔÓ¦µÄ³¡¾°
    ¹ÊÕâÀï×ö¸öÐé¼ÙÇÐͼÁ÷³Ì
    '''
    if curPlayer.GetMapID() != mapID:
        return
    
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ReqFBFuncLine, funcLineID)
    GameWorld.Log("Íæ¼Ò¸±±¾Öбä¸ü¹¦ÄÜÏß·ÐéÄâÇеØͼ: mapID=%s,posX=%s,posY=%s,funcLineID=%s" 
                  % (mapID, posX, posY, funcLineID), curPlayer.GetPlayerID())
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeMapID, mapID)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ResetFBLinePosX, posX)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ResetFBLinePosY, posY)
    
    NotifyPrepareChangeMap(curPlayer, mapID, funcLineID)
    NotifyStartChangeMap(curPlayer)
    
    ## ·¢ËÍ 04 01 ÈËÎïËùÔڵij¡¾°³õʼ»¯#tagPlayerMapInit
    playerMapInit = ChNetSendPack.tagPlayerMapInit()
    playerMapInit.Clear()
    playerMapInit.MapID = mapID
    playerMapInit.PosX = posX
    playerMapInit.PosY = posY
    NetPackCommon.SendFakePack(curPlayer, playerMapInit)
    
    curPlayer.SetSight(0) # ÊÓÒ°ÖÃ0£¬Çгɹ¦ºó»Ö¸´ÊÓÒ°£¬·ÀÖ¹½ÓÏÂÀ´ÌáÇ°ÉèÖÃ×ø±êµ¼ÖÂÇ°¶ËÊÓÒ°Ë¢ÐÂÒì³£
    curPlayer.ResetPos(posX, posY) # ÕâÀïÖ±½ÓÉèÖÃ×ø±ê£¬·Àֹǰ¶Ëδ¼ÓÔس¡¾°³É¹¦µôÏßµ¼ÖÂÖصǺó×ø±ê´íÎó
    SetFBFuncLineID(curPlayer, funcLineID) # ÕâÀïÖ±½ÓÉèÖóÉÄ¿±ê¹¦ÄÜÏß·ID£¬·Àֹǰ¶Ëδ¼ÓÔس¡¾°³É¹¦µôÏßµ¼ÖÂÖصǺó¼ÓÔس¡¾°Òì³£
    
    ## ·¢ËÍ 01 09 ·þÎñÆ÷×¼±¸¾ÍÐ÷#tagServerPrepareOK
    prepareOK = ChNetSendPack.tagServerPrepareOK()
    prepareOK.Clear()
    NetPackCommon.SendFakePack(curPlayer, prepareOK)
    return


##Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾ID
# @param curPlayer Íæ¼ÒʵÀý
# @param mapID µØͼID
# @param posX ×ø±êX
# @param posY ×ø±êY
# @param takeTruck ÊÇ·ñ´øïÚ³µ
# @param FBID ¸±±¾ID, ÐéÄâÏß·ID
# @param msg Я´ýÐÅÏ¢
# @param canLock ÊÇ·ñËø¶¨Íæ¼Ò
# @param funcLineID ¸±±¾¹¦ÄÜÏß·ID£¬ÓÉÇ°¶ËÇëÇó
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾ID
def PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, takeTruck, fbID=0, msg='', canLock=True, funcLineID=0, enterFBFree=False):
    '''
    ²ÎÊý˵Ã÷:
        @param fbID:
            ´óÓÚ0µÄÕûÊý:
                Èç¹û²ÎÊýmapIDÖ¸¶¨µÄµØͼ´æÔÚfbIDÖ¸¶¨µÄ·ÖÏߣ¬ÔòÖ±½Ó´«Ë͵½²ÎÊýmapIDËùÖ¸¶¨µÄµØͼµÄfbIDËùÖ¸¶¨µÄ·ÖÏߣ¬·ñÔòÔÚËùÓдæÔڵķÖÏßÖУ¬Ëæ»úÑ¡Ò»Ìõ·ÖÏß´«Èë¡£fbIDµÄ¼ÆËã¼ûÏÂÃæfbID=-1µÄ˵Ã÷¡£
            -1£º
                ½Ó¿ÚÄÚ²¿×Ô¶¯Ìæ»»³Éµ±Ç°fbID£¬´«Èë²ÎÊýmapIDËùÖ¸¶¨µÄµØͼ£¨ÕâÀï²ÎÊýmapIDÆäʵÊÇDataMapID£©µÄͬһfbIDµÄµØͼ(Èç¹ûÓУ¬Ã»ÓÐÔòËæ»ú)¡£
                Ï־͵±Ç°fbIDµÄ¼ÆËã,¾ÙÀý˵Ã÷,¼ÙÉèµØͼAºÍµØͼBÔÚMapID.txtÅäÖÃÈçÏ£º
                MapName     MapID   DataMapID FBCount
                µØͼA         101     101     3
                µØͼB         102     101     3 
                ¼´µØͼAºÍµØͼBÓй²Í¬µÄDataMapID,ÄÇôµØͼB½ø³ÌÄÚ²¿µÄµÚÒ»Ìõ·ÖÏߵĿͻ§¶ËID¾ÍÊÇ3(ËùÓзÖÏߵĿͻ§¶Ë·ÖÏßID:0¡¢1¡¢2¡¢3¡¢4¡¢5)
            -2£º
                Ö±½ÓËæ»ú´«µ½²ÎÊýmapIDËùÖ¸¶¨µÄµØͼµÄijһÄÚ²¿·ÖÏߣ¬ÕâÀïµÄijһÄÚ²¿·ÖÏßÏÞÓÚMapID.txtÖÐmapIDΪ´«Èë²ÎÊýmapIDµÄµØͼ½ø³ÌµÄ·ÖÏß¡£
    
        @param funcLineID: ¹¦ÄÜÏß·ID
    '''
    tick = GameWorld.GetGameWorld().GetTick()
    lastTransTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TransTick)
    #Ôݶ¨1Ãë
    if tick - lastTransTick < 1000:
        GameWorld.Log("Íæ¼ÒÇÐͼCDÖÐ: mapID=%s,posX=%s,posY=%s,takeTruck=%s,fbID=%s,msg=%s,funcLineID=%s,tick=%s,lastTransTick=%s" 
                      % (mapID, posX, posY, takeTruck, fbID, msg, funcLineID, tick, lastTransTick), curPlayer.GetPlayerID())
        NotifyCode(curPlayer, "MapMoveCD")
        return
    curPlayer.SetDict(ChConfig.Def_PlayerKey_TransTick, tick)
    
    sceneMapID = mapID
    if GameWorld.GetMap().GetMapFBTypeByMapID(mapID) != IPY_GameWorld.fbtNull:
        # ¸±±¾¹¦Äܳ¡¾°µØͼ
        mapID = FBCommon.GetRecordMapID(mapID)
        fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, funcLineID)
        if fbLineIpyData:
            sceneMapID = fbLineIpyData.GetMapID()
            
    # µØͼ·ÖÁ÷, ¼õÉÙµ¥µØͼѹÁ¦
    FBMapShuntDict = ReadChConfig.GetEvalChConfig("FBMapShunt")
    if mapID in FBMapShuntDict:
        shuntList = FBMapShuntDict[mapID]
        if shuntList:
            sceneMapID = random.choice(shuntList)
            GameWorld.DebugLog("µ¥È˵Øͼ·ÖÁ÷ sceneMapID=%s" % sceneMapID)
            
    #´«ËÍʱ, Ëø¶¨Íæ¼Ò, ´«Ëͳɹ¦, ÔÚÄ¿±êµØͼ½âËø, ´«ËÍʧ°Ü, ÔÚ´«Ëͻص÷º¯ÊýPlayerChangeMapFailCallbackÖнâËø
    if canLock:
        curPlayer.BeginEvent()
    
    if not takeTruck:
        #È¡Ïû×Ô¶¯ÔËïÚ
        PlayerTruck.SetAutoTruckState(curPlayer, ShareDefine.Def_Out_Truck)
    #GameWorld.Log(1, "SetXP=%s"%(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RecordXPValue)))
    #curPlayer.SetXP(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RecordXPValue))
    #»ñÈ¡¸±±¾´«È븱±¾ÐèҪЯ´øµÄÐÅÏ¢
    msg = FBLogic.GetPlayerResetWorldPosFBMsg(curPlayer, mapID, funcLineID)
    
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ReqFBFuncLine, funcLineID)
    GameWorld.Log("Íæ¼ÒÇëÇó¿ªÊ¼ÇÐͼ: sceneMapID=%s,posX=%s,posY=%s,takeTruck=%s,fbID=%s,msg=%s,funcLineID=%s,tick=%s,lastTransTick=%s" 
                  % (sceneMapID, posX, posY, takeTruck, fbID, msg, funcLineID, tick, lastTransTick), curPlayer.GetPlayerID())
    if enterFBFree:
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_EnterFBFree, 1)
        GameWorld.DebugLog("    ±¾´ÎÃâ·Ñ½øÈ븱±¾!")
    curPlayer.ResetWorldPosReq(sceneMapID, posX, posY, takeTruck, fbID, msg)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeMapID, sceneMapID)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeLineID, max(0, fbID))
    
    #ÇеØͼ´¦ÀíÍæ¼ÒʱÖÓ¾ÀÕýÎÊÌ⣨ÐèҪһֱͨ¹ýÍæ¼ÒʱÖÓ¼ÆËãµÄ£©
    RefreshPlayerTick(curPlayer)
    NotifyPrepareChangeMap(curPlayer, sceneMapID, funcLineID)
    return

# ֪ͨ׼±¸Çл»µØͼ
def NotifyPrepareChangeMap(curPlayer, sceneMapID, funcLineID):
    curPlayer.SetVisible(False)
    sendPack = ChPyNetSendPack.tagMCPrepareChangeMap()
    sendPack.Clear()
    sendPack.MapID = GameWorld.GetMapDataMapID(sceneMapID)
    sendPack.FuncLineID = funcLineID
    
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    GameWorld.Log("×¼±¸Çл»µØͼ", curPlayer.GetID())
    return

# ֪ͨ¿ªÊ¼Çл»µØͼ
def NotifyStartChangeMap(curPlayer):
    sendPack = ChPyNetSendPack.tagMCStartChangeMap()
    sendPack.Clear()
    sendPack.MapID = GameWorld.GetMapDataMapID(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID))
    sendPack.FuncLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBFuncLine)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    
    GameWorld.Log("֪ͨ¿ªÊ¼Çл»µØͼ", curPlayer.GetID())
    return

#---------------------------------------------------------------------
##Íæ¼Ò»»Ïß
# @param curPlayer Íæ¼ÒʵÀý
# @param changLineID Ïß·ID
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò»»Ïß
def PlayerChangeLine(curPlayer, changLineID):
    #---µØͼ·ÖÏß¼ì²é---
    if GameWorld.GetGameWorld().GetLineID() == changLineID:
        GameWorld.ErrLog('changLineID SameLine = %s' % (changLineID))
        return
    
    #---µØͼÊôÐÔ¼ì²é---
    gameMap = GameWorld.GetMap()
    
    #1. Ö»ÓÐÆÕͨµØͼ²ÅÄÜ»»Ïß
    if gameMap.GetMapFBType() != IPY_GameWorld.fbtNull:
        #GeRen_liubo_180377    <n color="0,255,0">¶Ô²»Æð£¬Ä¿Ç°¸ÃµØͼûÓпª·Å·ÖÁ÷£¬ÎÞ·¨Çл»Ïß·!</n>  256 -
        NotifyCode(curPlayer, "GeRen_liubo_180377")
        return
    
    #2. »»ÏßµÄÄ¿µÄµØ±ØÐë´æÔÚ
    if changLineID >= gameMap.GetMaxFbCount():
        GameWorld.ErrLog("»»ÏßµÄÄ¿µÄµØ²»´æÔÚ = %s, %s" % (changLineID, gameMap.GetMaxFbCount()), curPlayer.GetID())
        return
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PlayChangeLineID, changLineID + 1)
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, 0)
    NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, 0)
    
    #---¿ªÊ¼Çл»Ïß·---
    PlayerResetWorldPosFB(curPlayer, curPlayer.GetMapID(), curPlayer.GetPosX(), curPlayer.GetPosY(), False, changLineID)
    
    GameWorld.Log('Íæ¼Ò = %s Çл»·ÖÏß = %s, Ëøס' % (curPlayer.GetName(), changLineID), curPlayer.GetID())
    return

#---------------------------------------------------------------------
##Íæ¼ÒÇл»µØͼ
# @param curPlayer Íæ¼ÒʵÀý
# @param mapID µØͼID
# @param posX ×ø±êX
# @param posY ×ø±êY
# @param takeTruck ÊÇ·ñЯ´øïÚ³µ
# @param lineID Ïß·ID -1´ú±íµ±Ç°Ïß
# @param msg Çл»µØͼЯ´øµÄÐÅÏ¢
# @param canLock ÊÇ·ñ¿ÉÒÔËø¶¨Íæ¼Ò(´«Ë͵㲻¿ÉËø¶¨, ÒòΪҪ¿çµØͼѰ·)
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼ÒÇл»µØͼ
def PlayerResetWorldPos(curPlayer, mapID, posX, posY, takeTruck, lineID=-1, msg='', canLock=True, exData1=0):
    #¸ü¸Ä: ËÀÍöÔÊÐíÇл»µØͼ, ÔÚ¸±±¾Öб»¹Ö´òËÀ, ¸±±¾Ê±¼äµ½, »ØÊÕ¸±±¾
#    if GameObj.GetHP(curPlayer) <= 0 :
#        GameWorld.Log("ËÀÍöÎÞ·¨Çл»µØͼ")
#        return
    
    gameWorld = GameWorld.GetGameWorld()
    shuntLineID = GetResetWorldPosShuntLineID(curPlayer, gameWorld.GetMapID(), gameWorld.GetLineID(), mapID, lineID, exData1) # ·ÖÁ÷Ïß·ID
    GameWorld.DebugLog("·ÖÁ÷ mapID=%s,lineID=%s,shuntLineID=%s" % (mapID, lineID, shuntLineID), curPlayer.GetPlayerID())
    
    #---ͬµØͼID, ͬ·ÖÏß, ½öÇл»×ø±ê---
    #lingID = -1, ´ú±íĬÈϵ±Ç°Ïß, ÈçÖ÷³Ç2´«Ëͽ£×Ú, µ½´ï½£×Ú2
    if gameWorld.GetMapID() == mapID and (shuntLineID == -1 or gameWorld.GetLineID() == shuntLineID):
        if exData1:
            #bossµÄÓÃmove£¬Í¨ÖªÇ°¶Ë£¬ÓÉÇ°¶Ë·¢Æðmove
            ChPlayer.NotifyPlayerMove(curPlayer, posX, posY, exData1)
        else:
            #ÖØÖÃ×ø±ê
            GameWorld.ResetPlayerPos(curPlayer, posX, posY)
        #@bug: ÔÚ°Ú̯Çø¿ìËÙ´«ËÍÖÁ·Ç°Ú̯Çø, ¿ÉÒÔ°Ú̯, ÕâÀïË¢ÐÂһϳ¡¾°Buff
        SkillShell.ProcessMapBuff(curPlayer, GameWorld.GetGameWorld().GetTick())
        return
    
    #---²»Í¬µØͼIDÇл»µØͼ---
    PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, takeTruck, shuntLineID, msg, canLock)
    
    #Èç¹ûÊÇ·þÎñÆ÷ÖÐ×îºóÒ»¸öÈËÀ뿪, Ôò¹Øµô¸±±¾
    GameWorldProcess.OnPlayerLeaveMapCloseFB()
    return

def GetResetWorldPosShuntLineID(curPlayer, curMapID, curLineID, tagMapID, tagLineID, bossID=0):
    '''»ñÈ¡ÇÐͼÏß·ID
    ÇÐÏßÓÐÈýÖÖÇé¿ö
    1. Íæ¼ÒÊÖ¶¯Çл»Ïß·£¬ÓÅÏȼ¶×î¸ß
            ¼Ç¼key  Def_Player_Dict_PlayChangeLineID£¬ ÀëÏß³¬¹ý±£»¤Ê±¼äºóÖØÖã¬È·±£¶ÏÏßÖØÁ¬Õý³£¼´¿É
            
    2. ¹¦ÄÜÇл»µ½Ö¸¶¨Ïß·£¬Èç´òboss¡¢´«Ë͵½Ä¿±êÍæ¼ÒÏß·£¨±»»÷ɱÇйýÈ¥°ï棩
            ¼Ç¼key  Def_Player_Dict_FuncChangeLineID£¬ ÀëÏß³¬¹ý±£»¤Ê±¼äºóÖØÖã¬È·±£¶ÏÏßÖØÁ¬Õý³£¼´¿É
            
    3. ³£¹æÇÐͼ
            Ïß·ѡÔñÓÅÏȼ¶: ÊÖ¶¯ÇÐÏ߼Ǽ > ¹¦ÄÜÇÐÏ߼Ǽ > ¸ßµÍÇÐÏ߼Ǽ > ϵͳ·ÖÁ÷ÇÐÏß¹æÔò
            
            ϵͳ·ÖÁ÷ÇÐÏß¹æÔò: µ±Ç°µØͼÏß· ¶ÔÓ¦ Ä¿±êµØͼÏß·ÈËÊý Èç¹ûµ½´ï¶î¶¨Öµ²Å½øÐзÖÁ÷£¬·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·
            
        ÌØÊâboss·ÖÁ÷: 
        @param bossID: ·ÖÁ÷bossID
    '''
    if PlayerTJG.GetIsTJG(curPlayer):
        GameWorld.DebugLog("ÍÑ»úµÄÍæ¼Ò²»´¦Àí·ÖÁ÷£¡", curPlayer.GetPlayerID())
        return tagLineID
    if GameWorld.IsCrossServer():
        return tagLineID
    # ·Ç³£¹æµØͼ֮¼äµÄÇл»²»´¦Àí
    if curMapID not in PyGameData.g_commMapLinePlayerCountDict or tagMapID not in PyGameData.g_commMapLinePlayerCountDict:
        return tagLineID
    tagLinePlayerCountDict = PyGameData.g_commMapLinePlayerCountDict[tagMapID] # ´Ë·ÖÏß°üº¬ËùÓзÖÏߣ¬º¬Î´¿ª·ÅµÄ¼°»î¶¯·ÖÏß
    
    if bossID and tagMapID != ChConfig.Def_FBMapID_BossHome:
        tagLineID = 0 # BossµÄ»°Î´·ÖÁ÷Ç°ÏÈÇ¿ÖÆ1Ïߣ¬¼´Îª0
    playerID = curPlayer.GetPlayerID()
    playChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PlayChangeLineID)
    funcChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FuncChangeLineID)
    highChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_HighChangeLineID)
    
    GameWorld.DebugLog("´¦Àí·ÖÁ÷,curMapID=%s,curLineID=%s,tagMapID=%s,tagLineID=%s,bossID=%s" 
                       % (curMapID, curLineID, tagMapID, tagLineID, bossID), playerID)
    # ÓÐÖ¸¶¨Ïß·£¬Ö±½Ó·µ»Ø£¬²»·ÖÁ÷
    if tagLineID != -1:
        # »¹Ã»Ö¸¶¨·ÖÏ߼ǼµÄÔòÒª¼Ç¼£¬ÒѾ­¼Ç¼¹ýµÄ²»Öظ´¼Ç¼£¬Ö±µ½Ï´λص½Ô­Ïß·ºó²ÅÖØÖÃ0
        if not playChangeLineID and not funcChangeLineID and not highChangeLineID:
            NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, curLineID + 1)
            GameWorld.DebugLog("¹¦ÄÜÖ¸¶¨Çл»Ä¿±êÏß·£¬¼Ç¼µ±Ç°Ïß·ºóÐøÇÐÏß±¸ÓÃ! curLineID=%s,tagLineID=%s" % (curLineID, tagLineID), playerID)
            
        if bossID and NPCCommon.IsMapNeedBossShunt(tagMapID):
            bossShuntLineID = __GetBossShuntLineID(curPlayer, curMapID, curLineID, tagMapID, bossID, tagLinePlayerCountDict.keys())
            if bossShuntLineID != -1:
                tick = GameWorld.GetGameWorld().GetTick()
                GameWorld.DebugLog("·ÖÁ÷boss, bossID=%s,bossShuntLineID=%s" % (bossID, bossShuntLineID), playerID)
                NPCCommon.AddBossShuntRelatedPlayer(curPlayer, tagMapID, bossShuntLineID, bossID, tick)
                return bossShuntLineID
        return tagLineID
    
    if curMapID == tagMapID:
        GameWorld.DebugLog("ͬµØͼÇл»×ø±ê²»´¦Àí·ÖÁ÷£¡", playerID)
        return tagLineID
    
    # ¿ÉÒÔÓÃÀ´³£¹æ·ÖÁ÷µÄÏß·ÈËÊý×ÖµäÐÅÏ¢, ²¢²»ÊÇËùÓÐÏß·¶¼¿ÉÒÔÓÃÀ´×öÈËÊý·ÖÁ÷µÄ£¬±ÈÈçÖÐÁ¢µØͼÓжàÌõÏßÓÃÀ´·ÖÁ÷boss£¬µ«ÊÇÖ»ÓÐ1ÌõÏß¿ÉÓÃÀ´×ö³£¹æµÄÈËÊý·ÖÁ÷
    mapLineDict = IpyGameDataPY.GetFuncCfg("MapLine", 1)
    if tagMapID in mapLineDict:
        tagMapMaxLine = mapLineDict[tagMapID]
        tagLinePlayerCountShuntDict = {}
        for k, v in tagLinePlayerCountDict.items():
            if k >= tagMapMaxLine:
                continue
            tagLinePlayerCountShuntDict[k] = v
    else:
        tagLinePlayerCountShuntDict = tagLinePlayerCountDict
        tagMapMaxLine = len(tagLinePlayerCountShuntDict)
    GameWorld.DebugLog("Ä¿±êµØͼ¿ÉÓ÷ÖÁ÷Ïß·ÈËÊýÐÅÏ¢: tagMapID=%s,%s" % (tagMapID, tagLinePlayerCountShuntDict))
    
    # ÓÐÖ÷¶¯Çл»¹ý
    if playChangeLineID and playChangeLineID <= len(tagLinePlayerCountShuntDict):
        GameWorld.DebugLog("ÓÐÖ÷¶¯Çл»¹ýÏß·!playChangeLineID=%s" % playChangeLineID, playerID)
        return playChangeLineID - 1
    
    # ¹¦ÄÜÓÐÖ¸¶¨Ïß·¹ý
    if funcChangeLineID and funcChangeLineID <= len(tagLinePlayerCountShuntDict):
        GameWorld.DebugLog("¹¦ÄÜÓÐÖ¸¶¨¹ýÏß·ÀúÊ·Ïß·,funcChangeLineID=%s" % funcChangeLineID, playerID)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, 0) # ´¥·¢»ØÔ­Ïß·ºóÖØÖÃ
        return funcChangeLineID - 1
    
    # ÓиßÏßÇеÍÏ߼Ǽ
    if highChangeLineID and highChangeLineID <= len(tagLinePlayerCountShuntDict):
        GameWorld.DebugLog("ÓиßÏßÇеÍÏßÀúÊ·Ïß·,highChangeLineID=%s" % highChangeLineID, playerID)
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, 0) # ´¥·¢»ØÔ­Ïß·ºóÖØÖÃ
        return highChangeLineID - 1
    
    if curLineID not in tagLinePlayerCountShuntDict:
        GameWorld.DebugLog("Ä¿±êµØͼ²»´æÔÚ¸ÃÏß·,curLineID=%s" % curLineID, playerID)
        shuntLineID = __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict)
        
        # Èç¹ûûÓд¥·¢·ÖÁ÷£¬ÔòÐè¼Ç¼Íæ¼Ò´Ó¸ßÏß·µØͼÇл»µ½µÍÏß·µØͼʱµÄ¸ßÏß·ID
        if shuntLineID == -1 and not playChangeLineID and not funcChangeLineID and not highChangeLineID:
            NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, curLineID + 1)
            GameWorld.DebugLog("¸ßÏßÇеÍÏߣ¬¼Ç¼µ±Ç°Ïß·ºóÐøÇÐÏß±¸ÓÃ! curLineID=%s,tagLineID=%s" % (curLineID, tagLineID), playerID)
            
    else:
        shuntLineID = __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict, curLineID)
        
    if shuntLineID == -1 and (curLineID + 1) > tagMapMaxLine:
        shuntLineID = tagMapMaxLine - 1
        GameWorld.DebugLog("³£¹æ·ÖÁ÷ºóµÄlineIDΪ-1£¬µ«ÊÇÄ¿±êµØͼµ±Ç°Ïß·²»¿ÉÓ㡲»¿É´«Ë͵½¸ÃÏß·£¡curLineID=%s + 1 > tagMapMaxLine(%s), Ç¿ÖÆ·ÖÁ÷µ½Ïß·(shuntLineID=%s)" 
                           % (curLineID, tagMapMaxLine, shuntLineID))
        
    return shuntLineID

def __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict, curLineID=None):
    # ÒÔÏÂ×ßϵͳ×Ô¶¯·ÖÁ÷Âß¼­
    playerID = curPlayer.GetPlayerID()
    if curPlayer.GetLV() > IpyGameDataPY.GetFuncCfg("SetWorldPosShunt", 2):
        GameWorld.DebugLog("³¬¹ýÖ¸¶¨µÈ¼¶²»·ÖÁ÷", playerID)
        return -1
    
    mapShuntDict = IpyGameDataPY.GetFuncEvalCfg("SetWorldPosShunt", 1) # {mapID:ÈËÊý, ...}
    if tagMapID not in mapShuntDict:
        GameWorld.DebugLog("Ä¿±êµØͼ²»ÐèÒª·ÖÁ÷", playerID)
        return -1
    lineMaxPlayerCount = mapShuntDict[tagMapID]
    
    if curLineID != None:
        tagLinePlayerCount = tagLinePlayerCountShuntDict[curLineID]
        if tagLinePlayerCount < lineMaxPlayerCount:
            GameWorld.DebugLog("δ´ïµ½¶î¶¨ÈËÊýÖµ,²»Ó÷ÖÁ÷,curLineID=%s,Ä¿±êµØͼµ±Ç°Ïß·ÈËÊý: %s/%s" 
                               % (curLineID, tagLinePlayerCount, lineMaxPlayerCount), playerID)
            return -1
        
    # ·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·
    linePlayerList = [[playerCount, lineID] for lineID, playerCount in tagLinePlayerCountShuntDict.items()]
    linePlayerList.sort() # ÉýÐòÅÅ, ÔòË÷Òý0µÄÏß·Ϊ×î¼ÑÑ¡Ôñ
    shuntLineID = linePlayerList[0][1]
    GameWorld.DebugLog("·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·,tagMapID=%s,linePlayerList[count,lineID]=%s" % (tagMapID, linePlayerList), playerID)
    return shuntLineID

def __GetBossShuntLineID(curPlayer, curMapID, curLineID, tagMapID, npcID, lineIDList):
    '''»ñÈ¡Ä¿±êµØͼboss·ÖÁ÷Ïß·
                ¸ù¾ÝÈËÊý·ÖÁ÷Íæ¼Ò£¬ÓÅÏÈ·ÖÅäµ½»î×ŵÄÏß·
                ¶ÓÎéĬÈÏ·ÖÅäµ½¶ÓÎé¶ÓÔ±¶àµÄÄÇÌõÏß
                ЭÖúĬÈÏ·ÖÅ䵽Ŀ±êÍæ¼ÒÏß·£¬ÓÅÏȼ¶×î¸ß
                      
                Ç°¶Ë£º
        1.ÔÚÖÐÁ¢µØͼµÄʱºò£¬ÏÔʾµ±Ç°Ïß·BOSSµÄ״̬
        2.ÔÚ³£¹æµØͼµÄʱºò£¬ÏÔʾÍæ¼Ò»÷ɱBOSSµÄCDʱ¼ä
        3.±¾µØͼ²»»»Ïߣ¬60Ãë¹æÔò±£³Ö²»±ä
        4.½øÈëBOSSÇøÓòÀˢÐÂBOSS״̬
        
                Íæ¼ÒÔÚ·ÇÖÐÁ¢µØͼ£º
                ±¾µØͼ²»»»Ïߣ¬60Ãë¹æÔò±£³Ö²»±ä£¨£©
                
                Íæ¼ÒÔÚÖÐÁ¢µØͼ
                ûÓÐ60Ãë¹æÔò
                Ö±½Ó·¢´«ËÍ°ü£¬Óɺó¶Ë¾ö¶¨£¨ÓжÓÔ±ÔÚ²»Í¬Ïß·´òͬһֻboss£¬Ôò´«ËÍ£¬·ñÔòmove£©
    '''
    playerID = curPlayer.GetPlayerID()
    playerTeamID = curPlayer.GetTeamID()
    
    hurtTeamLineID = -1
    hurtTeamMemCount = -1
    
    bossLinePlayerDict = {1:[-1, []], 0:[-1, []]} # {ÊÇ·ñ±»»÷ɱ:[¸Ã״̬ÈËÊý¿ÕµÄÏß·, [[Íæ¼ÒÊý, Ïß·], ...]], ...}
    
    bossLineStateDict = PyGameData.g_bossShuntLineState.get(npcID, {})
    
    haveAliveLine = False # ÊÇ·ñÓлî×ŵÄÏß·
    activityMapLineDict = IpyGameDataPY.GetFuncEvalCfg("MapLine", 2, {})
    
    GameWorld.DebugLog("Íæ¼Òboss·ÖÁ÷: playerTeamID=%s,tagMapID=%s,npcID=%s,lineIDList=%s,bossLineStateDict=%s,g_bossShuntPlayerInfo=%s" 
                       % (playerTeamID, tagMapID, npcID, lineIDList, bossLineStateDict, PyGameData.g_bossShuntPlayerInfo), playerID)
    if tagMapID in activityMapLineDict:
        activityLineID = max(0, activityMapLineDict[tagMapID] - 1)
        # ·Ç1ÏߵĻÏß·²»²ÎÓë·ÖÁ÷
        if activityLineID != 0 and activityLineID in lineIDList:
            lineIDList.remove(activityLineID)
            GameWorld.DebugLog("    ·Ç1ÏߵĻÏß·²»²ÎÓë·ÖÁ÷: activityLineID=%s,lineIDList=%s" % (activityLineID, lineIDList), playerID)
            
    assistTagPlayerID = GetAssistTagPlayerID(curPlayer)
    for lineID in lineIDList:
        key = (tagMapID, lineID)
        # boss·ÖÁ÷Íæ¼ÒÐÅÏ¢{(mapID, lineID):{playerID:[bossID, teamID, relatedTick], ...}, ...}
        shuntPlayerDict = PyGameData.g_bossShuntPlayerInfo.get(key, {})
        if assistTagPlayerID and assistTagPlayerID in shuntPlayerDict:
            GameWorld.DebugLog("    ·ÖÁ÷µ½Ð­ÖúÄ¿±êÍæ¼ÒÏß· assistTagPlayerID=%s,lineID=%s" % (assistTagPlayerID, lineID), playerID)
            return lineID
        playerCount = 0
        teamPlayerCount = 0
        for shuntPlayerID, shuntInfo in shuntPlayerDict.items():
            bossID = shuntInfo[0]
            if npcID != bossID:
                continue
            playerCount += 1
            shuntTeamID = shuntInfo[1]
            if playerTeamID and playerTeamID == shuntTeamID and shuntPlayerID != playerID:
                teamPlayerCount += 1
        
        if teamPlayerCount and teamPlayerCount > hurtTeamMemCount:
            hurtTeamMemCount = teamPlayerCount
            hurtTeamLineID = lineID
            
        lineIsAlive = bossLineStateDict.get(lineID, 0)
        lineBossIsDead = 1 if not lineIsAlive else 0 # µ±Ç°Ïß·bossÊÇ·ñËÀÍö
        emptyLineID, linePlayerCountList = bossLinePlayerDict[lineBossIsDead]
        if not playerCount and emptyLineID == -1:
            emptyLineID = lineID
        linePlayerCountList.append([playerCount, lineID])
        bossLinePlayerDict[lineBossIsDead] = [emptyLineID, linePlayerCountList]
        
        if not lineBossIsDead:
            haveAliveLine = True
            
        GameWorld.DebugLog("    lineID=%s,lineBossIsDead=%s,playerCount=%s,teamPlayerCount=%s,hurtTeamMemCount=%s,hurtTeamLineID=%s" 
                           % (lineID, lineBossIsDead, playerCount, teamPlayerCount, hurtTeamMemCount, hurtTeamLineID), playerID)
        
    if hurtTeamLineID >= 0:
        GameWorld.DebugLog("    ·ÖÁ÷µ½¶ÓÓÑÈËÊý¶àµÄÏß· hurtTeamLineID=%s" % hurtTeamLineID, playerID)
        return hurtTeamLineID
    
    if curMapID == tagMapID and curMapID in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4):
        GameWorld.DebugLog("    ÖÐÁ¢µØͼÔÚ±¾µØͼÖÐĬÈϵ±Ç°Ïß· curLineID=%s" % curLineID, playerID)
        return curLineID
    
    shuntBossIsDead = 0 if haveAliveLine else 1 # ÓÅÏÈ·ÖÁ÷µ½»î×ŵÄÏß·
    GameWorld.DebugLog("    boss״̬¶ÔÓ¦Ïß·ÈËÊý: haveAliveLine=%s, ״̬key0Ϊ»î×Å: %s" % (haveAliveLine, bossLinePlayerDict))
    emptyLineID, linePlayerCountList = bossLinePlayerDict[shuntBossIsDead]
    linePlayerCountList.sort() # ÉýÐò
    playerCount, minPlayerCntLineID = linePlayerCountList[0]
    bossShuntPlayerCountMax = IpyGameDataPY.GetFuncCfg("BossShunt", 2)
    if playerCount >= bossShuntPlayerCountMax and emptyLineID >= 0:
        GameWorld.DebugLog("    ·ÖÁ÷µ½¿ÕÐÂÏß· shuntBossIsDead=%s,emptyLineID=%s" % (shuntBossIsDead, emptyLineID), playerID)
        return emptyLineID
    
    GameWorld.DebugLog("    ·ÖÁ÷µ½ÈËÊý×îÉÙµÄÏß· shuntBossIsDead=%s,minPlayerCntLineID=%s,linePlayerCountList=%s" 
                       % (shuntBossIsDead, minPlayerCntLineID, linePlayerCountList), playerID)
    return minPlayerCntLineID

#---------------------------------------------------------------------
##È¡ºÏ·¨ÖØÉúµã
# @param curPlayer Íæ¼ÒʵÀý
# @param posX ÖØÉúµãx×ø±ê
# @param posy ÖØÉúµãy×ø±ê
# @param round ÖØÉúµã·¶Î§
# @return ÖØÉúµã(×ø±êx£¬ ×ø±êy)
# @remarks 
def __GetLegitRebornPoint(curPlayer, posX, posY, round):
    rebornPosX = 0
    rebornPosY = 0
    
    curMapID = curPlayer.GetMapID()
    
    gameMap = GameWorld.GetMap()
    
    #Ìí¼Ó×ø±êµãÒì³£¼ì²é(ÖØÉúµã×ø±ê³¬¹ýµØͼ±ß½ç)
    if not gameMap.IsValidPos(posX, posY):
        GameWorld.ErrLog('ÖØÉúµãÒì³££¬³¬¹ýµØͼ(%s)±ß½ç posX = %s, posY = %s, round = %s' \
                         % (curMapID, posX, posY, round))
    
    else:
        # Ëæ»úÈ¡µ½·ÇÕÏ°­µã
        rebornPosX, rebornPosY = GameMap.GetNearbyPosByDis(posX, posY, round)
            
        #²¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½·ÇÕÏ°­µã
        if rebornPosX <= 0 or rebornPosY <= 0:
            GameWorld.Log("ÖØÉúµã·¶Î§ÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄ·ÇÕÏ°­ÖØÉúµã posX = %s, posY = %s, round = %s" % \
                          (curMapID, posX, posY, round), curPlayer.GetPlayerID())
    
    return (rebornPosX, rebornPosY)

                    
#---------------------------------------------------------------------
##Ë¢ÐÂÍæ¼ÒµÄÖØÉúµãÐÅÏ¢
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Ë¢ÐÂÍæ¼ÒµÄÖØÉúµãÐÅÏ¢
def RefreshRebornPoint(curPlayer, tick):
    #---¸´»îµãË¢ÐÂÅжÏ˳Ðò1.µØͼ²¼¸´»îµã 2.tagChinMap.txtÄÚ¸´»îµã 3.´´½¨½ÇÉ«³õʼ³öÉúµã---
    
    gameMap = GameWorld.GetMap()
    
    # ³õʼ»¯ÖØÉúµØͼΪµ±Ç°Íæ¼ÒËùÔÚµØͼ
    rebornMapID = curPlayer.GetMapID()
    rebornPosX = curPlayer.GetRebornPosX()
    rebornPosY = curPlayer.GetRebornPosY()
    
    #---µØͼÉϲ¼µÄÖØÉúµãÅжÏ---
    
    # µØͼÉÏÊÇ·ñÓв¼¸´»îˢеã
    hasBornRefreshPoint = True
    
    gameData = GameWorld.GetGameData()
    bornRefreshCount = gameData.GetBornRefreshCount()

    #Ò»°ãµØͼ²¼µÄÖØÉúµãÁбí,¸ù¾Ý¹ú¼®É¸Ñ¡
    bornList = []
    #¸±±¾µØͼ²¼µÄÖØÉúµãÁбí,²»É¸Ñ¡
    fbBornList = []
    
    # ûÓв¼ÖØÉúµã
    if not bornRefreshCount:
        GameWorld.Log("´ËµØͼûÓÐÖØÉúµã", curPlayer.GetPlayerID())
        hasBornRefreshPoint = False
    else:
        #´´½¨ÖØÉúµãÁбí
        for i in range(0, bornRefreshCount):
            bornRefreshPoint = gameData.GetBornRefreshByIndex(i)
            fbBornList.append(i)
            
            if GameWorld.IsSameCountry(curPlayer, bornRefreshPoint):
                bornList.append(i)
    
        if not bornList:
            GameWorld.Log("´ËµØͼûÓкÏÊÊÍæ¼ÒµÄÖØÉúµã", curPlayer.GetPlayerID())
            hasBornRefreshPoint = False

    #---¸ÃµØͼÓв¼ÖØÉúˢеã---
    if hasBornRefreshPoint:
        # Ëæ»ú»ñÈ¡ÖØÉúˢеã
        bornIndex = random.choice(bornList)
        bornRefreshPoint = gameData.GetBornRefreshByIndex(bornIndex)
        
        bRP_PosX = bornRefreshPoint.GetPosX()
        bRP_PosY = bornRefreshPoint.GetPosY()
        bRP_RoundPos = bornRefreshPoint.GetRound()
        
        rebornPosX, rebornPosY = __GetLegitRebornPoint(curPlayer, bRP_PosX, bRP_PosY, bRP_RoundPos)
        
        #²¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½ºÏ·¨ÖØÉúµã
        if rebornPosX <= 0 or rebornPosY <= 0 or rebornMapID <= 0:
            GameWorld.Log("µØͼÉϲ¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄºÏ·¨ÖØÉúµã" \
                          % curPlayer.GetMapID(), curPlayer.GetPlayerID())
            # Òì³££¬Éè±ê־ΪFalse,´ÓtagChinMap.txt±íÄÚÕÒ¸´»îµã
            hasBornRefreshPoint = False
    
    # ÔÚtagChinMap.txt±íÄÚÊÇ·ñÄÜÕÒµ½¸´»îµã
    hasBornPointInTxt = True  
    
    #---¸ÃµØͼûÓÐÖØÉúˢе㣬´ÓtagChinMap.txt±íÄÚÕÒ¸´»îµã---    
    if not hasBornRefreshPoint:
        rebornMapID = gameMap.GetRebornMapID()
        rebornPosX = gameMap.GetRebornMapX()
        rebornPosY = gameMap.GetRebornMapY()
        
        #ÑéÖ¤ÊÇ·ñ±¾µØͼ¸´»îµã ½øÐÐÂß¼­´¦Àí, ·Ç±¾µØͼ¸´»îµãÎÞ·¨Åжϣ¬ ÒªÇó²ß»®Ò»¶¨ÅäÖÃÕýÈ·
        if gameMap.GetMapID() == rebornMapID:
            # Ëæ»úÈ¡µ½·ÇÕÏ°­µã
            rebornPosX, rebornPosY = __GetLegitRebornPoint(curPlayer, \
                                                           rebornPosX, rebornPosY, ChConfig.Def_RebornPos_Area_Range)

        #tagChinMap.txt±íÉÏÕÒ²»µ½ºÏ·¨ÖØÉúµã
        if rebornPosX <= 0 or rebornPosY <= 0 or rebornMapID <= 0:
            GameWorld.Log("tagChinMap.txtÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄºÏ·¨ÖØÉúµã" \
                          % curPlayer.GetMapID(), curPlayer.GetPlayerID())
            hasBornPointInTxt = False
            
    #---ÔÚtagChinMap.txt±íÄÚÒ²ÕÒ²»µ½¸´»îµã,Ö±½ÓÖØÖõ½´´½¨½ÇɫʱµÄ³õʼµã---
    if not hasBornPointInTxt:
        curPlayerJob = curPlayer.GetJob()
        
        #´´½¨Íæ¼ÒλÖöÁ±í{ Ö°Òµ:[(map,x,y),(map1,x1,y1)..] }
        posList = ReadChConfig.GetEvalChConfig('Player_Reborn_Place')
        
        pos = random.choice(posList[curPlayerJob])
        rebornMapID = pos[0]
        bornRange = 1
        rebornPosX = pos[2] + random.randint(-bornRange, bornRange)
        rebornPosY = pos[3] + random.randint(-bornRange, bornRange)
        GameWorld.Log("""tagBornRefresh.txtºÍtagChinMap.txtÄÚ¶¼ÕÒ²»µ½¸ÃµØͼ(%s)
µÄºÏ·¨ÖØÉúµã£¬ÉèÖÃÍæ¼ÒÖØÉúµãΪ´´½¨½ÇɫʱµÄ³õʼµã%s-(%s,%s)""" % \
                      (curPlayer.GetMapID(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())        
                                
    #Íæ¼Ò²»ÔÚ¸±±¾ÖÐ
    if gameMap.GetMapFBType() == IPY_GameWorld.fbtNull:
        # ÉèÖÃÒ»°ãµØͼÖØÉúµã
        curPlayer.SetRebornMapID(rebornMapID)
        curPlayer.SetRebornPosX(rebornPosX)
        curPlayer.SetRebornPosY(rebornPosY)
        GameWorld.Log("Íæ¼Ò%s,ÉèÖÃĬÈÏÖØÉúµãÍê±Ï mapID = %s-(%s,%s)" % (curPlayer.GetPlayerName(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())
        return

#===============================================================================
#        #´å³¤¼ÒµÄµØͼID
#        cunZhangJiaMapID = 21
#    
#        #ÓÐÖØÉúµã
#        #ÐÂÊÖ³¡ÅÂÍæ¼Ò¿¨ËÀÕÏ°­µã£¬ÉèÖÃΪµ±Ç°×ø±ê
#        if curPlayerMapID == cunZhangJiaMapID:
#            curPlayer.SetRebornMapID( curPlayerMapID )
#            curPlayer.SetRebornPosX( curPlayer.GetPosX() )
#            curPlayer.SetRebornPosY( curPlayer.GetPosY() )
#            return
#        
#        #À뿪ÐÂÊÖ³¡¾°ºó£¬ÖØÖÃÒ»´ÎÖØÉúµã£¬·ÀÖ¹Íæ¼ÒÔٻص½ÐÂÊÖ³¡¾°
#        if curPlayerRebornMapID == cunZhangJiaMapID:
#            curPlayer.SetRebornMapID( curPlayerMapID )
#            curPlayer.SetRebornPosX( bornX )
#            curPlayer.SetRebornPosY( bornY )
#            return
#===============================================================================
    
    #ÏÈÉèÖÃĬÈϵĸ±±¾ÖØÉúµã
    curPlayer.SetFBRebornMapID(rebornMapID)
    curPlayer.SetFBRebornPosX(rebornPosX)
    curPlayer.SetFBRebornPosY(rebornPosY)
    GameWorld.Log("Íæ¼Ò%s,ÉèÖø±±¾Ä¬ÈÏÖØÉúµãÍê±Ï mapID = %s-(%s,%s)" % (curPlayer.GetPlayerName(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())
    
    # ÌØÊ⸱±¾¸´»îµãÂß¼­
    FBLogic.OnRebornPlace(curPlayer, fbBornList)
    return

#---------------------------------------------------------------------
##»ñÈ¡¾ôλ
# @param curLV µÈ¼¶
# @return ·µ»ØÖµ, ¾ôλµÈ¼¶
# @remarks »ñÈ¡¾ôλ
def GetRank(curLV):
    if curLV > 0 and curLV < 21:
        return 1
    else:
        return (curLV - 1) / 10

#---------------------------------------------------------------------
##»ñµÃÖ¸¶¨·½Î»ÄÚ¶ÓÎé³ÉÔ±Áбí
# @param curTeam ¶ÓÎéʵÀý
# @param centerX ÆðµãX
# @param centerY ÆðµãY
# @param area ·¶
# @return ·µ»ØÖµ, ³ÉÔ±Áбí
# @remarks »ñµÃÖ¸¶¨·½Î»ÄÚ¶ÓÎé³ÉÔ±Áбí
def GetAreaTeamMember(curTeam, centerX, centerY, area=ChConfig.Def_Team_GetExpScreenDist, isLog=False):   
    playerlist = list()

    if curTeam == None:
        GameWorld.ErrLog("»ñÈ¡¶ÓÎéÇøÓò³ÉÔ±£¬¶ÓÎé²»´æÔÚ£¡")
        return playerlist
    
    playerIDList = []
    #if isLog:
    #    GameWorld.Log("GetAreaTeamMember,teamID=%s,centerX=%s,centerY=%s,area=%s" % (curTeam.GetTeamID(), centerX, centerY, area))
        
    #±éÀú¶ÓÎé,°ë¾¶ÎªÒ»ÆÁ°ëµÄ¾àÀëÄÚµÄËùÓжÓÎé/ÍŶӳÉÔ±£¬¿ÉÒÔ»ñµÃ¾­Ñé
    for i in range(0, curTeam.GetMemberCount()):
        curTeamPlayer = curTeam.GetMember(i)
        if curTeamPlayer == None or curTeamPlayer.GetPlayerID() == 0:
            #if isLog:
            #    GameWorld.Log("    i=%s,³ÉÔ±²»´æÔÚ!" % (i))
            continue
        
        if GameObj.GetHP(curTeamPlayer) <= 0:
            #if isLog:
            #    GameWorld.Log("    i=%s,³ÉԱѪÁ¿Îª0!playerID=%s" % (i, curTeamPlayer.GetPlayerID()))
            continue
        
        #===========================================================================================
        # # ¶ÓÎéÒÑÓÉÿÌõÐéÄâÏß·¶À×Ô¹ÜÀí£¬´Ë´¦¿É²»ÔÙÅжÏ
        # if curTeamPlayer.GetCopyMapID() != GameWorld.GetGameWorld().GetCopyMapID():
        #    if isLog:
        #        GameWorld.Log("    i=%s,³ÉÔ±ÐéÄâÏß·²»Í¬!playerID=%s,copyMapID=%s,mapCopyMapID=%s" 
        #                      % (i, curTeamPlayer.GetPlayerID(), curTeamPlayer.GetCopyMapID(), GameWorld.GetGameWorld().GetCopyMapID()))
        #    #¸±±¾ID²»Í¬
        #    continue
        #===========================================================================================
        
        if GameWorld.GetDist(centerX, centerY, curTeamPlayer.GetPosX(),
                             curTeamPlayer.GetPosY()) > area:
            #if isLog:
            #    GameWorld.Log("    i=%s,³ÉÔ±²»ÔÚ·¶Î§ÄÚ!playerID=%s,centerPos(%s,%s),playerPos=(%s,%s),area=%s" 
            #                  % (i, curTeamPlayer.GetPlayerID(), centerX, centerY, curTeamPlayer.GetPosX(), curTeamPlayer.GetPosY(), area))
            continue
        
        playerlist.append(curTeamPlayer)
        playerIDList.append(curTeamPlayer.GetPlayerID())
        
    #if isLog:
    #    GameWorld.Log("    teamAreaPlayerIDList=%s" % (playerIDList))
    return playerlist

def GetMapTeamMember(curTeam):
    ''' »ñȡͬµØͼÖеĶÓÔ± '''
    
    playerlist = list()
    if curTeam == None:
        return playerlist
    
    for i in xrange(curTeam.GetMemberCount()):
        curTeamPlayer = curTeam.GetMember(i)
        if curTeamPlayer == None or curTeamPlayer.GetPlayerID() == 0:
            continue
        playerlist.append(curTeamPlayer)
        
    return playerlist

#---------------------------------------------------------------------
##»ñÈ¡Íæ¼Ò»õ±ÒÊý
# @param curPlayer Íæ¼ÒʵÀý
# @param TYPE_Price ,»õ±ÒÀàÐÍ
# @return
def GetMoney(curPlayer, TYPE_Price):
    
    #½ð×Ó
    if TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
        return curPlayer.GetGold()
        
    #½ðƱ
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
        return curPlayer.GetGoldPaper()
       
    #Òø×Ó
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
        return GetSilver(curPlayer)
        
    #񿮱
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
        return curPlayer.GetSilverPaper()
    
    #´ú±Ò
    elif TYPE_Price == ShareDefine.TYPE_Price_PayCoin:
        return GetPayCoin(curPlayer)
    
    #×Ô¶¨Òå»õ±Ò
    elif TYPE_Price in ShareDefine.TYPE_Price_CurrencyDict:
        return GetPlayerCurrency(curPlayer, TYPE_Price)
    
    return 0

def GetMoneyReal(curPlayer, moneyType):
    ## »ñÈ¡»õ±Òʵ¼ÊÖµ£¬Ö§³Ö¸ºÖµ
    moneyMinus = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
    if moneyMinus != 0:
        return -moneyMinus
    return GetMoney(curPlayer, moneyType)

def SetMoney(curPlayer, moneyType, value):
    ## ÉèÖûõ±ÒÖµ£¬Ö§³Ö¸ºÖµ
    if moneyType in ShareDefine.MoneyMinusRefreshDict:
        moneyMinus = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
        if value < 0:
            if moneyMinus != value:
                SetMoneyMinus(curPlayer, moneyType, value)
            value = 0
        else:
            if moneyMinus != 0:
                SetMoneyMinus(curPlayer, moneyType, 0)
                
    #½ð×Ó
    if moneyType == IPY_GameWorld.TYPE_Price_Gold_Money:
        curPlayer.SetGold(value)
        
    #½ðƱ
    elif moneyType == IPY_GameWorld.TYPE_Price_Gold_Paper:
        curPlayer.SetGoldPaper(value)
        
    #Òø×Ó
    elif moneyType == IPY_GameWorld.TYPE_Price_Silver_Money:
        SetSilver(curPlayer, value)
        
    #񿮱
    elif moneyType == IPY_GameWorld.TYPE_Price_Silver_Paper:
        curPlayer.SetSilverPaper(value)
        
    #´ú±Ò
    elif moneyType == ShareDefine.TYPE_Price_PayCoin:
        SetPayCoin(curPlayer, value)
        
    #×Ô¶¨Òå»õ±Ò
    elif moneyType in ShareDefine.TYPE_Price_CurrencyDict:
        SetPlayerCurrency(curPlayer, moneyType, value)
        
    return

def SetMoneyMinus(curPlayer, moneyType, value):
    value = abs(value) # ´æÖµ¼°Í¨ÖªÊ¹ÓÃÕýÊý
    NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_MoneyMinus % moneyType, value)
    #֪ͨ¿Í»§¶Ë
    if moneyType not in ShareDefine.MoneyMinusRefreshDict:
        return
    refreshType = ShareDefine.MoneyMinusRefreshDict[moneyType]
    if refreshType != None:
        SendPropertyRefresh(curPlayer, refreshType, value)
    return

## »ñÈ¡Íæ¼Ò²Ö¿â½ðÇ®Êý
#  @param curPlayer: Íæ¼ÒʵÀý
#  @param moneyType: ½ðÇ®ÀàÐÍ
#  @return: Íæ¼ÒÉíÉϽðÇ®Êý
def GetWarehouseMoney(curPlayer, moneyType):
    if moneyType == IPY_GameWorld.TYPE_Price_Gold_Money:
        return curPlayer.GetWarehouseGold()
    
    if moneyType == IPY_GameWorld.TYPE_Price_Gold_Paper:
        return curPlayer.GetWarehouseGoldPaper()
    
    if moneyType == IPY_GameWorld.TYPE_Price_Silver_Money:
        return curPlayer.GetWarehouseSilver()
    
    if moneyType == IPY_GameWorld.TYPE_Price_Silver_Paper:
        return curPlayer.GetWarehouseSilverPaper()
    
    GameWorld.ErrLog("GetWarehouseMoney, moneyType:%d Err" % (moneyType))
    return 0

## »ñµÃ×Ô¶¨Òå»õ±Ò£¨»ý·Ö£©
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def GetPlayerCurrency(curPlayer, currencyType):
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Currency % currencyType)

## ÉèÖÃ×Ô¶¨Òå»õ±Ò£¨»ý·Ö£©
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def SetPlayerCurrency(curPlayer, currencyType, value):
    NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Currency % currencyType, value)
    #֪ͨ¿Í»§¶Ë
    NotifyPlayerCurrency(curPlayer, currencyType, value)
    return

def NotifyPlayerCurrency(curPlayer, currencyType, value=-1):
    if currencyType not in ShareDefine.TYPE_Price_CurrencyDict:
        return
    refreshType = ShareDefine.TYPE_Price_CurrencyDict[currencyType]
    if refreshType == None:
        # ²»ÐèҪ֪ͨ¿Í»§¶Ë
        return
    if value < 0:
        value = GetPlayerCurrency(curPlayer, currencyType)
    SendPropertyRefresh(curPlayer, refreshType, value)
    return

# ֪ͨÍæ¼ÒËùÓÐ×Ô¶¨Òå»õ±Ò
def NotifyPlayerAllCurrency(curPlayer):
    notifyList = []
    for currencyType in ShareDefine.TYPE_Price_CurrencyDict:
        refreshType = ShareDefine.TYPE_Price_CurrencyDict[currencyType]
        if refreshType == None:
            # ²»ÐèҪ֪ͨ¿Í»§¶Ë
            continue
        
        #´Ë´¦¸ù¾ÝÐèÇóÈôValueΪ0 ¿É²»Í¨Öª¿Í»§¶Ë£¬¾ßÌ幦ÄÜÖÆ×÷Õß¾ö¶¨
        value = GetPlayerCurrency(curPlayer, currencyType)
        notifyStruct = ChPyNetSendPack.tagRefreshType()
        notifyStruct.RefreshType = refreshType
        notifyStruct.Value = value
        notifyList.append(notifyStruct)
        
    # ¸ºÖµ»õ±Ò
    for moneyType, refreshType in ShareDefine.MoneyMinusRefreshDict.items():
        if refreshType == None:
            # ²»ÐèҪ֪ͨ¿Í»§¶Ë
            continue
        value = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
        if not value:
            continue
        notifyStruct = ChPyNetSendPack.tagRefreshType()
        notifyStruct.RefreshType = refreshType
        notifyStruct.Value = value
        notifyList.append(notifyStruct)
        
    #ÊôÐÔ×éºÏ°ü ֪ͨ×Ô¼º
    sendPack = ChPyNetSendPack.tagObjInfoListRefresh()
    sendPack.Clear()
    sendPack.ObjID = curPlayer.GetID()
    sendPack.ObjType = curPlayer.GetGameObjType()
    sendPack.Count = len(notifyList)
    sendPack.RefreshType = notifyList
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

def NotifyUseMoneyTotal(curPlayer, moneyTypeList=None):
    if moneyTypeList:
        notifyMoneyTypeList = moneyTypeList
    else:
        notifyMoneyTypeList = ShareDefine.UseTotalPriceTypeList
        
    infoList = []
    for moneyType in notifyMoneyTypeList:
        useTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UseMoneyTotal % moneyType)
        if not useTotal and moneyTypeList == None:
            continue
        info = ChPyNetSendPack.tagMCUseMoneyTotal()
        info.MoneyType = moneyType
        info.UseTotal = useTotal
        infoList.append(info)
            
    if not infoList:
        return
    
    clientPack = ChPyNetSendPack.tagMCUseMoneyTotalInfo()
    clientPack.Clear()
    clientPack.InfoList = infoList
    clientPack.Count = len(clientPack.InfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

##Íæ¼ÒÊÇ·ñÓÐÇ®¿î
# @param curPlayer Íæ¼ÒʵÀý
# @param TYPE_Price ,»õ±ÒÀàÐÍ
# @param Price ,»õ±Ò¼Û¸ñ
# @return ·µ»ØÖµÕæ, ͨ¹ý
# @remarks Íæ¼ÒÊÇ·ñÓÐÇ®¿î
def HaveMoney(curPlayer, TYPE_Price, Price, needNotify=True):
    if Price < 0:
        return False
    
    needMoneyCount = 0
    notifyCode = ''
    #½ð×ÓÖ§¸¶
    if TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
        needMoneyCount = curPlayer.GetGold()
        notifyCode = "GoldErr"
        
    #½ðƱ֧¸¶
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
        needMoneyCount = curPlayer.GetGoldPaper()
        notifyCode = "GoldPaperErr"
       
    #Òø×ÓÖ§¸¶
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
        needMoneyCount = GetSilver(curPlayer)
        notifyCode = "SilverErr"
        
    #ÒøƱ֧¸¶
    elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
        needMoneyCount = curPlayer.GetSilverPaper()
        notifyCode = "SilverPaperErr"
        
    #´ú±ÒÖ§¸¶
    elif TYPE_Price == ShareDefine.TYPE_Price_PayCoin:
        needMoneyCount = GetPayCoinTotal(curPlayer)
        
    #×Ô¶¨Òå»õ±Ò
    elif TYPE_Price in ShareDefine.TYPE_Price_CurrencyDict:
        needMoneyCount = GetPlayerCurrency(curPlayer, TYPE_Price)
    else:
        GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ TYPE_Price = %s" % (TYPE_Price), curPlayer.GetPlayerID())
        return False   
    
    if needMoneyCount < Price:
        lackPrice = Price - needMoneyCount # »¹È±¶àÉÙÇ®
        tagMoneyInfo = GetEqualMoneyInfo(TYPE_Price, lackPrice)
        if tagMoneyInfo:
            tagMoneyType, tagMoneyValue = tagMoneyInfo
            if HaveMoney(curPlayer, tagMoneyType, tagMoneyValue, False):
                GameWorld.DebugLog("HaveMoney¿ÉʹÓõȼۻõ±Ò²¹×ã¿Û³ý: TYPE_Price=%s, Price=%s, lackPrice=%s, tagMoneyType=%s, tagMoneyValue=%s" 
                                   % (TYPE_Price, Price, lackPrice, tagMoneyType, tagMoneyValue), curPlayer.GetPlayerID())
                return True
            
    #---Ç®²»¹» ·µ»Ø¼ÙÈç¹ûÐèÒªÌáʾµÄ»° ÌáʾÐÅÏ¢---
    if needMoneyCount < Price:
        if needNotify and notifyCode:
            NotifyCode(curPlayer, notifyCode)
        GameWorld.DebugLog("»õ±Ò²»×ã: TYPE_Price=%s, Price=%s, curMoneyCount=%s" % (TYPE_Price, Price, needMoneyCount))
        return False
    
    return True

def GetEqualMoneyInfo(moneyType, needValue):
    equalMoneyInfo = IpyGameDataPY.GetFuncEvalCfg("EqualValueMoney", 2, {})
    if str(moneyType) not in equalMoneyInfo:
        return
    tagMoneyType = equalMoneyInfo[str(moneyType)]
    exchangeMoneyInfo = IpyGameDataPY.GetFuncEvalCfg("EqualValueMoney", 1, {})
    if str(tagMoneyType) not in exchangeMoneyInfo:
        return
    exchangeInfo = exchangeMoneyInfo[str(tagMoneyType)]
    if moneyType != exchangeInfo[0]:
        return
    multiple = exchangeInfo[1]
    tagMoneyValue = int(math.ceil(needValue / float(multiple)))
    #GameWorld.DebugLog("µÈ¼Û»õ±ÒÐÅÏ¢: moneyType=%s,needValue=%s,multiple=%s,tagMoneyType=%s,tagMoneyValue=%s" 
    #                   % (moneyType, needValue, multiple, tagMoneyType, tagMoneyValue))
    return tagMoneyType, tagMoneyValue

#---------------------------------------------------------------------
##Íæ¼ÒÊÇ·ñÓÐÇ®¿î
# @param curPlayer Íæ¼ÒʵÀý
# @param TYPE_Price ,»õ±ÒÀàÐÍ
# @param Price ,»õ±Ò¼Û¸ñ
# @return ·µ»ØÖµ[[type1,price1], [type2,price2]]
# @remarks Íæ¼ÒÊÇ·ñÓÐÇ®¿î
def HaveMoneyEx(curPlayer, TYPE_Price, Price, needNotify=True):
    if Price < 0:
        return []
    if TYPE_Price == ShareDefine.TYPE_Price_Gold_Paper_Money:
        TYPE_Price = IPY_GameWorld.TYPE_Price_Gold_Money #аæÎÞ°óÓñ£¬Ô­ÏÈ°óÓñÔÙÏÉÓñµÄ¿Û·¨¸Ä³É ¿ÛÏÉÓñ 2019/3/26
        #âýÓ¢°æ£º »Ö¸´°óÓñ£¬µ«ÊDz»Ê¹ÓÃÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔò£¬Ô­À´ÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔòÒ»ÑùΪĬÈÏ¿ÛÏÉÓñ 2019/10/8
        
    if TYPE_Price in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper,
                      IPY_GameWorld.TYPE_Price_Silver_Money, IPY_GameWorld.TYPE_Price_Silver_Paper]:
        if HaveMoney(curPlayer, TYPE_Price, Price, needNotify):
            return [[TYPE_Price, Price]]
        return []
    
    #ÏÈÀñȯÔÙÔª±¦
    elif TYPE_Price == ShareDefine.TYPE_Price_Gold_Paper_Money:
        goldPaper = curPlayer.GetGoldPaper() # Àñȯ
        gold = curPlayer.GetGold() # Ôª±¦
        
        if goldPaper + gold < Price: # Ç®²»¹»
            if needNotify:
                NotifyCode(curPlayer, "GoldErr")
            return []
            
        if goldPaper >= Price: # Ö»ÓÃÀñȯ¾Í¹»ÁË
            return [[IPY_GameWorld.TYPE_Price_Gold_Paper, Price]]
        needGold = Price - goldPaper # ÓÃÍêÀñȯ£¬»¹ÐèÒªÔª±¦
        return [[IPY_GameWorld.TYPE_Price_Gold_Paper, goldPaper], [IPY_GameWorld.TYPE_Price_Gold_Money, needGold]]
#    #ÓÃÕ½Ã˹±Ï׶È
#    elif TYPE_Price == ShareDefine.TYPE_Price_Family_Contribution:
#        return []
    else:
        GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ TYPE_Price = %s" % (TYPE_Price), curPlayer.GetPlayerID())
        return []   
    
    return []


#---------------------------------------------------------------------
##Íæ¼Ò¸¶¿î
# @param curPlayer Íæ¼ÒʵÀý
# @param type_Price ,»õ±ÒÀàÐÍ
# @param price ,»õ±Ò¼Û¸ñ
# @param costType ,Ïû·ÑµãÀàÐÍ
# @param infoDict ,À©Õ¹ÐÅÏ¢, ×ÓÏû·Ñ¶ÔÏó¿ÉÒÔͨ¹ýÉèÖÃChConfig.Def_Cost_Reason_SonKey keyÖµ
# @param quantity ,ÊýÁ¿
# @param isMinus ,ÊÇ·ñÔÊÐí¿Û³É¸ºÖµ
# @return ·µ»ØÖµÕæ, ¸¶¿î³É¹¦
# @remarks Íæ¼Ò¸¶¿î
def PayMoney(curPlayer, type_Price, price, costType=ChConfig.Def_Cost_Unknown, infoDict={}, quantity=1, costVIPGold= -1, isNotify=True, isMinus=False):
    if price == 0:
        return True
    if price < 0:
        GameWorld.Log('###---¿ÛÇ®Òì³£ = %s' % (price), curPlayer.GetPlayerID())
        return False
    lostMoney = price
    
    #20190917 »Ö¸´°óÓñ
#    if type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
#        type_Price = IPY_GameWorld.TYPE_Price_Gold_Money #аæÎÞ°óÓñ£¬Ô­ÏÈ°óÓñÔÙÏÉÓñµÄ¿Û·¨¸Ä³É ¿ÛÏÉÓñ 2019/6/3
        
    #½ð×ÓÖ§¸¶
    if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
        curPlayerGold = GetMoneyReal(curPlayer, type_Price)
        if curPlayerGold < price and not isMinus:
            NotifyCode(curPlayer, "GoldErr")
            return False
        updPlayerGold = curPlayerGold - price
        SetMoney(curPlayer, type_Price, updPlayerGold)
        
        curBourseMoney = GetMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney)
        updBourseMoney = curBourseMoney
        #µ±Êǽ»Ò×Ëù¿Û·Ñ¡¢×êʯºì°üʱ£¬Ôò±Ø¶¨¿Û³ý½»Ò׶î¶È
        if costType in ChConfig.UnUseInner_CostType:
            updBourseMoney = max(0, curBourseMoney - price)
        #ÆäËûÈç¹ûµ±Ç°½ð×ӱȽ»Ò׶î¶È»¹ÉÙ£¬ÔòÇ¿ÖƵ÷Õû½»Ò׶î¶ÈΪµ±Ç°½ð×ÓÊý(ÕâÖÖÇé¿öÒ»°ãÊǷǽ»Ò×ËùÏû·ÑµÄ£¬ÐèҪͬ²½¿Û³ý½»Ò×Ëù¿É¹ºÂò¶î¶È)
        elif updPlayerGold < updBourseMoney:
            updBourseMoney = updPlayerGold
        updBourseMoney = max(0, updBourseMoney)
        if updBourseMoney != curBourseMoney:
            SetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_BourseMoney, updBourseMoney)
        infoDict["BourseMoney"] = updBourseMoney
        
    #½ðƱ֧¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
        curPlayerGoldPaper = GetMoneyReal(curPlayer, type_Price)
        if curPlayerGoldPaper < price and not isMinus:
            NotifyCode(curPlayer, "GoldPaperErr")
            return False
        updGoldPaper = curPlayerGoldPaper - price
        SetMoney(curPlayer, type_Price, updGoldPaper)
        
    #Òø×ÓÖ§¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
        curPlayerSilver = GetSilver(curPlayer)
        if curPlayerSilver < price:
            NotifyCode(curPlayer, "SilverErr")
            return False
        #ÓÐ×ã¹»µÄǮ֧¸¶
        SetSilver(curPlayer, curPlayerSilver - price)
        
    #ÒøƱ֧¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
        curPlayerSilverPaper = curPlayer.GetSilverPaper()
        if curPlayerSilverPaper < price:
            NotifyCode(curPlayer, "SilverPaperErr")
            return False
        #ÓÐ×ã¹»µÄǮ֧¸¶
        curPlayer.SetSilverPaper(curPlayerSilverPaper - price)
        
    #´ú±ÒÖ§¸¶
    elif type_Price == ShareDefine.TYPE_Price_PayCoin:
        curPlayerPayCoin = GetPayCoin(curPlayer)
        curPayCoinDay = GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
        payCoinTotal = curPlayerPayCoin + curPayCoinDay
        if payCoinTotal < price:
            return False
        #ÓÐ×ã¹»µÄǮ֧¸¶
        costPayCoinDay = price if (curPayCoinDay >= price) else curPayCoinDay
        costPayCoin = price
        if costPayCoinDay:
            GameWorld.DebugLog("ÏÈ¿Û´ú±ÒʱЧ: curPayCoinDay=%s,price=%s,costPayCoinDay=%s" % (curPayCoinDay, price, costPayCoinDay))
            SetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay, curPayCoinDay - costPayCoinDay)
            costPayCoin -= costPayCoinDay
            GameWorld.DebugLog("ÔÙ¿Û´ú±Ò: costPayCoin=%s" % (costPayCoin))
        #ʱЧ²»¹»¿Û³ý£¬ÔÙ¿Û·ÇʱЧ
        if costPayCoin > 0:
            SetPayCoin(curPlayer, curPlayerPayCoin - costPayCoin)
            
    #×Ô¶¨Òå»õ±Ò
    elif type_Price in ShareDefine.TYPE_Price_CurrencyDict:
        curCurrency = GetPlayerCurrency(curPlayer, type_Price)
        if curCurrency < price:
            lostMoney = curCurrency
            lackPrice = price - curCurrency # »¹È±¶àÉÙÇ®
            tagMoneyInfo = GetEqualMoneyInfo(type_Price, lackPrice)
            if tagMoneyInfo:
                tagMoneyType, tagMoneyValue = tagMoneyInfo
                if not PayMoney(curPlayer, tagMoneyType, tagMoneyValue, costType, infoDict, quantity, costVIPGold, isNotify, isMinus):
                    #GameWorld.Log("µÈ¼Û»õ±ÒÒ²²»×ã")
                    return False
                GameWorld.Log("µÈ¼Û»õ±Ò²¹×ã¿Û³ý: type_Price%s, price=%s, curCurrency=%s, lackPrice=%s, tagMoneyType=%s, tagMoneyValue=%s" 
                                   % (type_Price, price, curCurrency, lackPrice, tagMoneyType, tagMoneyValue), curPlayer.GetPlayerID())
            else:
                #GameWorld.Log("ûÓеȼۻõ±Ò£¬ÎÞ·¨¿Û³ý")
                return False
        #ÓÐ×ã¹»µÄǮ֧¸¶
        SetPlayerCurrency(curPlayer, type_Price, curCurrency - lostMoney)
    else:
        GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ type_Price = %s" % (type_Price), curPlayer.GetPlayerID())
        return False
    
    #¸¶¿îÒÔºóºóÐø²Ù×÷
    __PayMoneyAfter(curPlayer, type_Price, lostMoney, costType, infoDict, quantity, costVIPGold)
    
    #֪ͨ¿Í»§¶Ëʧȥ½ðÇ®
    if isNotify:
        if type_Price == ShareDefine.TYPE_Price_PayCoin:
            NotifyCode(curPlayer, "LostMoney", [type_Price, lostMoney/100])
        else:
            NotifyCode(curPlayer, "LostMoney", [type_Price, lostMoney])
    return True

## ¸¶¿îÒÔºóºóÐø²Ù×÷
#  @param curPlayer Íæ¼ÒʵÀý
#  @param type_Price ,»õ±ÒÀàÐÍ
#  @param price ,»õ±Ò¼Û¸ñ
#  @param costType ,Ïû·ÑÀàÐÍ
#  @param infoDict ,À©Õ¹ÐÅÏ¢
#  @param quantity Ïû·ÑÊýÁ¿
#  @return None
def __PayMoneyAfter(curPlayer, type_Price, price, costType, infoDict, quantity, costVIPGold):
    if type_Price in ShareDefine.UseTotalPriceTypeList:
        useTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UseMoneyTotal % type_Price)
        useTotal = min(useTotal + price, ChConfig.Def_UpperLimit_DWord)
        NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_UseMoneyTotal % type_Price, useTotal)
        NotifyUseMoneyTotal(curPlayer, [type_Price])
    
    #½ð×ÓÖ§¸¶
    if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
        __PayMoneyAfterByGoldMoney(curPlayer, type_Price, price, costType, infoDict, costVIPGold)
            
    #½ðƱ֧¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
        __PayMoneyAfterByGoldPaper(curPlayer, price, costType, infoDict)
    
    #Òø×ÓÖ§¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
        __PayMoneyAfterBySilverMoney(curPlayer, price)
    
    #ÒøƱ֧¸¶
    elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
        __PayMoneyAfterBySilverPaper(curPlayer, price)
    
    EventShell.EventRespons_OnMoneyChange(curPlayer, type_Price)
    
    #»îÔ¾¶È´¦Àí
    PlayerActivity.OnPayMoneyActivity(curPlayer, type_Price, price)
    #תÅ̻
    PlayerActTurntable.OnPlayerUseGold(curPlayer, type_Price, price)
    #Âֻصî
    PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_PayMoney, type_Price, price)
    
    unitPrice = price if quantity == 1 else int(math.ceil(price * 1.0 / quantity)) # µ¥¼Û
    #reason_name = "Unknown" if not costType else costType
    reason_name = costType
    eventName = reason_name
    if costType in ChConfig.Def_CostType_Dict:
        eventName = ChConfig.Def_CostType_Dict[costType]
    #===========================================================================
    # isDivSonKey = False # ÊÇ·ñÇø·ÖÏû·Ñ¶ÔÏó
    # if costType in ChConfig.Def_CostType_Dict:
    #    eventName, reason_name, isDivSonKey = ChConfig.Def_CostType_Dict[costType]
    #    if costType in ChConfig.CostGroupToGoldShop:
    #        reason_name = ChConfig.Def_CostType_Dict[ChConfig.Def_Cost_BuyStoreItem][1]
    #    
    # if isDivSonKey and isinstance(infoDict, dict) and ChConfig.Def_Cost_Reason_SonKey in infoDict:
    #    reasonSon = infoDict[ChConfig.Def_Cost_Reason_SonKey]
    # else:
    #    reasonSon = reason_name
    # # ͳһ¸ñʽ: ¡¸Ïû·Ñ×é:Ïû·Ñ¶ÔÏó¡¹ ; ûÓÐÉèÖÃÏû·Ñ¶ÔÏóµÄĬÈÏΪÏû·Ñ×é
    # reason_name = "%s:%s" % (reason_name, reasonSon)
    #===========================================================================
    
    # ³ý×êʯ¼°°ó×êÍ⣬δָ¶¨²Ù×÷ÀàÐ͵IJ»¼Ç¼
    if type_Price not in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper, ShareDefine.TYPE_Price_PayCoin] \
        and costType == ChConfig.Def_Cost_Unknown:
        #GameWorld.DebugLog("¸Ã»õ±ÒûÓÐÖ¸¶¨Ïû·ÑÀàÐͲ»¼Ç¼!type_Price=%s,costType=%s" % (type_Price, costType))
        return
    if type_Price == ShareDefine.TYPE_Price_PayCoin:
        playerID = curPlayer.GetPlayerID()
        nowMoney = GetMoneyReal(curPlayer, type_Price)
        payCoinDay = GetMoney(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
        infoDict["PlayerMoneyCount2"] = payCoinDay
        orderInfo = infoDict.get("orderInfo", "")
        GameWorld.Log("¼Ç¼ÏûºÄ´ú±Ò: eventName=%s,price=%s,nowMoney=%s,payCoinDay=%s,orderInfo=%s" % (eventName, price, nowMoney, payCoinDay, orderInfo), playerID)
        GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [2, price, nowMoney, payCoinDay], orderInfo, 1)
    # Á÷ÏòÓà eventName
    #if eventName:
    DataRecordPack.DR_UseMoney(curPlayer, eventName, type_Price, price, infoDict) # Á÷Ïò
    EventReport.WriteEvent_virtual_resource(curPlayer, type_Price, reason_name, quantity,
                                            unitPrice, ShareDefine.Def_UserAction_Money_Use, infoDict)
    #===========================================================================
    # if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
    #    EventReport.WriteEvent_virtual_cost(curPlayer, quantity, unitPrice, reason_name)
    # elif type_Price in [IPY_GameWorld.TYPE_Price_Gold_Paper, IPY_GameWorld.TYPE_Price_Silver_Money]:
    #    
    #    # ½ð±Òδָ¶¨Ïû·ÑÀàÐ͵IJ»¼Ç¼
    #    if type_Price == IPY_GameWorld.TYPE_Price_Silver_Money and costType == ChConfig.Def_Cost_Unknown:
    #        return
    #    EventReport.WriteEvent_virtual_resource(curPlayer, type_Price, reason_name, quantity, 
    #                                            unitPrice, ShareDefine.Def_UserAction_Money_Use)
    #    
    # # ×Ô¶¨Òå¼Ç¼
    # priceNameDict = {IPY_GameWorld.TYPE_Price_Gold_Money:["×êʯ", "GetGold", 0],
    #                 IPY_GameWorld.TYPE_Price_Gold_Paper:["°ó×ê", "GetGoldPaper", 0],
    #                 IPY_GameWorld.TYPE_Price_Silver_Money:["½ð±Ò", "GetSilver", ChConfig.Def_DRRecord_Min_Silver],
    #                 }
    # if type_Price in priceNameDict:
    #    typeName, moneyFuncName, minPrice = priceNameDict[type_Price]
    #    if minPrice <= 0 or price >= minPrice: 
    #        EventReport.WriteEvent_pay_money(curPlayer, reason_name, typeName, price, getattr(curPlayer, moneyFuncName)())
    #===========================================================================
    return

## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ð×Ó)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param price ,»õ±Ò¼Û¸ñ
#  @return None
def __PayMoneyAfterByGoldMoney(curPlayer, type_Price, price, costType, infoDict, costVIPGold):
        
    
    # ³äÖµ»î¶¯Íæ¼ÒÏûºÄÔª±¦´¦Àí
    #PlayerGoldAction.PlayerUseGold(curPlayer, price)
    
    # Ïû·Ñ·µÀû
    if costType not in ChConfig.CostRebate_DisableType:
        PlayerCostRebate.AddCostRebateGold(curPlayer, costType, price, infoDict)
        PlayerFeastTravel.AddFeastTravelTaskValue(curPlayer, ChConfig.Def_FeastTravel_UseGold, price)
        PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_UseGold, price)
    else:
        GameWorld.DebugLog("²»¼ÆÈëÏû·Ñ»î¶¯µÄÏû·ÑÀàÐÍ!costType=%s" % costType, curPlayer.GetPlayerID())
        
    # ʼþ»ã±¨
    #===========================================================================
    # if costType == ChConfig.Def_Cost_BourseBuy:
    #    # ½»Ò×Ëù¹ºÂòÎïÆ·£¬»ã±¨½»Ò××êʯ
    #    playerName = curPlayer.GetPlayerName()
    #    leftGold = curPlayer.GetGold()
    #    eventParam = "RoleID=%s,Price=%s,TradeType=Lost,LeftGold=%s" \
    #                    % (playerName, price, leftGold)
    #    EventReport.EventReport(ShareDefine.Def_UserAction_TradeGold, eventParam, curPlayer)
    # else:
    #    playerName = curPlayer.GetPlayerName()
    #    leftGold = curPlayer.GetGold()
    #    eventParam = "RoleID=%s,CostType=%s,ItemID=%s,Price=%s,LeftGold=%s" \
    #                    % (playerName, costType, infoDict, price, leftGold)
    #    EventReport.EventReport(ShareDefine.Def_UserAction_UseGold, eventParam, curPlayer)
    #===========================================================================
    
    # ֪ͨԪ±¦Ïû·Ñ¼Ç¼
    #__Sync_GoldCostReport(curPlayer, costType, price, expandValue)
    return


## ֪ͨԪ±¦Ïû·Ñ¼Ç¼
#  @param curPlayer: Íæ¼ÒʵÀý
#  @param costType: Ïû·ÑµãÀàÐÍ
#  @param price: Ïû·Ñ¶î¶È
#  @param itemID: ÎïÆ·id£¬Ïû·ÑÀàÐÍΪÎïƷʱ¿ÉÌî
#  @return None
def __Sync_GoldCostReport(curPlayer, costType, price, itemID=0):
    sendPack = ChPyNetSendPack.tagMCGoldCostReport()
    sendPack.Clear()
    sendPack.CostType = costType
    sendPack.Price = price
    sendPack.ItemID = itemID
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return


## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param price ,»õ±Ò¼Û¸ñ
#  @return None
def __PayMoneyAfterByGoldPaper(curPlayer, price, costType, infoDict):    
    
    # ʼþ»ã±¨
    #===========================================================================
    # playerName = curPlayer.GetPlayerName()
    # leftGoldPaper = curPlayer.GetGoldPaper()
    # eventParam = "RoleID=%s,CostType=%s,ItemID=%s,Price=%s,LeftGoldPaper=%s" \
    #                % (playerName, costType, infoDict, price, leftGoldPaper)
    # EventReport.EventReport(ShareDefine.Def_UserAction_UseGoldPaper, eventParam, curPlayer)
    #===========================================================================
    return


## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param price ,»õ±Ò¼Û¸ñ
#  @return None
def __PayMoneyAfterBySilverMoney(curPlayer, price):    
    return


## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param price ,»õ±Ò¼Û¸ñ
#  @return None
def __PayMoneyAfterBySilverPaper(curPlayer, price):    
    return

#---------------------------------------------------------------------
##Íæ¼Ò»ñµÃ½ðÇ®
# @param curPlayer Íæ¼ÒʵÀý
# @param value ,»õ±Ò¼Û¸ñ
# @param priceType ,»õ±ÒÀàÐÍ
# @return ·µ»ØÖµÕæ, ¸øÇ®³É¹¦
# @param isSysHint ÊÇ·ñϵͳÌáʾ£¨Ä¬ÈÏÊÇ£©
# @remarks Íæ¼Ò»ñµÃ½ðÇ®
def GiveMoney(curPlayer, priceType, value, giveType=ChConfig.Def_GiveMoney_Unknown, addDataDict={}, isSysHint=True, isGiveBourseMoney=True):
    if value == 0:
        return True
    
    if value < 0:
        GameWorld.Log('Íæ¼Ò»ñµÃ½ðÇ®Òì³£ £¬ value = %s , priceType = %s ,' % (value, priceType))
        return
    
    if GameWorld.IsCrossServer():
        serverGroupID = GetPlayerServerGroupID(curPlayer)
        msgInfo = {"PlayerID":curPlayer.GetPlayerID(), "MoneyType":priceType, "Value":value, "GiveType":giveType, "AddDataDict":addDataDict}
        GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_GiveMoney, msgInfo, [serverGroupID])
        return True
        
    if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
        updPlayerGold = GetMoneyReal(curPlayer, priceType) + value
        if updPlayerGold > ChConfig.Def_PlayerTotalMoney_Gold:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return
        SetMoney(curPlayer, priceType, updPlayerGold)
        
        if isGiveBourseMoney and updPlayerGold > 0:
            GiveMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney, min(value, updPlayerGold))
        addDataDict["BourseMoney"] = GetMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney)
        
    elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
        updPlayerGoldPaper = GetMoneyReal(curPlayer, priceType)  + value
        if updPlayerGoldPaper > ChConfig.Def_PlayerTotalMoney_Gold:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return
        SetMoney(curPlayer, priceType, updPlayerGoldPaper)
        
    elif priceType == IPY_GameWorld.TYPE_Price_Silver_Money:
        # ½ðǮ֧³Ö³¬¹ý20ÒÚ, Ôݲ»×öÉÏÏÞ¿ØÖÆ
#        if curSilver + value > ChConfig.Def_PlayerTotalMoney_Silver:
#            #³¬¹ý½ðÇ®ÉÏÏÞ
#            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
#            return
        SetSilver(curPlayer, GetSilver(curPlayer) + value)
       
        
    elif priceType == IPY_GameWorld.TYPE_Price_Silver_Paper:
        if curPlayer.GetSilverPaper() + value > ChConfig.Def_PlayerTotalMoney_Silver:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return
        
        curPlayer.SetSilverPaper(curPlayer.GetSilverPaper() + value)
        
    elif priceType == ShareDefine.TYPE_Price_PayCoin:
        SetPayCoin(curPlayer, GetPayCoin(curPlayer) + value)
        
    #×Ô¶¨Òå»õ±Ò
    elif priceType in ShareDefine.TYPE_Price_CurrencyDict:
        curCurrency = GetPlayerCurrency(curPlayer, priceType)
        if curCurrency >= ChConfig.Def_UpperLimit_DWord:
            return
        updValue = min(ChConfig.Def_UpperLimit_DWord, curCurrency + value)
        SetPlayerCurrency(curPlayer, priceType, updValue)
        if priceType == ShareDefine.TYPE_Price_RealmPoint:
            PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_GetRealmPoint, value)
            EventShell.EventRespons_GetRealmPoint(curPlayer)
    else:
        GameWorld.ErrLog("½ðÇ®ÀàÐÍ´íÎó, priceType=%s,value=%s,giveType=%s" % (priceType, value, giveType), curPlayer.GetPlayerID())
        DataRecordPack.DR_GiveMoneyError(curPlayer, priceType, value, giveType, addDataDict)
        return
    
    # ʱЧ´ú±ÒºóÐø´¦Àí¾ùÊÓΪ´ú±Ò£¬°üº¬ÏµÍ³Ìáʾ¡¢¼Ç¼¡¢Á÷ÏòµÈ
    if priceType == ShareDefine.TYPE_Price_PayCoinDay:
        priceType = ShareDefine.TYPE_Price_PayCoin
        
    if isSysHint and priceType != ShareDefine.TYPE_Price_BourseMoney:
        #֪ͨ¿Í»§¶ËµÃµ½½ðÇ®
        if priceType == ShareDefine.TYPE_Price_PayCoin:
            NotifyCode(curPlayer, "GetMoney", [priceType, value/100])
        else:
            NotifyCode(curPlayer, "GetMoney", [priceType, value])
    __GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict)
    
    return True

def __GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict):
    # ³ý×êʯ¼°°ó×êÍ⣬δָ¶¨²Ù×÷ÀàÐ͵IJ»¼Ç¼
    
    EventShell.EventRespons_OnMoneyChange(curPlayer, priceType)
    
    if priceType not in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper, ShareDefine.TYPE_Price_PayCoin] \
        and giveType == ChConfig.Def_GiveMoney_Unknown:
        #GameWorld.DebugLog("¸Ã»õ±ÒûÓÐÖ¸¶¨À´Ô´ÀàÐͲ»¼Ç¼!priceType=%s,giveType=%s" % (priceType, giveType))
        return
    eventName = giveType
    if giveType in ChConfig.Def_GetType_Dict:
        eventName = ChConfig.Def_GetType_Dict[giveType]
        addDataDict["eventName"] = eventName
        
    if priceType == ShareDefine.TYPE_Price_PayCoin:
        playerID = curPlayer.GetPlayerID()
        nowMoney = GetMoneyReal(curPlayer, priceType)
        payCoinDay = GetMoney(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
        addDataDict["PlayerMoneyCount2"] = payCoinDay
        orderInfo = addDataDict.get("orderInfo", "")
        GameWorld.Log("¼Ç¼»ñµÃ´ú±Ò: eventName=%s,value=%s,nowMoney=%s,payCoinDay=%s,orderInfo=%s" % (eventName, value, nowMoney, payCoinDay, orderInfo), playerID)
        GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [1, value, nowMoney, payCoinDay], orderInfo, 1)
        
    DataRecordPack.DR_GiveMoney(curPlayer, eventName, priceType, value, addDataDict)
    EventReport.WriteEvent_virtual_resource(curPlayer, priceType, giveType, 1, value,
                                            ShareDefine.Def_UserAction_Money_Get, addDataDict)
    
#===============================================================================
#    reason_name = "Unknown" if not giveType else giveType
#    eventName = reason_name
#    if giveType in ChConfig.Def_GetType_Dict:
#        eventName, reason_name = ChConfig.Def_GetType_Dict[giveType][:2]
#    if isinstance(addDataDict, dict) and ChConfig.Def_Give_Reason_SonKey in addDataDict:
#        reasonSon = addDataDict[ChConfig.Def_Give_Reason_SonKey]
#    else:
#        reasonSon = reason_name
#    # ͳһ¸ñʽ: ¡¸»ñµÃ×é:»ñµÃÔ­Òò¡¹
#    reason_name = "%s:%s" % (reason_name, reasonSon)
#            
#    # Á÷ÏòÓà eventName
#    if eventName:
#        DataRecordPack.DR_GiveMoney(curPlayer, eventName, priceType, value, addDataDict)
#        
#    if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
#        playerName = curPlayer.GetPlayerName()
#        eventParam = "RoleID=%s,AddGold=%s,LeftGold=%s,AddDataDict=%s" \
#                    % (playerName, value, curPlayer.GetGold(), addDataDict)
#        EventReport.EventReport(ShareDefine.Def_UserAction_GameMakeGold, eventParam, curPlayer)
#        
#    elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
#        playerName = curPlayer.GetPlayerName()
#        eventParam = "RoleID=%s,AddGoldPaper=%s,LeftGoldPaper=%s,AddDataDict=%s" \
#                        % (playerName, value, curPlayer.GetGoldPaper(), addDataDict)
#        EventReport.EventReport(ShareDefine.Def_UserAction_GameMakeGoldPaper, eventParam, curPlayer)
#    
# 
#    if priceType == IPY_GameWorld.TYPE_Price_Gold_Money: #and eventName != "CoinToGold":
#        EventReport.WriteEvent_virtual_reward(curPlayer, value, reason_name)
#    # ¶þ¼¶»õ±Ò²ú³ö¼Ç¼, ÔÝÖ»¼Ç¼°ó×ê¡¢½ð±Ò
#    elif priceType in [IPY_GameWorld.TYPE_Price_Gold_Paper, IPY_GameWorld.TYPE_Price_Silver_Money]:
#        EventReport.WriteEvent_virtual_resource(curPlayer, priceType, reason_name, 1, value,
#                                                ShareDefine.Def_UserAction_Money_Get)
#        
#    # ×Ô¶¨Òå¼Ç¼
#    priceNameDict = {IPY_GameWorld.TYPE_Price_Gold_Money:["×êʯ", "GetGold", 0],
#                     IPY_GameWorld.TYPE_Price_Gold_Paper:["°ó×ê", "GetGoldPaper", 0],
#                     IPY_GameWorld.TYPE_Price_Silver_Money:["½ð±Ò", "GetSilver", ChConfig.Def_DRRecord_Min_Silver],
#                     }
#    if priceType in priceNameDict:
#        typeName, moneyFuncName, minPrice = priceNameDict[priceType]
#        if minPrice <= 0 or value >= minPrice: 
#            EventReport.WriteEvent_give_money(curPlayer, reason_name, typeName, value, getattr(curPlayer, moneyFuncName)())
#===============================================================================
        
    return


#---------------------------------------------------------------------
##Íæ¼ÒÄÜ·ñ»ñµÃ½ðÇ®
# @param curPlayer Íæ¼ÒʵÀý
# @param value ,»õ±Ò¼Û¸ñ
# @param type ,»õ±ÒÀàÐÍ
# @return ·µ»ØÖµÕæ, ͨ¹ý
# @remarks Íæ¼ÒÄÜ·ñ»ñµÃ½ðÇ®
def CanGiveMoney(curPlayer, priceType, value):
    if value == 0:
        return True
    
    if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
        if curPlayer.GetGold() + value > ChConfig.Def_PlayerTotalMoney_Gold:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return False 
    elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
        if curPlayer.GetGoldPaper() + value > ChConfig.Def_PlayerTotalMoney_Gold:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return False
    elif priceType == IPY_GameWorld.TYPE_Price_Silver_Money:
        #½ð±ÒÖ§³Ö³¬¹ý20ÒÚ£¬Ôݲ»×öÉÏÏÞ¿ØÖÆ
        pass
#        if GetSilver(curPlayer) + value > ChConfig.Def_PlayerTotalMoney_Silver:
#            #³¬¹ý½ðÇ®ÉÏÏÞ
#            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
#            return False
    elif priceType == IPY_GameWorld.TYPE_Price_Silver_Paper:
        if curPlayer.GetSilverPaper() + value > ChConfig.Def_PlayerTotalMoney_Silver:
            #³¬¹ý½ðÇ®ÉÏÏÞ
            NotifyCode(curPlayer, "MoneyIsFull", [priceType])
            return False
    elif priceType == ShareDefine.TYPE_Price_PayCoin:
        pass
    elif priceType in ShareDefine.TYPE_Price_CurrencyDict:
        curCurrency = GetPlayerCurrency(curPlayer, priceType)
        if curCurrency + value > ChConfig.Def_UpperLimit_DWord:
            return False
    else:
        
        GameWorld.Log("½ðÇ®ÀàÐÍ = %sÌî´íÀ²" % (priceType), curPlayer.GetPlayerID())
        return False 
    
    return True

#---------------------------------------------------------------------
##Íæ¼Ò×Ô¶¯»ØѪ
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò×Ô¶¯»ØѪ
def PlayerAutoRestoreHP(curPlayer, tick):
    return
    
#---------------------------------------------------------------------
##Íæ¼Ò×Ô¶¯»Øħ
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Íæ¼Ò×Ô¶¯»Øħ
def PlayerAutoRestoreMP(curPlayer, tick):
    return


##»ñµÃµ±Ç°Íæ¼ÒµÄ²Î¿¼¾­Ñé
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµ, ²Î¿¼¾­Ñé
# @remarks »ñµÃµ±Ç°Íæ¼ÒµÄ²Î¿¼¾­Ñé
def GetPlayerReExp(curPlayer):
    lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
    if not lvIpyData:
        return 0
    return lvIpyData.GetReExp()

## »ñµÃµ±Ç°Íæ¼ÒµÄ²Î¿¼½ðÇ®
#  @param curPlayer Íæ¼ÒʵÀý
#  @return
def GetPlayerReMoney(curPlayer):
    return 0

#---------------------------------------------------------------------
##Ôö¼ÓÍæ¼ÒµÄPKÖµ
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Ôö¼ÓÍæ¼ÒµÄPKÖµ
def AddPlayerPKValue(curPlayer, tick):
    curPlayerPKValue = curPlayer.GetPKValue()
    maxPKValue = GetMaxPKValue()
    if curPlayerPKValue >= maxPKValue:
        #µ±Ç°PKÖµÒѵ½ÉÏÏÞ,²»Ìí¼Ó
        return
    
    #Ìí¼ÓµãÊý
    addPoint = 1
    changePKValue = ChangePKValue(curPlayer, addPoint, tick)
    
    if changePKValue >= maxPKValue:
        #PK_wll_0: ÄúɱÄõ¹ýÖØ£¬ÔÚºìÃû״̬ÏûʧǰÄú½«²»ÄܼÌÐø¶øÒѹ¥»÷ËûÈË
        NotifyCode(curPlayer, "PK_lhs_202580")
        
    #Íæ¼ÒïÚ³µÉíÉϼǼÍæ¼ÒÃû×ÖÑÕÉ«ÐÅÏ¢(±ØÐëÔÚÉèÖúìÃûÒÔºó)
    #PlayerTruck.ChangeTruckNoteInfo(curPlayer)
    return

def ChangePKValue(curPlayer, addValue, tick):
    '''¸ü¸ÄPKÖµ'''
    curPlayerPKValue = curPlayer.GetPKValue()
    maxPKValue = GetMaxPKValue()
    newPKValue = max(0, min(maxPKValue, curPlayerPKValue + addValue))
    if newPKValue == curPlayerPKValue:
        return newPKValue
    
    GameWorld.DebugLog("¸üÐÂPKÖµ: curPlayerPKValue=%s,newPKValue=%s,addValue=%s" % (curPlayerPKValue, newPKValue, addValue), curPlayer.GetPlayerID())
    if newPKValue == 0:
        ClearPKValue(curPlayer)
    else:
        addBuffID = ChConfig.Def_SkillID_Red
        curPlayer.SetPKValue(newPKValue)
        findBuffInfo = SkillCommon.FindBuffByID(curPlayer, addBuffID)
        redBuff = findBuffInfo[0]
        addTimeValue = newPKValue - curPlayerPKValue
        if not redBuff:
            SkillCommon.AddBuffBySkillType_NoRefurbish(curPlayer, addBuffID, tick)
            if newPKValue > 1:
                findBuffInfo = SkillCommon.FindBuffByID(curPlayer, addBuffID)
                redBuff = findBuffInfo[0]
                addTimeValue = newPKValue - 1
                
        if addTimeValue and redBuff:
            __AddPKValueRedBuffTime(curPlayer, redBuff, addTimeValue)
    return newPKValue

def __AddPKValueRedBuffTime(curPlayer, redBuff, addTimeValue):
    '''Ôö¼ÓPKÖµ¶ÔÓ¦buffʱ³¤
    @param addTimeValue: Ôö¼ÓµÄbuffµ¥Î»Ê±³¤´ÎÊý, Ö§³ÖÕý¸º
    '''
    buffSkill = redBuff.GetSkill()
    if not buffSkill:
        return
    buffType = SkillCommon.GetBuffType(buffSkill)
    addTime = buffSkill.GetLastTime() * addTimeValue # ÓÐÕý¸º
    remainTime = redBuff.GetRemainTime()
    resultTime = min(max(0, remainTime + addTime), ChConfig.Def_Max_Buff_RemainTime)
    redBuff.SetRemainTime(resultTime)
    BuffSkill.PYSync_RefreshBuff(curPlayer, redBuff, buffType)
    GameWorld.DebugLog("    Ôö¼ÓºìÃûbuffʱ³¤: addTimeValue=%s,remainTime=%s,addTime=%s,resultTime=%s" 
                       % (addTimeValue, remainTime, addTime, resultTime), curPlayer.GetPlayerID())
    return

def RefreshPKValueByRedBuff(curPlayer):
    ## ˢкìÃû¶ÔÓ¦PKValue
    curPKValue = curPlayer.GetPKValue()
    if not curPKValue:
        return
    if PlayerTJG.GetIsTJG(curPlayer):
        return
    redBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_Red)[0]
    if not redBuff:
        curPlayer.SetPKValue(0)
        return
    buffSkill = redBuff.GetSkill()
    if not buffSkill:
        return
    remainTime = redBuff.GetRemainTime()
    perPKValueTime = buffSkill.GetLastTime()
    pkValue = int(math.ceil(remainTime / float(perPKValueTime)))
    if curPKValue != pkValue:
        curPlayer.SetPKValue(pkValue)
        GameWorld.DebugLog("¸üÐÂÍæ¼ÒPKÖµ: remainTime=%s,pkValue=%s" % (remainTime, pkValue), curPlayer.GetPlayerID())
    return

def ClearPKValue(curPlayer):
    '''Çå³ýPKÖµ'''
    curPlayer.SetPKValue(0)
    tick = GameWorld.GetGameWorld().GetTick()
    BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_Red, tick)
    return

def GetMaxPKValue():
    '''»ñÈ¡×î´óPKÖµ'''
    return IpyGameDataPY.GetFuncCfg("PKConfig", 2)

#---------------------------------------------------------------------
##»ñµÃÍæ¼ÒÉý¼¶, »ñµÃµÄÊôÐÔµã
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµ, »ñµÃµÄÊôÐÔµã
# @remarks »ñµÃÍæ¼ÒÉý¼¶, »ñµÃµÄÊôÐÔµã
def GetLvUp_AddPoint(curPlayer):
    curPlayerID = curPlayer.GetID()
    curLV = curPlayer.GetLV() # µ±Ç°µÈ¼¶
    
    addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
    addPoint = GameWorld.GetDictValueByRangeKey(addPointDict, curLV, 0)
    
    if addPoint == None:
        raise Exception('Íæ¼Ò»ñµÃÉý¼¶ÊôÐÔµãÒì³£, curLV = %s PlayerID = %s' % (curLV, curPlayerID))
        return
    return int(addPoint+ GetFabaoAddPoint(curPlayer) + GetTitleAddExtraPoint(curPlayer))

def GetAllPointByLV(curPlayer):
    ##»ñÈ¡µ±Ç°µÈ¼¶¿ÉµÃµ½ÊôÐÔµãÊý
    openLV = GameFuncComm.GetFuncLimitLV(ShareDefine.GameFuncID_AddPoint)
    curLV = curPlayer.GetLV()
    if curLV < openLV:
        return 0
    # ³õʼµã+(Éý¼¶µã+·¨±¦Ð§¹û)*³ÆºÅЧ¹û±¶Êý+¾³½çµã
    setFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)
    fabaoAddPoint = GetFabaoAddPoint(curPlayer)
    titleAddPoint = GetTitleAddExtraPoint(curPlayer)
    addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
    for rangLVs, point in addPointDict.items():
        if curLV < rangLVs[0]:
            continue
        setFreePoint += (point + fabaoAddPoint + titleAddPoint) * (min(curLV, rangLVs[1]) - rangLVs[0] + 1)
    
    #¾³½çÌáÉýµãÊý
    setFreePoint += curPlayer.GetOfficialRank() * IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 3)
    return setFreePoint

def GetTitleAddExtraPoint(curPlayer):
    # ³ÆºÅ¶îÍâÔö¼ÓÍæ¼Òÿ¼¶»ñµÃµÄÁé¸ùµã
    titleID = IpyGameDataPY.GetFuncCfg("TitleAddPoint")
    if titleID and curPlayer.GetDienstgradManager().GetDienstgrad(titleID):
        return IpyGameDataPY.GetFuncCfg("TitleAddPoint", 2)
    return 0

def GetFabaoAddPoint(curPlayer):
    #·¨±¦¶îÍâÔö¼ÓÍæ¼Òÿ¼¶»ñµÃµÄÁé¸ùµã
    mwID = IpyGameDataPY.GetFuncCfg('FabaoAddPoint', 1)
    if not PlayerMagicWeapon.GetIsActiveMagicWeapon(curPlayer, mwID, lv=1):
        return 0
    return IpyGameDataPY.GetFuncCfg('FabaoAddPoint', 2)

def DoAddPointOpen(curPlayer):
    '''¼Óµã¹¦ÄÜ¿ªÆô'''
    beforeFreePoint = curPlayer.GetFreePoint()
    
    setFreePoint = GetAllPointByLV(curPlayer)
    curLV = curPlayer.GetLV()
    addDataDict = {'beforeFreePoint':beforeFreePoint}
    curPlayer.SetFreePoint(setFreePoint)
    DataRecordPack.DR_Freepoint(curPlayer, "AddPointOpen", setFreePoint, addDataDict)
    GameWorld.DebugLog('    ¼Óµã¹¦ÄÜ¿ªÆô´¦Àí  beforeFreePoint=%s,curLV=%s, setFreePoint=%s'%(beforeFreePoint, curLV, setFreePoint), curPlayer.GetID())
    return

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

## ¹¦ÄÜÄ£¿éÕ½¶·Á¦Àà
#
#  ·ÖÄ£¿é¼ÆËãÕ½¶·Á¦
class ModuleFightPower():
    
    __AttrName = "%s" # ²ÎÊýΪChConfig.Def_Calc_AllAttrType_MAX¶ÔÓ¦ËùÓÐÊôÐÔÁбíË÷Òý
    __AttrNameNoline = "Noline_%s" # ²ÎÊýΪChConfig.Def_Calc_AllAttrType_MAX¶ÔÓ¦ËùÓÐÊôÐÔÁбíË÷Òý
    __NolineAttrList = [ChConfig.TYPE_Calc_AttrSpeed] # ÐèÒª¼Ç¼µÄ·ÇÏßÐÔÕ½¶·ÊôÐÔ
    
    ## ³õʼ»¯
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks ³õʼ»¯
    def __init__(self, mfpType):
        self.mfpType = mfpType
        self.ClearAttr()
        return
            
    ## ÖØÖÃËùÓÐÊôÐÔ
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    def ClearAttr(self):
        for attrIndex in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            value = 0
            setattr(self, self.__AttrName % attrIndex, value)
        for attrIndex in self.__NolineAttrList:
            setattr(self, self.__AttrNameNoline % attrIndex, 0)            
        return
            
    ## ¸ù¾ÝÕ½¶·ÊôÐÔÁбíÉèÖüÆËãÕ½¶·Á¦ÊôÐÔ
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    def SetCalcMFPBattleAttr(self, allAttrList):
        battleAttrDict = allAttrList[ChConfig.CalcAttr_Battle]
        # ÉèÖñ¾Ä£¿éÔö¼ÓµÄÏßÐÔÕ½¶·ÊôÐÔ£¬·ÇÏßÐÔÕ½¶·ÊôÐÔÔö¼ÓµÄÔÚË¢ÊôÐÔʱÀÛ¼ÓÉÏÈ¥
        for attrIndex, value in battleAttrDict.items():
            self.AddCalcMFPAttr(attrIndex, value)
            
        # ·ÇÏßÐÔÕ½¶·ÊôÐÔ½öÉèÖÃʱ¼Ç¼¼´¿É
        battleNolineAttrDict = allAttrList[ChConfig.CalcAttr_BattleNoline]
        for attrIndex, value in battleNolineAttrDict.items():
            if attrIndex in self.__NolineAttrList:
                setattr(self, self.__AttrNameNoline % attrIndex, value)
        return
    
    ## ÉèÖüÆËãÕ½¶·Á¦ÊôÐÔÖµ
    def SetCalcMFPAttr(self, attrIndex, value):
        if 1 <= attrIndex < ChConfig.Def_Calc_AllAttrType_MAX:
            attrName = self.__AttrName % attrIndex
            setattr(self, attrName, value)
        return
            
    ## Ôö¼Ó¼ÆËãÕ½¶·Á¦ÊôÐÔ
    #  @param self ÀàʵÀý
    #  @param key ¼ÆËãÊôÐÔÀàÐÍ
    #  @param value ¼ÆËãÊôÐÔÊýÖµ
    #  @return ·µ»ØÖµÎÞÒâÒå
    def AddCalcMFPAttr(self, attrIndex, value):
        # Èç¹ûÓдæÔÚ¼ÆËãÕ½¶·Á¦ËùÐèµÄ²ÎÊýkeyÖµ£¬ÔòÔö¼ÓÉÏÈ¥
        if 1 <= attrIndex < ChConfig.Def_Calc_AllAttrType_MAX:
            attrName = self.__AttrName % attrIndex
            setattr(self, attrName, getattr(self, attrName) + value)
    
    def GetModuleFightPower(self, fpParam, curPlayer):
        MaxHP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrMaxHP) # ×î´óѪÁ¿
        MinAtk = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrATKMin) # ×îС¹¥»÷
        MaxAtk = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrATKMax) # ×î´ó¹¥»÷
        Def = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrDEF) # Îï·À
        Hit = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrHit) * fpParam.GetCftHit() # ÃüÖÐÖµ
        Miss = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrMiss) * fpParam.GetCftMiss() # ÉÁ±ÜÖµ
        AtkSpeed = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrAtkSpeed) # ¹¥»÷Ëٶȣ¨ÊýÖµ·Ç¹¥»÷¼ä¸ô£©
        SuperHitRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SuperHitRate) * fpParam.GetCftSuperHitRate() # ±©»÷ÂÊ
        SuperHitRateReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SuperHitRateReduce) * fpParam.GetCftSuperHitRateReduce() # ±©»÷¸ÅÂÊ¿¹ÐÔ
        SuperHit = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SuperHit) # ±©»÷É˺¦¹Ì¶¨Öµ
        SuperHitReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SuperHitReduce) # ±©»÷¹Ì¶¨¼õÉË
        LuckyHitRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_LuckyHitRate) * fpParam.GetCftLuckyHitRate() # »áÐÄÒ»»÷
        LuckyHitRateReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_LuckyHitRateReduce) * fpParam.GetCftLuckyHitRateReduce() # »áÐÄÒ»»÷¸ÅÂÊ¿¹ÐÔ
        LuckyHit = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_LuckyHit) # »áÐÄÒ»»÷É˺¦¹Ì¶¨Öµ
        LuckyHitReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_LuckyHitReduce) # »áÐÄÒ»»÷É˺¦¹Ì¶¨¼õÉË
        SkillAtkRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SkillAtkRate) * fpParam.GetCftSkillAtkRate() # ¼¼Äܹ¥»÷±ÈÀý¼Ó³É
        SkillAtkRateReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_SkillAtkRateReduce) * fpParam.GetCftSkillAtkRateReduce() # ¼¼Äܹ¥»÷±ÈÀý¼õÉÙ
        DamagePVP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePVP)  # PVP¹Ì¶¨É˺¦
        DamagePVPReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePVPReduce)  # PVP¹Ì¶¨¼õÉË
        DamagePVE = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePVE)  # PVE¹Ì¶¨É˺¦
        HPRestore = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_HPRestorePer) # ×Ô¶¯»Ø¸´ÑªÁ¿£¬¹Ì¶¨Öµ
        DamBackPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamBackPer) * fpParam.GetCftDamBackPer() # ·´ÉË°Ù·Ö±È
        SpeedValue = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrSpeed) # Òƶ¯ËÙ¶ÈÖµ
        SpeedPer = 0#getattr(self, self.__AttrNameNoline % ChConfig.TYPE_Calc_AttrSpeed) * fpParam.GetCftSpeedPer() # Òƶ¯ËٶȰٷֱÈϵÊý
        PetMinAtk = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_PetMinAtk) # ³èÎï×îС¹¥»÷
        PetMaxAtk = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_PetMaxAtk) # ³èÎï×î´ó¹¥»÷
        PetDamPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_PetDamPer) # ³èÎïÉ˺¦°Ù·Ö±ÈÌáÉý
        IceAtk = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrIceAtk) # ±ù¹¥, ÔªËع¥»÷
        IceDef = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AttrIceDef) # ±ù·À, ÔªËØ·ÀÓù
        IgnoreDefRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_IgnoreDefRate) * fpParam.GetCftIgnoreDefRate() # ÎÞÊÓ·ÀÓù¼¸ÂÊ
        IgnoreDefRateReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_IgnoreDefRateReduce) * fpParam.GetCftIgnoreDefRateReduce() # ÎÞÊÓ·ÀÓù¸ÅÂÊ¿¹ÐÔ
        DamChanceDef = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamChanceDef) * fpParam.GetCftDamChanceDef() # 20%µÄ¸ÅÂʵÖÓùÉ˺¦±ÈÂÊ
        BleedDamage = 0#getattr(self, self.__AttrName % ChConfig.TYPE_Calc_BleedDamage) * fpParam.GetCftBleedDamage() # Á÷ѪÉ˺¦
        AtkBackHP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AtkBackHPPer) # ¹¥»÷»Ø¸´ÑªÁ¿
        FaintRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FaintRate) * fpParam.GetCftFaintRate() # ´¥·¢»÷ÔÎ
        FaintDefRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FaintDefRate) * fpParam.GetCftFaintDefRate() # »÷Ôεֿ¹
        FinalHurt = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FinalHurt) # ×îÖչ̶¨É˺¦Ôö¼Ó
        FinalHurtReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FinalHurtReduce) # ×îÖչ̶¨É˺¦¼õÉÙ
        BossFinalHurtPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_BossFinalHurtPer) * fpParam.GetCftBossFinalHurtPer() # Boss×îÖÕÉ˺¦Íò·ÖÂÊ
        FinalHurtPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FinalHurtPer) * fpParam.GetCftFinalHurtPer() # ×îÖÕÉ˺¦Íò·ÖÂÊ
        FinalHurtReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FinalHurtReducePer) * fpParam.GetCftFinalHurtReducePer() # ×îÖÕÉ˺¦¼õÉÙÍò·ÖÂÊ
        DamagePerPVP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePerPVP) * fpParam.GetCftDamagePerPVP() # É˺¦Êä³ö¼ÆËã°Ù·Ö±ÈPVP
        DamagePerPVPReduce = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_DamagePerPVPReduce) * fpParam.GetCftDamagePerPVPReduce() # É˺¦Êä³ö¼ÆËã°Ù·Ö±ÈPVP¼õÉÙ
        JobAHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobAHurtAddPer) * fpParam.GetCftJobAHurtAddPer() # ¶ÔÄ¿±êսʿÉ˺¦¼Ó³É
        JobBHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobBHurtAddPer) * fpParam.GetCftJobBHurtAddPer() # ¶ÔÄ¿±ê·¨Ê¦É˺¦¼Ó³É
        JobCHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobCHurtAddPer) * fpParam.GetCftJobCHurtAddPer() # ¶ÔÄ¿±ê¹­¼ýÉ˺¦¼Ó³É
        JobAAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobAAtkReducePer) * fpParam.GetCftJobAAtkReducePer() # սʿ¹¥»÷É˺¦¼õÃâ
        JobBAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobBAtkReducePer) * fpParam.GetCftJobBAtkReducePer() # ·¨Ê¦¹¥»÷É˺¦¼õÃâ
        JobCAtkReducePer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_JobCAtkReducePer) * fpParam.GetCftJobCAtkReducePer() # ¹­¼ý¹¥»÷É˺¦¼õÃâ
        AffairSpeedPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_AffairSpeedPer) * fpParam.GetCftAffairSpeedPer() # ÏÉÃËÊÂÎñËٶȼӳÉ
        FamilyBossHurtPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FamilyBossHurtPer) * fpParam.GetCftFamilyBossHurtPer() # ÏÉÃËBOSSÉ˺¦¼Ó³É
        FamilyWarHPPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FamilyWarHPPer) * fpParam.GetCftFamilyWarHPPer() # ÏÉÃËÁªÈüÉúÃü¼Ó³É
        FamilyWarAtkPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FamilyWarAtkPer) * fpParam.GetCftFamilyWarAtkPer() # ÏÉÃËÁªÈü¹¥»÷¼Ó³É
        FamilySitExpPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FamilySitExpPer) * fpParam.GetCftFamilySitExpPer() # ÏÉÃË´ò×ø¾­Ñé¼Ó³É
        
        NormalHurt = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_NormalHurt) 
        NormalHurtPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_NormalHurtPer) * fpParam.GetCftNormalHurtPer() # ÆÕͨ¸½¼ÓÉ˺¦¼Ó³É
        FabaoHurt = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FabaoHurt)
        FabaoHurtPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_FabaoHurtPer) * fpParam.GetCftFabaoHurtPer() # ·¨±¦¸½¼ÓÉ˺¦¼Ó³É
        Luck = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_Luck)
        
        ComboRate = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ComboRate) # Á¬»÷¼¸ÂÊ
        ComboDamPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ComboDamPer) # Á¬»÷É˺¦
        #MaxProDef = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_MaxProDef) # ×î´ó·À»¤Öµ
        #ProDefAbsorb = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ProDefAbsorb) # ·À»¤ÖµÎüÊÕÉ˺¦±ÈÂÊ
        ProDefPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_ProDefHPPer) # ·À»¤×ª»¯°Ù·Ö±È
        
        OnlyFinalHurt = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_OnlyFinalHurt) # ¶îÍâÊä³öÉ˺¦
        PVPAtkBackHP = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_PVPAtkBackHP) # PVP¹¥»÷»ØѪ
        NPCHurtAddPer = getattr(self, self.__AttrName % ChConfig.TYPE_Calc_NPCHurtAddPer) * fpParam.GetCftNPCHurtAddPer() # ¶Ô¹ÖÎïÉ˺¦¼Ó³É
        
        #ÆäËûÐè×÷Ϊ¹«Ê½²ÎÊýµÄϵÊý
        AtkSpeedParameter = fpParam.GetCftAtkSpeed()
        LuckyHitParameter = 0#fpParam.GetCftLuckyHit()
        
        #È¡×ÜÊôÐÔµÄ
        SuperHitRateTotal = curPlayer.GetSuperHitRate()
        LuckyHitRateTotal = curPlayer.GetLuckyHitRate()
        
        job = curPlayer.GetJob()
        diffAttrDict = self.__GetAttrFightPowerParamDiff(job)
        for paramName, diffValue in diffAttrDict.items():
            exec("%s = max(0, %s - %s)" % (paramName, paramName, diffValue))
            
        #»ñÈ¡²ß»®ÅäÖõıí¸ñ
        FightpowerFormula = IpyGameDataPY.GetFuncCfg("FightpowerFormula")
        totalFightPower = eval(FormulaControl.GetCompileFormula("FightpowerFormula", FightpowerFormula))
        
        #GameWorld.DebugLog("MfpType=%s,FightPower=%s, %s" % (self.mfpType, totalFightPower, self.GetMFPAttrStr()))
        if totalFightPower > ShareDefine.Def_UpperLimit_DWord:
            GameWorld.ErrLog("Ä£¿éÕ½Á¦³¬¹ýÊýÖµÉÏÏÞ, MfpType=%s,fightPower=%s, %s" % (self.mfpType, totalFightPower, self.GetMFPAttrStr()))
            totalFightPower = ShareDefine.Def_UpperLimit_DWord
        return totalFightPower
        
    def __GetAttrFightPowerParamDiff(self, job):
        ## Õ½Á¦¼ÆËãÊôÐÔ²ÎÊýÓëʵ¼ÊÊôÐÔ²îÖµ
        
        #½ÇÉ«»ù´¡Ä£¿éijЩÊôÐÔ²»¼ÆËãÕ½Á¦
        if self.mfpType != ShareDefine.Def_MFPType_Role:
            return {}
        
        roleBaseAttrDict = IpyGameDataPY.GetFuncEvalCfg("CreatRoleBaseAttr", 1)
        notFightPowerEffIDNameDict = IpyGameDataPY.GetFuncEvalCfg("CreatRoleBaseAttr", 2)
        if job not in roleBaseAttrDict:
            return {}
        
        diffAttrDict = {}
        jobBaseAttrDict = roleBaseAttrDict[job]
        for attrID, paramName in notFightPowerEffIDNameDict.items():
            if attrID not in jobBaseAttrDict:
                continue
            diffAttrDict[paramName] = jobBaseAttrDict[attrID]
        return diffAttrDict
    
    def GetMFPAttrStr(self):
        attrStr = ""
        for attrIndex in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            attrName = self.__AttrName % attrIndex
            attrValue = getattr(self, attrName)
            if attrValue <= 0:
                continue
            
            attrStr += "%s=%s," % (attrName, attrValue)
            
        for attrIndex in self.__NolineAttrList:
            attrName = self.__AttrNameNoline % attrIndex
            attrValue = getattr(self, attrName)
            if attrValue <= 0:
                continue
            
            attrStr += "%s=%s," % (attrName, attrValue)
        return attrStr

###############################################################
#ÈËÎï¿ØÖÆÀà

## ÈËÎï¿ØÖÆÀà
#
#  ÈËÎïËÀÍöµÈÂß¼­´¦Àí
class PlayerControl:
    __Player = None
    __fpTypeObjDict = {}
    #---------------------------------------------------------------------
    ## ³õʼ»¯
    #  @param self ÀàʵÀý
    #  @param iPlayer Íæ¼ÒʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks ³õʼ»¯
    def __init__(self, iPlayer):
        self.__Player = iPlayer
    
    ## »ñÈ¡Ä£¿éÕ½¶·Á¦¶ÔÏó
    #  @param self ÀàʵÀý
    #  @param fpType Õ½¶·Á¦ÀàÐÍ
    #  @return ·µ»ØÕ½¶·Á¦¶ÔÏó
    def GetModuleFightPowerObj(self, fpType):
        fpObj = self.__fpTypeObjDict.get(fpType)
        if not fpObj:
            fpObj = ModuleFightPower(fpType)
            self.__fpTypeObjDict[fpType] = fpObj
        return fpObj
    
    ## »ñÈ¡Ä£¿éÕ½¶·Á¦¶ÔÏó
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÕ½¶·Á¦¶ÔÏó
    def ResetFightPowerObj(self):
        for obj in self.__fpTypeObjDict.values():
            obj.ClearAttr()
    
    #---------------------------------------------------------------------
    ## Íæ¼ÒÉý¼¶¼Óµã¼Ó¼¼ÄÜ Ç°20¼¶×Ô¶¯¼Óµã 20¼¶ºó ÒÔÇ°ÊǼӼ¼ÄܵãÏָijÉÖ±½ÓÉý¼¶ºó¶Á±í¼Ó¼¼ÄÜ
    #  @param self ÀàʵÀý
    #  @return None
    #  @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)
        if addPoint != 0:
            setFreePoint = curFreePoint + addPoint
            #NotifyCode(curPlayer, "ObtainAttributeDot", [addPoint])
            
            DataRecordPack.DR_Freepoint(curPlayer, "LvUP", addPoint)
            curPlayer.SetFreePoint(setFreePoint)

        return
    #---------------------------------------------------------------------
    ## ¼ì²éÍæ¼ÒÊÇ·ñÐèÒª·â¾ô
    #  @param self ÀàʵÀý
    #  @param curPlayer Íæ¼ÒʵÀý
    #  @param curLV µ±Ç°µÈ¼¶
    #  @return ·µ»ØÖµÕæ, ÐèÒª
    #  @remarks ¼ì²éÍæ¼ÒÊÇ·ñÐèÒª·â¾ô
    def __LVUpDoInvestiture(self, curPlayer, curLV):
#===============================================================================
#        ´ËÂß¼­²»ÄÜÓà GetTotalExp, 
#        ¸Ä¶¯ÇëÉ÷ÖØ!
#===============================================================================
        #1. ¼ì²éÍæ¼ÒÊÇ·ñÔÚ·â¾ôµÈ¼¶
        if curLV < 20 or curLV % 10 != 0:
            return False
        
        curMission = curPlayer.FindMission(curLV * 100)
        if curMission != None and curMission.GetState() == ChConfig.Def_Mission_State_Over:
            #ÈÎÎñÍê³É
            return False
            
        if curMission == None:
            #2. Èç¹ûÔÚ·â¾ôµÈ¼¶, ²¢ÇÒ¼´½«Éýµ½ÏÂÒ»¼¶, ´¥·¢·â¾ôÈÎÎñ
            if EventShell.EventResponse_LVFull(curPlayer) != True:
                GameWorld.Log("´¥·¢·â¾ôÈÎÎñʧ°Ü", curPlayer.GetPlayerID())
                return False
            
        return True
    
    #---------------------------------------------------------------------
    
    ## ¼Ó¾­ÑéÖµ 
    #  @param self ÀàʵÀý
    #  @param addExp Ìí¼ÓµÄ¾­Ñé
    #  @param exp_rate ¾­Ñ鱶ÂÊ
    #  @param expViewType ¾­Ñé»ñµÃµÄÇþµÀ
    #  @param isSysHint ÊÇ·ñϵͳÌáʾ£¨Ä¬ÈÏÊÇ£©
    #  @return ²¼¶ûÖµ
    def AddExp(self, addExp, expViewType=ShareDefine.Def_ViewExpType_Mission, isSysHint=True, addSkillID=0, expRateEx=0):
        curPlayer = self.__Player
        finalAddExp, expNotifyType = self.__AddExp(curPlayer, addExp, expViewType, isSysHint, addSkillID, expRateEx)
        
        # ֪ͨ¿Í»§¶Ë¾­ÑéÀ´Ô´
        if finalAddExp:
            sendPack = ChPyNetSendPack.tagMCAddExp()
            sendPack.ExpPoint = finalAddExp / ChConfig.Def_PerPointValue
            sendPack.Exp = finalAddExp % ChConfig.Def_PerPointValue
            sendPack.Source = expNotifyType # ¿Í»§¶ËչʾÓÃ
            NetPackCommon.SendFakePack(curPlayer, sendPack)
            
        #¸±±¾»ñµÃ¾­Ñé, ÎÞÂÛ»ñµÃ¶àÉÙ¾­Ñé¾ùÐè֪ͨ, ÓÐЩ¸±±¾Âß¼­ÐèҪͨ¹ý»ñµÃ¾­Ñéʱ»ú´¦Àí
        if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
            FBLogic.OnGetExp(curPlayer, finalAddExp, expViewType)
            
        return finalAddExp
    
    # ²ÎÊý addSkillID ±íʾÒòʲô¼¼ÄÜɱËÀNPC»ñµÃ¾­Ñé
    def __AddExp(self, curPlayer, addExp, expViewType, isSysHint, addSkillID=0, expRateEx=0):
        if addExp == 0:
            # ²»½øÈë¼ÆËã
            return addExp, expViewType
        
        #È¡µÃÈËÎﵱǰ¾­Ñé
        #curTotalExp = GetPlayerTotalExp(curPlayer)
        curTotalExp = curPlayer.GetExpPoint() * ChConfig.Def_PerPointValue + curPlayer.GetTotalExp()

        maxLV = GetPlayerMaxLV(curPlayer)
        maxLVExpStore = IpyGameDataPY.GetFuncCfg("MaxLVExpStore", 1)
        
        curLV = curPlayer.GetLV()            
#        # ¼ì²éתÉúµÈ¼¶
#        if curLV >= nextReinLV and curTotalExp >= maxLVExpStore:
#            self.__NotifyExpFull(curPlayer, "GeRen_liubo_260986")
#            GameWorld.DebugLog("¾­ÑéÒÑÂú£¡ÐèÏÈתÉú£¡curLV=%s,reinLV=%s" % (curLV, nextReinLV), curPlayer.GetPlayerID())
#            return 0

        # ¼ì²é×î´óµÈ¼¶£¬maxLVExpStore -1ʱ²»ÏÞÀۼƾ­ÑéÉÏÏÞ
        if curLV >= maxLV and curTotalExp >= maxLVExpStore and maxLVExpStore != -1:
            self.__NotifyExpFull(curPlayer, "GeRen_admin_825676")
            GameWorld.DebugLog("¾­ÑéÒÑÂú£¡ÒÑÂú¼¶£¡curLV=%s,maxLV=%s,curTotalExp=%s >= maxLVExpStore=%s" % (curLV, maxLV, curTotalExp, maxLVExpStore), curPlayer.GetPlayerID())
            return 0, expViewType
        
        # ɱ¹Ö
        if expViewType == ShareDefine.Def_ViewExpType_KillNPC:
            exp_rate = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TotalExpRate)
            superRate = PassiveBuffEffMng.GetPassiveSkillValueByTriggerType(curPlayer, None, None, ChConfig.TriggerType_AddExpRate)
            if superRate:
                # Áú·ïïí ¾­Ñé
                expViewType = ShareDefine.Def_ViewExpType_KillNPCSuper
            if addSkillID == ChConfig.Def_SkillID_LXHY_AddExpRate:
                addSkill = GameWorld.GetGameData().GetSkillBySkillID(addSkillID)
                hasEffect = SkillCommon.GetSkillEffectByEffectID(addSkill, ChConfig.Def_Skill_Effect_AddExpRate)
                if hasEffect:
                    #ÁÒÑæÕ½Éñ ¾­Ñé
                    superRate += hasEffect.GetEffectValue(0)
                    expViewType = ShareDefine.Def_ViewExpType_LYZS
            exp_rate += superRate
                
        elif expViewType in [ShareDefine.Def_ViewExpType_GameEvent, ShareDefine.Def_ViewExpType_Sit]:
            exp_rate = curPlayer.GetGameEventExpRate()
            exp_rate += GetFamilySitExpPer(curPlayer)
        else:
            exp_rate = max(GameWorld.GetGameWorld().GetExpRate(), ChConfig.Def_MaxRateValue)
                        
        exp_rate += expRateEx
        #ÊäÈëµÄ¾­ÑéÓпÉÄÜΪlongÐÍ
        addExp = int(addExp * exp_rate / float(ChConfig.Def_MaxRateValue))
        
        #·À³ÁÃÔ¼ÆËã
        addExp = PlayerGameWallow.ChangeExpByWallow(curPlayer, addExp)
        
        #===========================================================================================
        # #ÌØÊâµØͼɱ¹Ö¾­ÑéÍâ²ã¼Ó³É
        # if expViewType == ShareDefine.Def_ViewExpType_KillNPC:
        #    #mapID = GameWorld.GetMap().GetMapID()
        #    #if mapID in ChConfig.Def_FBMapID_BZZDAll:
        #    #    nobleVIPOuterRate = ...
        #    #    #nobleVIPAddExp += 0 if not nobleVIPOuterRate else int(addExp * nobleVIPOuterRate / float(ChConfig.Def_MaxRateValue))
        #    #    nobleVIPAddExp += nobleVIPOuterRate
        #    
        #    outerExpRate = FBLogic.OnGetOuterExpRate(curPlayer)
        #    if outerExpRate > 0:
        #        addExp = int(addExp * outerExpRate / float(ChConfig.Def_MaxRateValue))
        #===========================================================================================
        
        # ²»¿ÉÔÙÉý¼¶Ê±£¬Ôö¼ÓºóµÄ¾­Ñé²»¿É³¬¹ý×î´ó¿É´æ´¢¾­Ñé
        #if curLV >= nextReinLV or curLV >= maxLV:
        if curLV >= maxLV and maxLVExpStore > 0:
            addExp = min(addExp, max(0, maxLVExpStore - curTotalExp))

        if addExp <= 0:
            #ÎÞ·¨»ñµÃ¾­Ñé
            GameWorld.DebugLog("ÎÞ·¨»ñµÃ¾­Ñé")
            return 0, expViewType
        
        #addExp = min(addExp, ChConfig.Def_UpperLimit_DWord) # µ¥´Î¼Ó¾­Ñé²»³¬¹ý20ÒÚ

        #»º´æ»ñÈ¡µÄ¾­ÑéÖµ, ÓÃÓÚ¶Ò»»¼Ò×åÈÙÓþ
        #if curPlayer.GetFamilyID() != 0:
        #    curPlayer.SetPerExp(min(curPlayer.GetPerExp() + addExp, ChConfig.Def_UpperLimit_DWord))

        #ÈËÎïÍ·¶¥Ìáʾ
        #=======================================================================
        # viewExpCnt = min(2, addExp / ChConfig.Def_UpperLimit_DWord) # ×î¶àÆ®Á½´Î20ÒÚµÄ
        # viewExp = addExp % ChConfig.Def_UpperLimit_DWord
        # for _ in range(viewExpCnt):
        #    curPlayer.Notify_GetExpView(ChConfig.Def_UpperLimit_DWord, expViewType)
        # if viewExp:
        #    curPlayer.Notify_GetExpView(viewExp, expViewType)
        # 
        # if isSysHint:
        #    # ɱ¹Ö¸½¼Ó¼Ó³ÉÏÔʾ
        #    if expViewType == ShareDefine.Def_ViewExpType_KillNPC:
        #        nobleVIPAddExp = int(nobleVIPAddExp / 100.0)
        #        #NotifyCode(curPlayer, "GeRen_liubo_74717", [addExp, nobleVIPAddExp])
        #    elif expViewType in [ShareDefine.Def_ViewExpType_GameEvent,
        #                         ShareDefine.Def_ViewExpType_Sit]:
        #        #СÓÎϷʼþÌØÊâÌáʾ,´ò×ø»ñÈ¡¾­Ñé
        #        NotifyCode(curPlayer, "ObtainExperience", [addExp])
        #    elif expViewType == ShareDefine.Def_ViewExpType_MousePos:
        #        #Êó±êλÖÃÌáʾ»ñµÃ¾­Ñé
        #        NotifyCode(curPlayer, "GeRen_admin_887936", [addExp])
        #    else:
        #        #Õý³£ÐÅÏ¢Ìáʾ
        #        NotifyCode(curPlayer, "GeRen_lhs_0", [addExp])
        #=======================================================================
                
        #¸øÈËÎï¾­Ñé ÏÈÉè¾­ÑéºóÉý¼¶
        #SetPlayerTotalExp(curPlayer, curTotalExp + addExp)
        totalExp = curTotalExp + addExp
        curExp = totalExp % ChConfig.Def_PerPointValue
        expPoint = totalExp / ChConfig.Def_PerPointValue
        
        if curPlayer.GetExpPoint() != expPoint:
            curPlayer.SetExpPoint(expPoint)
        if curPlayer.GetTotalExp() != curExp:
            curPlayer.SetTotalExp(curExp)
        
        #GameWorld.Log("Íæ¼Ò = %s µÃµ½¾­Ñé = %s ,µ±Ç°¾­Ñ鱶ÂÊ = %s"%(curPlayer.GetName(), addExp,expRate ))
        #СÓÚתÉúµÈ¼¶²Å¿ÉÉý¼¶
        #if curLV < nextReinLV and curLV < maxLV:
        if curLV < maxLV:
            self.PlayerLvUp()
        
        #Ìí¼Ó¾­Ñé³É¹¦
        return addExp, expViewType
    
    ## ¾­ÑéÂúÌáʾ
    def __NotifyExpFull(self, curPlayer, expFullNotifyMark):
        expFullNotifyState = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ExpFullNotify)
        if not expFullNotifyState:
            NotifyCode(curPlayer, expFullNotifyMark)
            curPlayer.SetDict(ChConfig.Def_PlayerKey_ExpFullNotify, 1)
        return
    
    ## ÈËÎïÉý¼¶ »ØÂúѪ »ØÂúħ£¬´¥·¢Ìí¼Ó¼¼ÄÜ£¬ÈÎÎñ£¬¼ÓÊôÐԵ㣨ԭÀ´²¿·Öº¯Êý²Ù×÷·ÅÔÚ¼Ó¾­ÑéÖÐ ÏÖÔÚÌá³öÀ´£©
    #  @param handLvUp: ÊÇ·ñÊÇÊÖ¶¯Éý¼¶
    #  @return: None
    #  @remarks: Èç¹ûÊÇ×Ô¶¯Éý¼¶²»¸ø²ÎÊý ¶øÈç¹ûÊÇÊÖ¶¯Éý¼¶ÐèÒª¸ø²ÎÊý ÊÇÊÖ¶¯Éý¼¶ True 
    #  1-20¼¶×Ô¶¯Éý¼¶Ö±½Ó¼Óµã Ö®ºó±ØÐëÊÖ¶¯Éý¼¶ ¸ø×ÔÓÉÊôÐÔµã
    def PlayerLvUp(self, handLvUp=False):
        curPlayer = self.__Player
        
        if GameObj.GetHP(curPlayer) <= 0:
            #Íæ¼ÒËÀÍö²»¿ÉÉý¼¶
            return
        
        #lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
        lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", curPlayer.GetLV())
        if not lvIpyData:
            GameWorld.ErrLog("¾­Ñé±íÒì³£  lv= %s" % curPlayer.GetLV())
            return
        
        #lvUpNeedExp = GetLVUPTotalExpNeed(lvIpyData)
        lvUpNeedExp = lvIpyData.GetExpPoint() * ChConfig.Def_PerPointValue + lvIpyData.GetExp()
        
        if lvUpNeedExp <= 0:
            return
        
        #Ôö¼Ó¾­Ñé
        #curTotalExp = GetPlayerTotalExp(curPlayer)
        curTotalExp = curPlayer.GetExpPoint() * ChConfig.Def_PerPointValue + curPlayer.GetTotalExp()
        #δ´ïµ½Éý¼¶¾­Ñé
        if curTotalExp < lvUpNeedExp:
            return
        needSyncTalentPoint = False
        playerNeedDoLVUp = False
        curLV = curPlayer.GetLV()
        maxLV = GetPlayerMaxLV(curPlayer)
        
        curPlayer.BeginRefreshState()
        #befXP = curPlayer.GetXP()
        befLV = curPlayer.GetLV()
        befFreePoint = curPlayer.GetFreePoint()
        befBaseSTR = curPlayer.GetBaseSTR()
        befBasePNE = curPlayer.GetBasePNE()
        befBasePHY = curPlayer.GetBasePHY()
        befBaseCON = curPlayer.GetBaseCON()
        
        #Éý¼¶Ç°µÄÊÀ½çµÈ¼¶¾­Ñé
        #beforeExpRate = PlayerWorldAverageLv.GetWorldAverageLvExpRate(curPlayer)
        
        while curTotalExp >= lvUpNeedExp and curLV < maxLV:
            
            playerNeedDoLVUp = True
            
            #---ÈËÎïÉý¼¶³É¹¦---
            curLV = curLV + 1
            
            isNotifyServer = True
            if curLV < 50:
                # ¼õÉÙÇ°ÆڵĹ㲥£¬³ÌÐò¿ØÖÆ
                isNotifyServer = False
            
            curPlayer.SetLV(curLV, isNotifyServer)
            EventReport.WriteEvent_level_up(curPlayer)
                       
            # ¼Ç¼Íæ¼ÒÉý¼¶
            DataRecordPack.DR_PlayerUpgrade(curPlayer, curPlayer.GetLV(), GetPlayerTotalExp(curPlayer), lvUpNeedExp)
            DataRecordPack.Cache_FightPowerChangeInfo(curPlayer, ChConfig.PowerDownType_LVUP, {'lv':curLV})
            self.__GiveLVMailAward(curLV)
            self.__DoLVUPAddPoint()  # Éý¼¶¼Óµã
            #self.__DoLvUpAddSkill()  # Éý¼¶¼Ó¼¼ÄÜ
            
            lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
            # ´óʦÌ츳µã
            if lvIpyData:
                addTalentPoint = lvIpyData.GetTalentPoint()
                if addTalentPoint:
                    needSyncTalentPoint = True
                    PlayerGreatMaster.AddGreatMasterSkillPointByLV(curPlayer, addTalentPoint)
            
            EventShell.EventResponse_LVUp(curPlayer)  # Éý¼¶´¥·¢Ê¼þ
            
            PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_LVUp, 1)
            #---ÊÇ·ñ¼ÌÐøÑ­»·---
            curTotalExp = curTotalExp - lvUpNeedExp
            
            #»ñµÃÏÂÒ»¼¶µÄ¾­Ñé±í
            lvUpNeedExp = GetLVUPTotalExpNeed(lvIpyData)
            
            if lvUpNeedExp <= 0:
                break
            
        curPlayer.EndRefreshState() # ½áÊøˢкó£¬Óбä¸üµÄÊôÐÔҪ֪ͨ¿Í»§¶ËµÄÐèÖØÐÂÉèÖÃÒ»´Î
        #---------------------------------------------------
        #ÓÐÉý¼¶, תÉúʱ¸ÕºÃÊÇתÉúµÈ¼¶»áĬÈÏ+1¼¶
        if playerNeedDoLVUp:
            aftLV = curPlayer.GetLV()
            aftFreePoint = curPlayer.GetFreePoint()
            aftBaseSTR = curPlayer.GetBaseSTR()
            aftBasePNE = curPlayer.GetBasePNE()
            aftBasePHY = curPlayer.GetBasePHY()
            aftBaseCON = curPlayer.GetBaseCON()
            if aftLV > befLV:
                curPlayer.SetLV(aftLV, False) # ÕâÀï²»ÔÙ֪ͨGameServer
                PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_HeroLV, aftLV)
                PlayerActivity.DoAddActivityByLV(curPlayer, befLV, aftLV)
                
            if aftFreePoint > befFreePoint:
                curPlayer.SetFreePoint(aftFreePoint)
                #NotifyCode(curPlayer, "ObtainAttributeDot", [aftFreePoint - befFreePoint])
            if aftBaseSTR > befBaseSTR:
                curPlayer.SetBaseSTR(aftBaseSTR)
            if aftBasePNE > befBasePNE:
                curPlayer.SetBasePNE(aftBasePNE)
            if aftBasePHY > befBasePHY:
                curPlayer.SetBasePHY(aftBasePHY)
            if aftBaseCON > befBaseCON:
                curPlayer.SetBaseCON(aftBaseCON)
            PlayerGubao.DoGubaoAddFreePoint(curPlayer)
            #===================================================================
            # if curPlayer.GetXP() != befXP:
            #    curPlayer.SetXP(curPlayer.GetXP())
            #===================================================================
                
            #ÏíÊÜÊÀ½çµÈ¼¶
            #===================================================================
            #curExpRate = PlayerWorldAverageLv.GetWorldAverageLvExpRate(curPlayer)
            #if beforeExpRate <= 0 and curExpRate > 0:
            #    NotifyCode(curPlayer, "GeRen_liubo_127574")
            
            #===================================================================
            # Ì츳µã֪ͨ
            if needSyncTalentPoint:
                PlayerGreatMaster.Sync_GreatMasterFreeSkillPoint(curPlayer)
            # Éý¼¶ÐèÒªÖ´ÐеÄÓÎÏ·¹¦ÄÜ´¦Àí
            GameFuncComm.DoFuncOpenLogic(curPlayer)
            ChEquip.RefreshPlayerLingQiEquipAttr(curPlayer) # ÁéÆ÷ÊôÐÔ»áËæµÈ¼¶³É³¤
            if aftLV%10 == 0:
                # ¿ØÖÆÏÂˢдÎÊý
                PlayerPet.CalcPetItemAddPlayerAttr(curPlayer)   # ³èÎïÓÐËæµÈ¼¶±ä»¯µÄ¼¼ÄÜ
            
            self.RefreshPlayerAttrState(billboardFunc=PlayerBillboard.UpdatePlayerLVBillboard)
            #·ÅÔÚ¹¦ÄÜ¿ªÆôºóÃæ
            PlayerWorldAverageLv.UpdatePlayerWorldAverageLv(curPlayer)
            #½«ÑªÉèÖÃΪ×î´ó
            GameObj.SetHPFull(curPlayer)
            if curPlayer.GetMaxMP() > 0:
                curPlayer.SetMP(curPlayer.GetMaxMP())
            
            FBLogic.OnPlayerLVUp(curPlayer)
            # ¼Ç¼¿ª·þ»î¶¯³å¼¶Êý¾Ý
            #OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_LV, curPlayer.GetLV())
            #ÉñÃØÏÞ¹º
            FunctionNPCCommon.MysticalLimitShopOpen(curPlayer, befLV, aftLV)

        #²»ÐèÒª×öÉý¼¶ÈÎÎñ, ÉèÖÃÍæ¼Ò¾­Ñé
        SetPlayerTotalExp(curPlayer, curTotalExp) 
        return
    
    def __GiveLVMailAward(self, curLV):
        # ¸øµÈ¼¶Óʼþ½±Àø
        mailLVAwardDict = IpyGameDataPY.GetFuncEvalCfg("MailLVAward", 1, {})
        if curLV not in mailLVAwardDict:
            return
        mailTypeKey, mailItemList = mailLVAwardDict[curLV]
        curPlayer = self.__Player
        SendMailByKey(mailTypeKey, [curPlayer.GetPlayerID()], mailItemList, [curLV])
        return
    
    #---------------------------------------------------------------------

    def CalcRoleBaseAttr(self, curPlayer):
        # ¼ÆËãÍæ¼Ò½ÇÉ«»ù´¡ÊôÐÔÖµ
        
        curPlayerID = curPlayer.GetID()
        job = curPlayer.GetJob()
        
        lvAttrDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAttr%s" % job, 1)
        
        if not lvAttrDict:
            GameWorld.ErrLog('ÎÞ´ËÖ°ÒµµÈ¼¶Ë¢ÊôÐÔÅäÖÃ!job=%s' % (job), curPlayerID)
            return
        
        allAttrList = [{} for _ in range(4)]
        
        # Ö°Òµ³õʼÊôÐÔ
        roleBaseAttrDict = IpyGameDataPY.GetFuncEvalCfg("CreatRoleBaseAttr", 1)
        if job in roleBaseAttrDict:
            for roleBaseAttrID, value in roleBaseAttrDict[job].items():
                CalcAttrDict_Type(roleBaseAttrID, value, allAttrList)
        #GameWorld.DebugLog("³õʼ¼ÓÊôÐÔ: %s" % allAttrList)
                
        # µÈ¼¶³É³¤ÊôÐÔ
        LV = curPlayer.GetLV()
        for lvAttrID, formula in lvAttrDict.items():
            calcValue = eval(FormulaControl.GetCompileFormula("LVUPAttr%s_%s" % (job, lvAttrID), formula))
            CalcAttrDict_Type(lvAttrID, calcValue, allAttrList)
            #GameWorld.DebugLog("    lvAttrID=%s,calcValue=%s" % (lvAttrID, calcValue))
        #GameWorld.DebugLog("µÈ¼¶¼ÓÊôÐÔ: %s" % allAttrList)
        
        # ÊôÐÔµãÊôÐÔ
        hadRefreshAttr = curPlayer.GetDictByKey(ChConfig.Def_Player_HadRefreshAttr) # ±¾µØͼÊÇ·ñˢйýÊôÐÔ
        pointFightPowerEx = 0
        pointValueInfo = {ShareDefine.Def_Effect_Metal:[lambda curObj:GetMetal(curObj), lambda curObj, value:SetMetalQualityLV(curObj, value), lambda curObj:GetMetalQualityLV(curObj)],
                          ShareDefine.Def_Effect_Wood:[lambda curObj:GetWood(curObj), lambda curObj, value:SetWoodQualityLV(curObj, value), lambda curObj:GetWoodQualityLV(curObj)],
                          ShareDefine.Def_Effect_Water:[lambda curObj:GetWater(curObj), lambda curObj, value:SetWaterQualityLV(curObj, value), lambda curObj:GetWaterQualityLV(curObj)],
                          ShareDefine.Def_Effect_Fire:[lambda curObj:GetFire(curObj), lambda curObj, value:SetFireQualityLV(curObj, value), lambda curObj:GetFireQualityLV(curObj)],
                          ShareDefine.Def_Effect_Earth:[lambda curObj:GetEarth(curObj), lambda curObj, value:SetEarthQualityLV(curObj, value), lambda curObj:GetEarthQualityLV(curObj)],
                          }
        hasChange_Qualitylv = False #Áé¸ùÆ·¼¶ÊÇ·ñÓбä¸ü
        lingGenQualityAttrList = [{} for _ in range(4)]
        for pointAttrID, pointFuncInfo in pointValueInfo.items():
            pointValue = pointFuncInfo[0](curPlayer)
            befPQLV = pointFuncInfo[2](curPlayer)
            pointFuncInfo[1](curPlayer, 0)
            if not pointValue:
                if 0 != befPQLV:
                    hasChange_Qualitylv = True
                continue
            ipyData = IpyGameDataPY.GetIpyGameData("RolePoint", pointAttrID)
            if not ipyData:
                continue
            # ÿµãÊôÐÔ
            perPointAddAttrDict = ipyData.GetAddAttrInfoPerPoint() # {"Ö°Òµ":[[ÿXµã,ÊôÐÔID,Öµ], ...], ..}
            addAttrList = perPointAddAttrDict.get(str(job), [])
            for needPoint, pointAddAttrID, pointAddAttrValue in addAttrList:
                pointAddValueTotal = pointAddAttrValue * (pointValue / needPoint)
                CalcAttrDict_Type(pointAddAttrID, pointAddValueTotal, allAttrList)
                #GameWorld.DebugLog("    ÊôÐÔµã(%s)¼ÓÊôÐÔ: pointValue=%s,pointAddAttrID=%s,pointAddValueTotal=%s" % (pointAttrID, pointValue, pointAddAttrID, pointAddValueTotal))
                
            pointFightPowerEx += (ipyData.GetFightPowerPerPoint() * pointValue)
            
            # µãÊýÆ·ÖÊÊôÐÔ
            curPQLV = 0
            pqIntervalList = ipyData.GetPointQualityIntervalList()
            for pqLV, pqValue in enumerate(pqIntervalList, 1): # Áé¸ùÆ·¼¶´Ó1¿ªÊ¼
                if pointValue >= pqValue:
                    curPQLV = pqLV
                else:
                    break
            pointFuncInfo[1](curPlayer, curPQLV)
            if curPQLV != befPQLV:
                hasChange_Qualitylv = True
            if not curPQLV:
                continue
            pqAttrInfoDict = ipyData.GetPointQualityAttrDict().get(str(curPlayer.GetJob()), {})
            for pqAttrID, pqAttrValueList in pqAttrInfoDict.items():
                pqAttrValue = 0 if curPQLV > len(pqAttrValueList) else pqAttrValueList[curPQLV - 1]
                CalcAttrDict_Type(int(pqAttrID), pqAttrValue, lingGenQualityAttrList)
            #GameWorld.DebugLog("        ÊôÐÔµã(%s)Æ·½×µÈ¼¶ÊôÐÔ: befPQLV=%s,curPQLV=%s,pqAttrInfoDict=%s" % (pointAttrID, befPQLV, curPQLV, pqAttrInfoDict))
            if hadRefreshAttr and befPQLV < curPQLV:
                for pqlv in xrange(befPQLV+1, curPQLV+1):
                    EventShell.EventRespons_LingGenQualityUP(curPlayer, pointAttrID, pqlv)
                
        #GameWorld.DebugLog("µÈ¼¶ÊôÐÔµã¼ÓÊôÐÔ: %s" % allAttrList)
        #GameWorld.DebugLog("Áé¸ùÆ·½×µÈ¼¶ÊôÐÔ: %s" % lingGenQualityAttrList)
        #GameWorld.DebugLog("Áé¸ùµãÊý¸½¼ÓÕ½Á¦: %s" % pointFightPowerEx)
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % ShareDefine.Def_MFPType_Role, pointFightPowerEx) 
        SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase, allAttrList)
        SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty, lingGenQualityAttrList)
        return hasChange_Qualitylv
    
    #---------------------------------------------------------------------
    def NotifyAllState(self, playerStateDict):
        curPlayer = self.__Player
        notifySelfList = []
        notifyAllList = []
        notifyAllAttrState = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NotifyAllAttrState)
        
        #ÔÚ´Ë´¦°ÑËùÓÐÊôÐԵIJ»Í¬Í¨Öª¸ø¿Í»§¶Ë
        for index, value in playerStateDict.items():
            
            curPlayerState, attrType, notifySelf, notifyAll = EffGetSet.GetValueByEffIndexEx(curPlayer, index)
            
            if not attrType:
                continue
            
            if notifyAllAttrState and curPlayerState == value:
                #GameWorld.Log("µÚ%d¸ö£¬Ô­Öµ%dµÈÓÚÏÖÖµ%d£¬²»·¢¸ø¿Í»§¶Ë"%( index, value, curPlayerState ) )
                continue
            notifyStruct = ChPyNetSendPack.tagRefreshType()
            notifyStruct.RefreshType = attrType
            if attrType in [IPY_PlayerDefine.CDBPlayerRefresh_HP, IPY_PlayerDefine.CDBPlayerRefresh_MaxHP]:
                notifyStruct.Value = curPlayerState % ShareDefine.Def_PerPointValue
                notifyStruct.ValueEx = curPlayerState / ShareDefine.Def_PerPointValue
            else:
                notifyStruct.Value = curPlayerState               
            if notifySelf:
                notifySelfList.append(notifyStruct)
            if notifyAll:
                notifyAllList.append(notifyStruct)
        
        #ÊôÐÔ×éºÏ°ü
        #֪ͨ×Ô¼º
        if notifySelfList:
            sendPack = ChPyNetSendPack.tagObjInfoListRefresh()
            sendPack.Clear()
            sendPack.ObjID = curPlayer.GetID()
            sendPack.ObjType = curPlayer.GetGameObjType()
            sendPack.Count = len(notifySelfList)
            sendPack.RefreshType = notifySelfList
            NetPackCommon.SendFakePack(curPlayer, sendPack)
            
        if len(notifyAllList) != 0:
            #¹ã²¥ÖÜΧÍæ¼Ò
            sendPack = ChPyNetSendPack.tagObjInfoListRefresh()
            sendPack.Clear()
            sendPack.ObjID = curPlayer.GetID()
            sendPack.ObjType = curPlayer.GetGameObjType()
            sendPack.Count = len(notifyAllList)
            sendPack.RefreshType = notifyAllList
            PyNotifyAll(curPlayer, sendPack, False, -1)
            
        if not notifyAllAttrState:
            curPlayer.SetDict(ChConfig.Def_PlayerKey_NotifyAllAttrState, 1)
        return
    
    ## Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
    #  @param self ÀàʵÀý
    #  @param isForce ÊÇ·ñÇ¿ÖÆË¢ÐÂ
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
    def RefreshAllState(self, isSyncBuff=False, billboardFunc=None, isForce=False):
        curPlayer = self.__Player
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Start RefreshAllState!!!", playerID)
        
        self.RefreshPlayerActionState()
        self.RefreshPlayerAttrState(billboardFunc, isForce)
        return
    
    
    ## ÖؼÆË㲢ˢÐÂÍæ¼ÒËùÓÐ״̬, Ä¿Ç°Ö»ÓÃÓëÇл»µØͼ
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
    def ReCalcAllState(self):
        curPlayer = self.__Player
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Start ReCalcAllState!!!", playerID)
        
        for funcIndex in ChConfig.CalcAttrFuncList:
            ClearCalcAttrListValue(curPlayer, funcIndex)
            
        #ÏÈѹÈëBUFFµÄЧ¹ûÖµ¼°¼¼ÄÜÕ½¶·Á¦
        self.RefreshAllSkill()
        ChEquip.RefreshPlayerEquipAttribute(curPlayer)
        ChEquip.RefreshPlayerLingQiEquipAttr(curPlayer)
        #SkillShell.RefreshPlayerBuffOnAttrAddEffect(curPlayer)
        PlayerHorse.CalcHorseAttrEx(curPlayer)
        PlayerPrestigeSys.CalcOfficialRankAttr(curPlayer)
        PlayerGodWeapon.CalcGodWeaponAttr(curPlayer)
        PlayerDienstgrad.CalcAllDienstgradAttr(curPlayer)
        PlayerPet.CalcPetItemAddPlayerAttr(curPlayer)
        PlayerRune.RefreshRuneAttr(curPlayer)
        PlayerMagicWeapon.CalcMagicWeaponAttr(curPlayer)
        PlayerSuccess.CalcSuccessAttr(curPlayer)
        PlayerVip.CalcVIPAttr(curPlayer)
        PlayerRefineStove.CalcStoveAttr(curPlayer)
        PlayerFamilyTech.CalcFamilyTechAttr(curPlayer)
        PlayerEquipDecompose.RefreshEDAttr(curPlayer)
        PlayerDogz.RefreshDogzAttr(curPlayer)
        PlayerGatherSoul.RefreshGatherSoulAttr(curPlayer)
        PlayerGatherTheSoul.CalcSoulAttr(curPlayer)
        PlayerCoat.CalcClothesCoatSkinAttr(curPlayer)
        PlayerFaQi.CalcFaQiAttr(curPlayer)
        PlayerLove.CalcLoveAttr(curPlayer)
        PlayerCharm.CalcCharmAttr(curPlayer)
        PlayerLianTi.CalcLianTiAttr(curPlayer)
        PlayerShentong.CalcShentongAttr(curPlayer)
        PlayerFamilyZhenfa.CalcZhenfaAttr(curPlayer)
        PlayerFace.CalcFaceAttr(curPlayer)
        PlayerFace.CalcFacePicAttr(curPlayer)
        self.RefreshAllState(isForce=True)
        GameWorld.DebugLog("End ReCalcAllState!!!", playerID)
        return
    
    
    # BUFF²ãµ¥¶ÀË¢ÐÂÊôÐÔ£¬¹¦ÄÜÊôÐÔÈ¡»º´æ---------------------------------------------
    def RefreshPlayerAttrByBuff(self, isForce=False):
        curPlayer = self.__Player
        curPlayer.SetDict(ChConfig.Def_Player_RefreshAttrByBuff, 1)
        
        if isForce:
            self.RefreshPlayerAttrByBuffEx()
        return True
    
    # BUFF²ãµ¥¶ÀË¢ÐÂÊôÐÔ
    def RefreshPlayerAttrByBuffEx(self):
        
        curPlayer = self.__Player
        if curPlayer.GetDictByKey(ChConfig.Def_Player_RefreshAttrByBuff) != 1:
            return
        
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Start RefreshPlayerAttrByBuffEx!!!", playerID)
        beforeMaxHP = GameObj.GetMaxHP(curPlayer)
        beforeMoveSpeedValue = GetSpeedValue(curPlayer)
        #¹¹½¨Íæ¼ÒË¢ÐÂ֪ͨ¿Í»§¶Ë×Öµä, »º´æ[Ë÷Òý, ÊýÖµ]
        playerStateDict = {}
        for index in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            playerStateDict.update({index:EffGetSet.GetValueByEffIndex(curPlayer, index)})
        #GameWorld.DebugLog("Ë¢ÊôÐÔÇ°=%s" % playerStateDict, playerID)
        #self.PrintAttr(curPlayer, "ˢ֮ǰ")
        #---------------------------¿ªÊ¼¼ÆËã-------------------------------------
        curPlayer.BeginRefreshState()
        # »Ö¸´¹¦ÄÜÊýÖµ  ²»Äܵ÷Óú¯Êýself.InitPlayerState()
        EffGetSet.RestorePlayerFuncAttr(curPlayer)
        
        # 6.¼ÆËãbuffÊôÐÔ, buff²ã¼¶µÄ²»ËãÈçÕ½¶·Á¦
        self.__RefreshBuffAttr()
        
        # 7.Ë¢ÍêÊôÐÔºóÐèÒª´¦ÀíµÄÂß¼­
        self.__DoRefreshAttrAfterLogic(beforeMaxHP, beforeMoveSpeedValue, playerStateDict)
        
        curPlayer.SetDict(ChConfig.Def_Player_RefreshAttrByBuff, 0)
        GameWorld.DebugLog("End RefreshPlayerAttrByBuffEx!!!", playerID)
        return
    
    
    #===========================================================================
    # #×°±¸ºÍBUFF Ч¹ûµÄ¼ÆËãÒƵ½Íâ²ã
    # #RefreshPlayerBuffOnAttrAddEffect
    # #RefreshPlayerEquipAttribute(curPlayer)
    #===========================================================================
    ## Ë¢ÐÂÍæ¼ÒÊôÐÔµ÷Óô˺¯Êý£¬Á¢¼´Ë¢Ð¸ÄΪ֪ͨˢУ¬ÓÉProcessStatueͳһˢÐÂÒ»´Î
    ## ÅÅÐаñÀàµÄË¢ÐÂisForceÐèҪΪTrue
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    def RefreshPlayerAttrState(self, billboardFunc=None, isForce=False):
        curPlayer = self.__Player
        curPlayer.SetDict(ChConfig.Def_Player_RefreshAttr, 1)
            
        if billboardFunc and billboardFunc not in PyGameData.g_refreshAttrBillboardFunc:
            PyGameData.g_refreshAttrBillboardFunc.append(billboardFunc)
            
        if isForce:
            self.RefreshPlayerAttrStateEx()
            
        return
    
    def PrintAttr(self, curPlayer, mark):
        attrInfo = ""
        for index in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            value = EffGetSet.GetValueByEffIndex(curPlayer, index)
            if value:
                attrInfo = "%s,%s=%s" % (attrInfo, index, value)
        GameWorld.DebugLog("%s AttrInfo=%s" % (mark, attrInfo))
        return
    
    def RefreshPlayerAttrStateEx(self):
        ''' ±¾ÏîÄ¿Ë¢ÊôÐÔ¹æÔò
                    ÊôÐÔ£º
            1.¹Ì¶¨ÊôÐÔ£ºÈç¹¥»÷+100
            2.°Ù·Ö±ÈÊôÐÔ£º Èç¹¥»÷+5%£¬°Ù·Ö±È¼Ó³É»ùÖµ½öΪ¹Ì¶¨ÊôÐÔ£¬°Ù·Ö±È¼Ó³ÉÊôÐÔÖµ²»±»³ýbuff°Ù·Ö±ÈÍâµÄÈκΰٷֱÈÊôÐÔ¶þ´Î¼Ó³É
            
                    ²ã¼¶£º
            1.ÊôÐԲ㼶£ºËùÓй¦ÄÜͬһ²ã¼¶
            2.buff²ã¼¶£º°Ù·Ö±È¿É¶Ô¹¦ÄܰٷֱȼӳɵÄÊôÐÔ½øÐжþ´Î¼Ó³É
            
                    ¹¦ÄÜÄ£¿é£º¶¨ÒåÒ»¸ö¹¦ÄÜ£¬±ÈÈçÁé¸ùÄ£¿é£¬Ò»¸öÄ£¿é¿ÉÄÜ°üº¬¶à¸ö¹¦Äܵã
                    ¹¦Äܵ㣺ij¸öÄ£¿éϵĸ÷¸öÊôÐÔ¹¦Äܵ㣬ÈçÁé¸ùÄ£¿é¿ÉÄÜ°üº¬ Áé¸ù»ù´¡¡¢Áé¸ùÆ·ÖÊ Á½¸ö¹¦ÄܵãÊôÐÔ
        
                    °Ù·Ö±È¼Ó³ÉÖµ£º°Ù·Ö±È¼Ó³ÉÊôÐÔÖµ²»±»³ýbuff°Ù·Ö±ÈÍâµÄÈκΰٷֱÈÊôÐÔ2´Î¼Ó³É
            1.¹¦ÄÜÄÚ²¿ÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶Ô×Ô¼º¹¦Ä̶ܹ¨Öµ¼Ó³É
            2.¹¦Äܽ»²æÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶ÔÆäËû¹¦Ä̶ܹ¨Öµ¼Ó³É
            3.¹¦Ä̶ܹ¨ÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶ÔËùÓй¦Ä̶ܹ¨Öµ¼Ó³É
            4.buff²ã¼¶°Ù·Ö±È£º¶ÔËùÓÐÊôÐÔ½øÐжþ´Î¼Ó³É
            
                    ¼¼ÄÜÊôÐÔ£º¹Ì¶¨Öµ²»ÏíÊ̶ܹ¨°Ù·Ö±È¼Ó³É
                    
        buff²ã¼¶£º
            1.²»ËãÕ½Á¦
            2.ÏÈËã°Ù·Ö±È¼Ó³ÉÔټӹ̶¨Öµ
            
                    ÊôÐÔËã·¨£º
                       Ä£¿é¹Ì¶¨ÊôÐÔ    = ¹¦ÄܵãA¹Ì¶¨Öµ + ¹¦ÄܵãB¹Ì¶¨Öµ + ...
                        ¹Ì¶¨×ÜÊôÐÔ        = Ä£¿éA¹Ì¶¨Öµ + Ä£¿éB¹Ì¶¨Öµ + ...
                        ÎÞbuff×ÜÊôÐÔ  = ¹Ì¶¨×ÜÊôÐÔ + ÄÚ²¿°Ù·Ö±È¼Ó³ÉÖµ + ½»²æ°Ù·Ö±È¼Ó³É  + ¹Ì¶¨×ÜÊôÐÔ°Ù·Ö±È¼Ó³É   + ¼¼ÄܰٷֱȶԹ̶¨ÊôÐÔ¼Ó³É  + ¼¼Ä̶ܹ¨Öµ
                        º¬buff×ÜÊôÐÔ  = ÎÞbuff×ÜÊôÐÔ * buff°Ù·Ö±È¼Ó³É  +  buff¹Ì¶¨Öµ
        '''
        curPlayer = self.__Player
        
        if curPlayer.GetDictByKey(ChConfig.Def_Player_RefreshAttr) != 1:
            return False
        
        PlayerGubao.CalcGubaoAttr(curPlayer) # ¹Å±¦¶¨Î»Îª¶Ô¹áͨËùÓÐÓÎÏ·¹¦ÄÜϵͳµÄÊôÐÔÍæ·¨£¬ËùÒÔÿ´Î¶¼ÖØÐÂË¢ÐÂ
        
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Start RefreshPlayerAttrStateEx!!!", playerID)
        
        #beforeAtkInterval = curPlayer.GetAtkInterval()
        beforeMaxHP = GameObj.GetMaxHP(curPlayer)
        beforeMoveSpeedValue = GetSpeedValue(curPlayer)
        beforeMaxProDef = GetMaxProDef(curPlayer)
        #[½ðľˮ»ðÍÁ]
        beforePointList = [GetMetal(curPlayer), GetWood(curPlayer), GetWater(curPlayer), GetFire(curPlayer), GetEarth(curPlayer)]
        #¹¹½¨Íæ¼ÒË¢ÐÂ֪ͨ¿Í»§¶Ë×Öµä, »º´æ[Ë÷Òý, ÊýÖµ]
        playerStateDict = {}
        for index in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            playerStateDict.update({index:EffGetSet.GetValueByEffIndex(curPlayer, index)})
        #GameWorld.DebugLog("Ë¢ÊôÐÔÇ°=%s" % playerStateDict, playerID)
        #self.PrintAttr(curPlayer, "ˢ֮ǰ")
        #---------------------------¿ªÊ¼¼ÆËã-------------------------------------
        curPlayer.BeginRefreshState()
        self.ResetFightPowerObj()
        #self.PrintAttr(curPlayer, "ÖØÖúó")
        notAttrList = [{} for _ in range(4)]
        
        # 1.³õʼ»¯ÈËÎï¸÷Ïî״̬¼°ÊôÐÔ
        self.InitPlayerState()
        #self.PrintAttr(curPlayer, "³õʼ»¯")
        
        # ¹¦ÄÜÊôÐԲ㼶һ...
        # 2.¼ÆËã»ù´¡ÊôÐÔ
        #    2.1 »ñÈ¡ËùÓй¦ÄܼÆËãµã¼ÆËãµÄÊôÐÔÖµ, ͳ¼Æ»ù´¡ÊôÐÔÀÛ¼Ó
        baseAttrDict = {}
        baseAttrNolineDict = {}
        funcAttrLen = len(ChConfig.CalcAttrFuncList)
        funcAttrInfoList = [[{} for _ in range(4)]] * funcAttrLen
        funcInsidePerAttrList = [{}] * funcAttrLen # ¹¦ÄÜÄÚ²¿°Ù·Ö±È¸½¼ÓÊôÐÔ
        for funcIndex in ChConfig.CalcAttrFuncList:
            # »ù´¡ÊôÐԵȹ¦ÄÜ»ã×ÜÍêºóͳһˢУ¬ÒòΪ¸÷¹¦ÄÜ¿ÉÄÜ»á¼ÓÊôÐÔµãÊý
            if funcIndex in [ChConfig.Def_CalcAttrFunc_RoleBase, ChConfig.Def_CalcAttrFunc_LingGenQuailty]:
                continue
            attrInfo, insidePerAttrDict = GetCalcAttrListValue(curPlayer, funcIndex)[:2]
            if attrInfo == notAttrList and not insidePerAttrDict:
                continue
            GameWorld.DebugLog("¹¦ÄܵãÊôÐÔ: %s(%s), %s, ÄÚ²ã°Ù·Ö±È¸½¼Ó: %s" % (funcIndex, ChConfig.FuncIndexName.get(funcIndex, ""), attrInfo, insidePerAttrDict), playerID)
            funcAttrInfoList[funcIndex] = attrInfo
            funcInsidePerAttrList[funcIndex] = insidePerAttrDict
            # ²»Í¬¹¦Äܵã¼äµÄÊýÖµÀÛ¼Ó£¬ÐèʹÓÃÖ§³ÖË¥¼õµÝÔöµÄ¼ÆË㷽ʽ
            AddAttrDictValue(baseAttrDict, attrInfo[ChConfig.CalcAttr_Base])
            AddAttrDictValue(baseAttrNolineDict, attrInfo[ChConfig.CalcAttr_BaseNoline])
            
        #    2.2 ½«»ù´¡ÊôÐÔÀÛ¼Óµ½Íæ¼ÒÉíÉÏ
        if baseAttrDict or baseAttrNolineDict:
            # ÒòΪ»ù´¡ÊôÐÔ»áÓ°ÏìÕ½¶·ÊôÐÔ¼ÆË㣬ËùÒÔÏÈͳ¼ÆÔö¼Ó»ù´¡ÊôÐÔ
            GameWorld.DebugLog("¹¦Äܸ½¼Óµã: baseAttrDict=%s,baseAttrNolineDict=%s" % (baseAttrDict, baseAttrNolineDict), playerID)
            CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, baseAttrDict)
            CalcNoLineEffect.ChangePlayerAttrInNoLineEffectList(curPlayer, baseAttrNolineDict)
            
        # ¹¦ÄÜÓмӻù´¡ÊôÐÔÖµ£¬ÕâÀïÔÙÖØÐÂË¢ÐÂһϻù´¡ÊôÐÔ, »ù´¡ÊôÐÔ»áÓ°ÏìÕ½¶·ÊôÐÔ, ÿ´Î¶¼Ë¢Ð½ÇÉ«»ù´¡ÊôÐÔ
        hasChange_Qualitylv = self.CalcRoleBaseAttr(curPlayer)
        roleBaseAttrInfo, roleInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_RoleBase)[:2]
        lingGenQualityAttrList, lingGenQualityInsidePerAttrDict = GetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_LingGenQuailty)[:2]
        funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleBaseAttrInfo
        funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_RoleBase] = roleInsidePerAttrDict
        funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] =  lingGenQualityAttrList
        funcInsidePerAttrList[ChConfig.Def_CalcAttrFunc_LingGenQuailty] =  lingGenQualityInsidePerAttrDict
        GameWorld.DebugLog("¹¦ÄܵãÊôÐÔ: %s(%s), %s, ÄÚ²ã°Ù·Ö±È¸½¼Ó: %s" 
                           % (ChConfig.Def_CalcAttrFunc_RoleBase, ChConfig.FuncIndexName.get(ChConfig.Def_CalcAttrFunc_RoleBase, ""), roleBaseAttrInfo, roleInsidePerAttrDict), playerID)
        GameWorld.DebugLog("¹¦ÄܵãÊôÐÔ: %s(%s), %s, ÄÚ²ã°Ù·Ö±È¸½¼Ó: %s" 
                           % (ChConfig.Def_CalcAttrFunc_LingGenQuailty, ChConfig.FuncIndexName.get(ChConfig.Def_CalcAttrFunc_LingGenQuailty, ""), lingGenQualityAttrList, lingGenQualityInsidePerAttrDict), playerID)
        
        #self.PrintAttr(curPlayer, "»ù´¡ºó", playerID)
        
        # 3.¼ÆËãÕ½¶·ÊôÐÔ
        #    3.1 Õ½¶·ÊôÐԲ㼶½»²æÓ°Ïì»ùÖµÊýÖµ»ã×Ü
        #        »ù´¡²ã¼¶(½ÇÉ«»ù´¡ÊôÐÔ)
        baseAttrList = AddAttrListValue([funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase],
                                         funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGen],
                                         funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGenQuailty],
                                         ])
        #GameWorld.DebugLog("»ù´¡²ã¼¶: %s" % baseAttrList, playerID)
        
        #        ¹¦Äܵ㽻²æÓ°Ïì·ÇÏßÐÔ²ã¶ÔÓ¦ÊôÐÔ»ùÖµÁбí
        funcAttrPerInfo = {ChConfig.TYPE_Calc_BaseAtkAddPer:[baseAttrList],
                           ChConfig.TYPE_Calc_BaseMaxHPAddPer:[baseAttrList],
                           ChConfig.TYPE_Calc_BaseDefAddPer:[baseAttrList],
                           ChConfig.TYPE_Calc_BaseHitAddPer:[baseAttrList],
                           ChConfig.TYPE_Calc_BaseMissAddPer:[baseAttrList],
                           ChConfig.TYPE_Calc_FaQiMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FaQi]],
                           ChConfig.TYPE_Calc_FaQiAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FaQi]],
                           ChConfig.TYPE_Calc_FaQiDefPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FaQi]],
                           ChConfig.TYPE_Calc_GodWeaponMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_GodWeapon]],
                           ChConfig.TYPE_Calc_GodWeaponAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_GodWeapon]],
                           ChConfig.TYPE_Calc_StoneMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Stone]],
                           ChConfig.TYPE_Calc_StoneAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Stone]],
                           ChConfig.TYPE_Calc_StoneBasePer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Stone]],
                           ChConfig.TYPE_Calc_RealmBasePer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Prestige]],
                           ChConfig.TYPE_Calc_HorseAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Horse]],
                           ChConfig.TYPE_Calc_HorseMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Horse]],
                           ChConfig.TYPE_Calc_HorseTrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseTarin]],
                           ChConfig.TYPE_Calc_PetTrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_PetTarin]],
                           ChConfig.TYPE_Calc_GuardTrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_GuardTarin]],
                           ChConfig.TYPE_Calc_WingTrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_WingTarin]],
                           ChConfig.TYPE_Calc_PeerlessWeaponTrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_PeerlessWeaponTrain]],
                           ChConfig.TYPE_Calc_PeerlessWeapon2TrainAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_PeerlessWeapon2Train]],
                           ChConfig.TYPE_Calc_LianTiAttrPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LianTi]],
                           ChConfig.TYPE_Calc_HorseSkinMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseSkin], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseStar]],
                           ChConfig.TYPE_Calc_HorseSkinAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseSkin], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseStar]],
                           ChConfig.TYPE_Calc_HorseSkinDefPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseSkin], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_HorseStar]],
                           ChConfig.TYPE_Calc_TitleMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Dienstgrad], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_TitleStar]],
                           ChConfig.TYPE_Calc_TitleAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Dienstgrad], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_TitleStar]],
                           ChConfig.TYPE_Calc_TitleDefPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Dienstgrad], funcAttrInfoList[ChConfig.Def_CalcAttrFunc_TitleStar]],
                           ChConfig.TYPE_Calc_FaceMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Face]],
                           ChConfig.TYPE_Calc_FaceAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Face]],
                           ChConfig.TYPE_Calc_FaceDefPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_Face]],
                           ChConfig.TYPE_Calc_FacePicMaxHPPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FacePic]],
                           ChConfig.TYPE_Calc_FacePicAtkPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FacePic]],
                           ChConfig.TYPE_Calc_FacePicDefPer:[funcAttrInfoList[ChConfig.Def_CalcAttrFunc_FacePic]],
                           }
        #    3.2 ͳ¼Æ¸÷¹¦ÄÜÖ®¼ä·ÇÏßÐÔÊôÐÔ½»²æÓ°ÏìÀÛ¼Ó
        funcCrossAttrPerInfoDict = {} # °Ù·Ö±È½»²æÓ°ÏìËùÌáÉýµÄÊôÐÔÖµ {¹¦ÄÜÊôÐÔ±àºÅ:{ÌáÉýµÄÊôÐÔÀàÐÍ:ÊýÖµ, ...}, ...}
        for i, funcAttrList in enumerate(funcAttrInfoList):
            battleNoLineAttrDict = funcAttrList[ChConfig.CalcAttr_BattleNoline] # ÔÝдËÀֻȡս¶··ÇÏßÐÔµÄ
            if not battleNoLineAttrDict:
                continue
            addAttrDict = {}
            #GameWorld.DebugLog("½»²æ¹¦Äܵã: i=%s,%s" % (i,battleNoLineAttrDict), playerID)
            for noLineAttrType, addAttrPer in battleNoLineAttrDict.items():
                if noLineAttrType not in funcAttrPerInfo or noLineAttrType not in ChConfig.FuncNoLinearAttrDict:
                    continue
                # ʹÓõĻùֵĿ±ê¹¦ÄÜË÷Òý
                attrRate = addAttrPer / float(ChConfig.Def_MaxRateValue)
                addAttrTypeList = ChConfig.FuncNoLinearAttrDict[noLineAttrType]
                useFuncAttrList = funcAttrPerInfo[noLineAttrType]
                for attrType in addAttrTypeList:
                    addValue = 0
                    for useAttrList in useFuncAttrList:
                        useAttrDict = useAttrList[ChConfig.CalcAttr_Battle] # ĬÈÏÔö¼ÓµÄÊÇÕ½¶·ÏßÐÔ
                        # ĬÈÏÌáÉýµÄÊôÐÔÔÚÏßÐÔÕ½¶·ÊôÐÔÀï
                        if attrType not in useAttrDict:
                            continue
                        baseValue = useAttrDict[attrType] # Ö»ÊÇÓõ½Ä¿±ê¹¦ÄܵĻùÖµ
                        addValue += int(baseValue * attrRate)
                        #GameWorld.DebugLog("    i=%s,calcID=%s,per=%s,rate=%s,baseValue=%s,attrType=%s,addValue=%s" % (i, noLineAttrType, addAttrPer, attrRate, baseValue, attrType, addValue), playerID)
                    if addValue <= 0:
                        continue
                    addAttrDict[attrType] = addAttrDict.get(attrType, 0) + addValue
                    
            if addAttrDict:
                # Ôö¼ÓµÄÊýֵͳ¼Æµ½°Ù·Ö±ÈÊôÐÔËùÊô¹¦Äܵã
                # Èç·ûÎÄÓиöÎäÆ÷¹¥»÷°Ù·Ö±ÈÔö¼ÓÊôÐÔ£¬Ôö¼ÓµÄÊýÖµÊôÓÚ·ûÎŦÄÜ£¬²»ÊôÓÚÎäÆ÷¹¦ÄܵãµÄ£¬Ö»ÊÇ»ùֵʹÓÃÁËÎäÆ÷¹¥»÷     
                funcCrossAttrPerInfoDict[i] = addAttrDict # Ïȶ¼Í³¼ÆÍêºóÔÙÀÛ¼Óµ½¶ÔÓ¦¹¦ÄÜÊôÐÔÀ²»È»¿ÉÄܻᵼÖ¹¦ÄÜ»ùÖµ±ä¸ü
                
        GameWorld.DebugLog("½»²æÓ°ÏìÊôÐÔ: %s" % funcCrossAttrPerInfoDict, playerID)
        
        #    3.3 ͳ¼ÆËùÓй¦Ä̶ܹ¨ÊôÐÔÓ°ÏìÀÛ¼Ó
        allFixAttrDict = {} # ¹Ì¶¨ÊôÐԲ㼶×ÜÊôÐÔ»ùÖµ
        for funcIndex, funcAttrList in enumerate(funcAttrInfoList):
            # ¼¼ÄÜÄ£¿é²»¼ÆÈ빦Ä̶ܹ¨ÊôÐÔ¡¢²»¼ÆÕ½Á¦
            if funcIndex in ChConfig.CalcAttrFuncSkillList:
                continue
            AddAttrDictValue(allFixAttrDict, funcAttrList[ChConfig.CalcAttr_Battle])
            
        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("¹Ì¶¨ÊôÐÔ×ܺÍ: %s" % allFixAttrDict, playerID)
        GameWorld.DebugLog("¹Ì¶¨°Ù·Ö±È¸½¼ÓÊôÐÔ: %s" % fixAttrPerAddExDict, playerID)
        
        # 4. ¼ÆËãÊôÐÔ¼°Õ½Á¦, ÐèÔÚ¼ÆËãbuff²ã֮ǰ¼ÆËã
        curLV = curPlayer.GetLV()
        fpParam = IpyGameDataPY.GetIpyGameData("FightPowerParam", curLV)
        mfpDict = {} # Ä£¿éÕ½¶·Á¦
        mfpObjDict = {}
        for mfpType, attrFuncIndexList in ChConfig.MFPTypeAttrFuncIndexDict.items():
            mfpAttrList = [{} for _ in range(4)]
            mfpAttrExDict = {}
            for funcIndex in attrFuncIndexList:
                if funcIndex in ChConfig.CalcAttrFuncSkillList:
                    # ¼¼ÄÜÄ£¿é²»¼ÆÈ빦Ä̶ܹ¨ÊôÐÔ¡¢²»¼ÆÕ½Á¦
                    continue
                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:
                    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)
            mfpObjDict[mfpType] = mfpObj
            
        # ÒòΪ¼ÆËãÕ½Á¦ÐèҪȡµ½×ÜÊôÐÔ£¬ËùÒԵȸ÷¹¦ÄܵãÊôÐÔÀÛ¼ÓÍêºóÔÙ¼ÆËã
        for mfpType, mfpObj in mfpObjDict.items():
            mfpValue = 0 if not fpParam else mfpObj.GetModuleFightPower(fpParam, curPlayer)
            mfpSkill = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpObj.mfpType)
            mfpEx = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpObj.mfpType)
            mfpEx = GetMFPExFightPower(curPlayer, mfpType)
            mfpTotal = mfpValue + mfpSkill + mfpEx
            mfpDict[mfpObj.mfpType] = min(mfpTotal, ChConfig.Def_UpperLimit_DWord)
            
            if mfpType == ShareDefine.Def_MFPType_Plus:
                OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_Plus, mfpTotal)
            elif mfpType == ShareDefine.Def_MFPType_Horse:
                OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_Horse, mfpTotal)
            elif mfpType == ShareDefine.Def_MFPType_Wash:
                OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_Wash, mfpTotal)
                
        #GameWorld.DebugLog("ÕûÌå²ã¼¶ÏßÐÔÊôÐÔ: %s" % allAttrList, playerID)
        
        # 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, playerID)
        
        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)
                
        #ÌØÊâÖ¸¶¨ÊôÐÔ¹«Ê½
        GameMap.SpecialMapSetAttrValueByFormat(curPlayer)
        
        #»¤¶ÜֵˢÐÂ
        self.__RefreshMaxProDef(beforeMaxProDef)
        
        # ¡¾µ½´ËËùÓй¦ÄÜÊôÐÔ¶¼ÒÑˢд¦ÀíÍê±Ï£¬¸´ÖÆÒ»·Ý ¹¦ÄÜÊôÐÔµÄˢнá¹û£¬ÓÃÓÚBUFFÊôÐÔµ¥¶ÀˢС¿
        EffGetSet.CopyPlayerFuncAttr(curPlayer)
        
        # 6.¼ÆËãbuffÊôÐÔ, buff²ã¼¶µÄ²»ËãÈçÕ½¶·Á¦
        self.__RefreshBuffAttr()
        
        # 7.Ë¢ÍêÊôÐÔºóÐèÒª´¦ÀíµÄÂß¼­
        self.__DoRefreshAttrAfterLogic(beforeMaxHP, beforeMoveSpeedValue, playerStateDict)
        
        #֪ͨ»ù´¡ÊôÐÔ
        self.__SyncBaseAttr(curPlayer, baseAttrList)
        #ÎåÐÐÁé¸ù±ä¸üÐèÒª´¦ÀíµÄÂß¼­
        afterPointList = [GetMetal(curPlayer), GetWood(curPlayer), GetWater(curPlayer), GetFire(curPlayer), GetEarth(curPlayer)]
        if beforePointList != afterPointList:
            diffPointAttrList = []
            for i, attrID in enumerate([ShareDefine.Def_Effect_Metal, ShareDefine.Def_Effect_Wood, ShareDefine.Def_Effect_Water,
                           ShareDefine.Def_Effect_Fire, ShareDefine.Def_Effect_Earth]):
                if beforePointList[i] != afterPointList[i]:
                    diffPointAttrList.append(attrID)
            SkillShell.RefreshElementSkillByAttr(curPlayer, diffPointAttrList)
#        if hasChange_Qualitylv:
#            #Áé¸ùÆ·¼¶±ä»¯´¦Àí
#            ChEquip.ChangeEquipfacadeByLingGen(curPlayer)
            
        # ¸üпª·þ»î¶¯Áé¸ùÊý¾Ý
        OpenServerCampaign.UpdOpenServerCampaignLingGenData(curPlayer)
        
        # ͬ²½Ç°¶ËÕ½Á¦£¬ÒòΪÓÐ SetFightPower ËùÒÔÀÛ¼ÓÕ½Á¦·ÅÔÚÕâÀïËùÓÐˢм°¼ÆËã´¦ÀíÍêºó²Å´¦Àí£¬²ÅÄÜÕý³£´¥·¢setͬ²½Ç°¶Ë
        self.SendModuleFightPowerPack(curPlayer, mfpDict)
        billFuncCnt = len(PyGameData.g_refreshAttrBillboardFunc) # Ö»´¦Àí¹Ì¶¨´ÎÊý£¬·ÀÖ¹ËÀÑ­»·
        while billFuncCnt > 0 and PyGameData.g_refreshAttrBillboardFunc:
            billFuncCnt -= 1
            billboardFunc = PyGameData.g_refreshAttrBillboardFunc.pop(0)
            GameWorld.DebugLog("»Øµ÷ÅÅÐаñ: %s" % billboardFunc, playerID)
            billboardFunc(curPlayer, isForceUpdate=True)
            
        # ÔÝͣˢÐÂÊôÐÔ±êÖ¾£¬±ØÐë±»µ÷ÓÃ
        curPlayer.SetDict(ChConfig.Def_Player_RefreshAttr, 0)
        curPlayer.SetDict(ChConfig.Def_Player_RefreshAttrByBuff, 0)
        curPlayer.SetDict(ChConfig.Def_Player_HadRefreshAttr, 1)
        GameWorld.DebugLog("End RefreshPlayerAttrStateEx!!!", playerID)
        return True
    
    
    # ÉúÃüת»¯Îª·À»¤Öµ
    def __RefreshMaxProDef(self, beforeMaxProDef):
        curPlayer = self.__Player
        if GetProDefHPPer(curPlayer) == 0:
            return
        maxHP = GameObj.GetMaxHP(curPlayer)
        proDefPer = GetProDefHPPer(curPlayer)
        
        #»ñÈ¡²ß»®ÅäÖõıí¸ñ
        GodWeapon4 = IpyGameDataPY.GetFuncCfg("GodWeapon4", 2)
        maxProDef = eval(FormulaControl.GetCompileFormula("GodWeapon4", GodWeapon4))
        maxProDef = min(maxProDef, ChConfig.Def_UpperLimit_DWord)
        
        SetMaxProDef(curPlayer, int(maxProDef))
        
        afterMaxProDef = GetMaxProDef(curPlayer)
        addValue = max(0, afterMaxProDef - beforeMaxProDef)
        curProDef = GetProDef(curPlayer)
        
        if beforeMaxProDef > 0 and addValue > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie:
            # ͬ²½Ôö¼Ó (ËÀÍö״̬ϲ»Ë¢)
            SetProDef(curPlayer, min(curProDef + addValue, afterMaxProDef))
        elif curProDef > afterMaxProDef:
            # ×öÒ»´Î·À·¶¾ÀÕý
            SetProDef(curPlayer, min(curProDef, afterMaxProDef))
            
        return
    
    def __RefreshBuffAttr(self):
        ## Ë¢ÐÂbuff²ãÊôÐÔ£¬¸Ã²ãÊôÐÔÖ»»á¸Ä±äÍæ¼Ò×îÖÕÊôÐÔ£¬²»»áÓ°ÏìÕ½Á¦µÈ
        curPlayer = self.__Player
        playerID = curPlayer.GetPlayerID()
        allAttrListBuffs = [{} for _ in range(4)]
        # 6.¼ÆËãbuffÊôÐÔ, buff²ã¼¶µÄ²»ËãÈçÕ½¶·Á¦
        #        ËãÕ½¶·Á¦×Üֵʱ¸Ã²ãÓ°ÏìµÄÊýÖµ²»Í³¼Æ£¬µ«Ë¢ÊôÐÔʱÐè¼ÆËã
        SkillShell.CalcBuffers_Effect(curPlayer, allAttrListBuffs)
        # ¶É½Ù¸±±¾»¤·¨ÊôÐÔ¼Ó³É
        GameLogic_DuJie.CalcDujieFBAttrAdd(curPlayer, allAttrListBuffs)
            
        #        ²ã·ÇÏßÐÔÕ½¶·ÊôÐÔÀÛ¼Ó
        battleNolineAttrBuff = allAttrListBuffs[ChConfig.CalcAttr_BattleNoline]
        CalcNoLineEffect.AddPlayerMapAttrNolineEffect(curPlayer, battleNolineAttrBuff)
        CalcNoLineEffect.ChangePlayerAttrInNoLineEffectList(curPlayer, battleNolineAttrBuff, isBuffAttr=True)
        
        battleAttrBuff = allAttrListBuffs[ChConfig.CalcAttr_Battle]
        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, battleAttrBuff, isBuffAttr=True)
        
        #        ËÙ¶ÈÌØÊâ´¦Àí ¼ÆËãÒ»´Î
        self.__RefreshMoveSpeed(allAttrListBuffs)
        
        # GM²âÊÔÊôÐÔÌØÊâÂß¼­
        self.__DoRefreshGMAttr()
        
        #        ˢй¥»÷ËÙ¶È
        self.__SetAtkInterval()
        GameWorld.DebugLog("Buff²ãÊôÐÔ: %s" % allAttrListBuffs, playerID)
        return
    
    def __DoRefreshGMAttr(self):
        ## Ë¢ÐÂGM²âÊÔÊôÐÔ
        curPlayer = self.__Player
        platform = GameWorld.GetPlatform()
        if platform not in GMShell.TestPlatformList:
            return
        if curPlayer.GetGMLevel() != ChConfig.Def_GM_LV_God:
            return
        
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        if not ipyDataMgr.GetGMAttrCount():
            return
        
        playerAccID = GameWorld.GetPlatformAccID(curPlayer.GetAccID())
        gmIpyData = None
        commIpyData = None
        for i in xrange(ipyDataMgr.GetGMAttrCount()):
            ipyData = ipyDataMgr.GetGMAttrByIndex(i)
            if not ipyData.GetIsValid():
                continue
            gmMaxLV = ipyData.GetGMMaxLV()
            if curPlayer.GetLV() > gmMaxLV:
                continue
            gmAccID = ipyData.GetGMAccID()
            if gmAccID == playerAccID:
                gmIpyData = ipyData
                break
            
            if not gmAccID and not commIpyData:
                commIpyData = ipyData
                
        if not gmIpyData:
            if not commIpyData:
                return
            gmIpyData = commIpyData
            
        setAttrDict = {}
        specAttrDict = gmIpyData.GetAttrSpecDict()
        attrLV = gmIpyData.GetAttrLV()
        attrPer = gmIpyData.GetAttrPer()
        if attrLV:
            if attrLV == 1:
                attrLV = curPlayer.GetLV()
            lvIpyData = GetPlayerLVIpyData(attrLV)
            if lvIpyData:
                setAttrDict[ChConfig.AttrName_MaxHP] = int(lvIpyData.GetReMaxHP() * attrPer) # ×î´óÉúÃüÖµ
                setAttrDict[ChConfig.AttrName_Atk] = int(lvIpyData.GetReAtk() * attrPer) # ¹¥»÷£¨×îС¡¢×î´ó¹¥»÷£©
                setAttrDict[ChConfig.AttrName_Def] = int(lvIpyData.GetReDef() * attrPer) # ·ÀÓù
                setAttrDict[ChConfig.AttrName_Hit] = int(lvIpyData.GetReHit() * attrPer) # ÃüÖÐ
                setAttrDict[ChConfig.AttrName_DefRate] = int(lvIpyData.GetReMiss() * attrPer) # ÉÁ±Ü
                setAttrDict[ChConfig.AttrName_AtkSpeed] = int((lvIpyData.GetReAtkSpeed() + 10000) * attrPer) # ¹¥»÷ËÙ¶È, ²ß»®µÈ¼¶±íÅäÖõÄÊǸ½¼ÓÖµ£¬ËùÒÔÕâÀïÒª¼Ó
                setAttrDict[ChConfig.AttrName_SkillAtkRate] = int(max(0, lvIpyData.GetReSkillAtkRate() - 10000) * attrPer) # ¼¼ÄÜÉ˺¦±ÈÀý, ²ß»®µÈ¼¶±íÅäÖõÄÊÇ×îÖÕÖµ£¬³õʼֵÊÇ0£¬ËùÒÔÕâÀïÒª¼õ
                setAttrDict[ChConfig.AttrName_DamagePVP] = int(lvIpyData.GetReDamagePer() * attrPer) # PVP¹Ì¶¨É˺¦
                setAttrDict[ChConfig.AttrName_DamagePVPReduce] = int(lvIpyData.GetReDamReduce() * attrPer) # PVP¹Ì¶¨¼õÉË
                setAttrDict[ChConfig.AttrName_IgnoreDefRate] = int(lvIpyData.GetReIgnoreDefRate() * attrPer) # ÎÞÊÓ·ÀÓù±ÈÀý
                setAttrDict[ChConfig.AttrName_LuckyHitRate] = int(lvIpyData.GetReLuckyHitRate() * attrPer) # »áÐÄÒ»»÷ÂÊ
                setAttrDict[ChConfig.AttrName_LuckyHit] = int(lvIpyData.GetReLuckyHit() * attrPer) # »áÐÄÒ»»÷É˺¦
                setAttrDict[ChConfig.AttrName_BleedDamage] = int(lvIpyData.GetReBleedDamage() * attrPer) # Á÷ѪÉ˺¦Ôö¼Ó
                setAttrDict[ChConfig.AttrName_IceAtk] = int(lvIpyData.GetReIceAtk() * attrPer) # ÕæʵÉ˺¦
                setAttrDict[ChConfig.AttrName_IceDef] = int(lvIpyData.GetReIceDef() * attrPer) # ÕæʵµÖÓù
                setAttrDict[ChConfig.AttrName_PetAtk] = int(lvIpyData.GetRePetAtk() * attrPer) # Áé³è¹¥»÷
                setAttrDict[ChConfig.AttrName_PetSkillAtkRate] = int(max(0, lvIpyData.GetRePetSkillAtkRate() - 10000) * attrPer) # Áé³è¼¼ÄÜ, ²ß»®µÈ¼¶±íÅäÖõÄÊÇ×îÖÕÖµ£¬³õʼֵÊÇ0£¬ËùÒÔÕâÀïÒª¼õ
                setAttrDict[ChConfig.AttrName_PetDamPer] = int(lvIpyData.GetRePetDamPer() * attrPer) # Áé³èÉ˺¦Ôö¼Ó
                setAttrDict[ChConfig.AttrName_FinalHurt] = int(lvIpyData.GetReFinalHurt() * attrPer) # ¹Ì¶¨É˺¦Ôö¼Ó
                setAttrDict[ChConfig.AttrName_FinalHurtReduce] = int(lvIpyData.GetReFinalHurtReduce() * attrPer) # ¹Ì¶¨É˺¦¼õÉÙ
                
        # ÌØÊâÊôÐÔµÄÖ±½ÓÓÅÏȼ¶×î¸ß£¬Ö±½Ó¸²¸Ç
        for attrType, attrValue in specAttrDict.items():
            setAttrDict[attrType] = attrValue
            
        gmAttrSetInfo = [{} for _ in range(4)]
        for attrType, attrValue in setAttrDict.items():
            if not attrValue:
                setAttrDict.pop(attrType)
                continue
            CalcAttrDict_Type(attrType, attrValue, gmAttrSetInfo)
            
        # Ö±½ÓÉèÖõÄÊôÐÔ
        if gmAttrSetInfo:
            for key, value in gmAttrSetInfo[ChConfig.CalcAttr_Battle].items():
                EffGetSet.SetValueByEffIndex(curPlayer, key, value)
                
        # ¸½¼ÓÊôÐÔ
        attrExDict = gmIpyData.GetAttrExDict()
        gmAttrExInfo = [{} for _ in range(4)]
        for attrType, attrValue in attrExDict.items():
            CalcAttrDict_Type(attrType, attrValue, gmAttrExInfo)
        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, gmAttrExInfo[ChConfig.CalcAttr_Battle])
        
        GameWorld.DebugLog("GM²âÊÔÉèÖÃÊôÐÔ: GMAttrID=%s,playerAccID=%s" % (gmIpyData.GetGMAttrID(), playerAccID))
        GameWorld.DebugLog("    GMµÈ¼¶ÊôÐÔ: GMAttrLV=%s,attrPer=%s,setAttrDict=%s,specAttrDict=%s,%s" 
                           % (attrLV, attrPer, setAttrDict, specAttrDict, gmAttrSetInfo))
        GameWorld.DebugLog("    GM¸½¼ÓÊôÐÔ: attrExDict=%s,%s" % (attrExDict, gmAttrExInfo))
        return
    
    def __DoRefreshAttrAfterLogic(self, beforeMaxHP, beforeMoveSpeedValue, playerStateDict):
        '''Ë¢Íê×ÜÊôÐÔ(¹¦ÄÜÊôÐÔ + buffÊôÐÔ) ºóÐèÒª´¦ÀíµÄÂß¼­
            °üº¬Ò»Ð©ÊýÖµ¾ÀÕý¡¢ÊôÐÔ±ä¸ü֪ͨµÈ
            @attention: ´Ëº¯ÊýΪˢ ¹¦ÄÜÊôÐÔ ¼° buffÊôÐÔ Í¨ÓÃÂß¼­£¬ËùÒÔ²»ÊÇÊÜbuffÓ°ÏìµÄÏà¹Ø´¦ÀíÇë²»Òª·ÅÕâÀ±ÈÈçÕ½¶·Á¦µÈ
        '''
        curPlayer = self.__Player
        #------------------------------¼ÆËãÍê±Ï--------------------------------
        afterMaxHP = GameObj.GetMaxHP(curPlayer)
        addMaxHP = max(0, afterMaxHP - beforeMaxHP)
        if beforeMaxHP > 0 and addMaxHP > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie:
            # ×î´óѪÁ¿Ôö¼Óʱ£¬Í¬²½Ôö¼ÓµÈÁ¿µÄµ±Ç°ÑªÁ¿ (ËÀÍö״̬ϲ»Ë¢µ±Ç°ÑªÁ¿)
            GameObj.SetHP(curPlayer, min(GameObj.GetHP(curPlayer) + addMaxHP, afterMaxHP))
        #self.PrintAttr(curPlayer, "×îÖÕµÄ")
        curPlayer.EndRefreshState() # ͳһÔÚË¢ÊôÐÔ½áÊøÂß¼­Öе÷ÓÃ
        #---------------------------------------------------------------------
        #°ÑÊôÐԺϲ¢Í¨Öª
        self.NotifyAllState(playerStateDict)
        
        #Òƶ¯ËٶȲ»Í¬Ôò֪ͨ¸ø¿Í»§¶Ë, ¹¦Äܲ㴦ÀíµÄÊÇ SpeedNotBuff , ֪ͨ¿Í»§¶ËµÄÐèÒªÊÇ×îÖÕµÄ SpeedValue
        if beforeMoveSpeedValue != GetSpeedValue(curPlayer):
            SetSpeedValue(curPlayer, GetSpeedValue(curPlayer))
            
        #¾ÀÕýµ±Ç°ÑªÄ§Á¿²»³¬¹ý×î´óÖµ
        self.__RestoreHPMP()
        
        #֪ͨ¿Í»§¶ËÍæ¼Òµ±Ç°¾­Ñ鱶ÂÊ
        Sync_ExpRateChange(curPlayer)
        return
    
    def __SyncBaseAttr(self, curPlayer, baseAttrList):
        baseBattleAttrDict = baseAttrList[ChConfig.CalcAttr_Battle]
        attrTypeKeyDict = {ChConfig.TYPE_Calc_AttrATKMin:[ChConfig.Def_PlayerKey_BaseAtkMin, ShareDefine.CDBPlayerRefresh_BaseAtkMin],
                           ChConfig.TYPE_Calc_AttrATKMax:[ChConfig.Def_PlayerKey_BaseAtkMax, ShareDefine.CDBPlayerRefresh_BaseAtkMax],
                           ChConfig.TYPE_Calc_AttrMaxHP:[ChConfig.Def_PlayerKey_BaseMaxHP, ShareDefine.CDBPlayerRefresh_BaseMaxHP],
                           ChConfig.TYPE_Calc_AttrDEF:[ChConfig.Def_PlayerKey_BaseDef, ShareDefine.CDBPlayerRefresh_BaseDef],
                           ChConfig.TYPE_Calc_AttrHit:[ChConfig.Def_PlayerKey_BaseHit, ShareDefine.CDBPlayerRefresh_BaseHit],
                           ChConfig.TYPE_Calc_AttrMiss:[ChConfig.Def_PlayerKey_BaseMiss, ShareDefine.CDBPlayerRefresh_BaseMiss],
                           }
        
        notifySList = []
        for attrType, attrInfo in attrTypeKeyDict.items():
            attrKey, refreshType = attrInfo
            baseValue = baseBattleAttrDict.get(attrType, 0)
            curBaseValue = curPlayer.GetDictByKey(attrKey)
            if baseValue != curBaseValue:
                curPlayer.SetDict(attrKey, baseValue)
                
                notifyStruct = ChPyNetSendPack.tagRefreshType()
                notifyStruct.RefreshType = refreshType
                notifyStruct.Value = baseValue
                notifySList.append(notifyStruct)
                
        # ֪ͨ»ù´¡ÊôÐÔ
        if notifySList:
            sendPack = ChPyNetSendPack.tagObjInfoListRefresh()
            sendPack.Clear()
            sendPack.ObjID = curPlayer.GetID()
            sendPack.ObjType = curPlayer.GetGameObjType()
            sendPack.Count = len(notifySList)
            sendPack.RefreshType = notifySList
            NetPackCommon.SendFakePack(curPlayer, sendPack)
        return
    
    #---------------------------------------------------------------------
    
    ## Ë¢ÐÂÍæ¼Ò¼¼ÄÜÕ½¶·Á¦
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÍæ¼Ò±»¶¯¼¼ÄÜBuff
    def RefreshAllSkill(self):
        curPlayer = self.__Player
        
        skillManager = curPlayer.GetSkillManager()
        
        # ÖØÖÃÄ£¿é¼¼ÄÜÕ½¶·Á¦
        for mfpType in ShareDefine.ModuleFightPowerTypeList:
            curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPSkill % mfpType, 0)
        
        for i in range(0, skillManager.GetSkillCount()):
            curSkill = skillManager.GetSkillByIndex(i)

            mfpType = ChConfig.Def_SkillFuncType_MFPType.get(curSkill.GetFuncType(), ShareDefine.Def_MFPType_Role)

            skillMFP = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpType)
            curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPSkill % mfpType, skillMFP + curSkill.GetFightPower())
        
        return
    
    ## ¼¼ÄÜÉý¼¶Ë¢ÊôÐÔÕ½¶·Á¦´¦Àí
    def RefreshSkillFightPowerEx(self, skillID, beforeFightPower, isRefreshState=True):
        curPlayer = self.__Player
        # м¼ÄÜÕ½Á¦-¾É¼¼ÄÜÕ½Á¦ÎªÔö¼ÓµÄ¼¼ÄÜÕ½Á¦
        curSkill = GameWorld.GetGameData().GetSkillBySkillID(skillID)
        if not curSkill:
            return
        
        mfpType = ChConfig.Def_SkillFuncType_MFPType.get(curSkill.GetFuncType(), ShareDefine.Def_MFPType_Role)
        addFightPower = curSkill.GetFightPower() - beforeFightPower
        skillMFP = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpType)
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPSkill % mfpType, max(0, skillMFP + addFightPower))
        GameWorld.DebugLog("ˢм¼Äܸ½¼ÓÕ½¶·Á¦: skillID=%s,beforeFightPower=%s,mfpType=%s,skillMFP=%s,updMFP=%s" 
                           % (skillID, beforeFightPower, mfpType, skillMFP, skillMFP + addFightPower), curPlayer.GetPlayerID())
        
        if isRefreshState:
            # Èç¹ûÐèҪͬ²½ÅÅÐаñµÄ»°ÏÈÇ¿ÖÆË¢ÊôÐÔ
            self.RefreshPlayerAttrState()
            
        return
    
    def RefreshSkillFightPowerByDel(self, delSkillID, isRefreshState=True):
        curPlayer = self.__Player
        # м¼ÄÜÕ½Á¦-¾É¼¼ÄÜÕ½Á¦ÎªÔö¼ÓµÄ¼¼ÄÜÕ½Á¦
        curSkill = GameWorld.GetGameData().GetSkillBySkillID(delSkillID)
        if not curSkill:
            return
        delFightPower = curSkill.GetFightPower()
        mfpType = ChConfig.Def_SkillFuncType_MFPType.get(curSkill.GetFuncType(), ShareDefine.Def_MFPType_Role)
        skillMFP = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPSkill % mfpType)
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPSkill % mfpType, max(0, skillMFP - delFightPower))
        GameWorld.DebugLog("ˢм¼Äܸ½¼ÓÕ½¶·Á¦: delSkillID=%s,mfpType=%s,skillMFP=%s,delFightPower=%s" 
                           % (delSkillID, mfpType, skillMFP, delFightPower), curPlayer.GetPlayerID())
        
        if isRefreshState:
            # Èç¹ûÐèҪͬ²½ÅÅÐаñµÄ»°ÏÈÇ¿ÖÆË¢ÊôÐÔ
            self.RefreshPlayerAttrState()
            
        return
    
    ## ¼ÆËã±»¶¯buffÊôÐÔ¼Ó³É
    #  @param self ÀàʵÀý
    #  @return 
    def CalcPassiveBuffAttr(self):
        #=======================================================================
        # curPlayer = self.__Player
        # allAttrListPassive = [{} for i in range(4)]
        # SkillShell.CalcCurBuffer_Effect(curPlayer.GetPassiveBuf(), curPlayer, allAttrListPassive)
        # SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_PassiveBuf, allAttrListPassive)
        #=======================================================================
        return
    
    ## //A3 A1 ¸÷¹¦ÄÜÄ£¿éÕ½¶·Á¦ÐÅÏ¢ #tagMCModuleFightPowerInfo
    #  @param curPlayer Íæ¼Ò
    #  @return None
    def SendModuleFightPowerPack(self, curPlayer, mfpDict):
        mfpDataList = []
        totalFightPower = 0
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Õ½Á¦¹¦Äܵã: %s" % ChConfig.MFPTypeAttrFuncIndexDict, playerID)
        GameWorld.DebugLog("Ä£¿éÕ½Á¦: %s" % mfpDict, playerID)
        for mfpType, fightPower in mfpDict.items():
            SetMFPFightPower(curPlayer, mfpType, fightPower)
            mfpData = ChPyNetSendPack.tagMCModuleFightPower()
            mfpData.Clear()
            mfpData.MfpType = mfpType
            mfpData.FightPower = fightPower # µ±Ç°Ä£¿éÕ½¶·Á¦ÊýÖµ
            mfpDataList.append(mfpData)
            totalFightPower += fightPower # ÀÛ¼Ó×ÜÕ½¶·Á¦
            
        # //A3 A1 ¸÷¹¦ÄÜÄ£¿éÕ½¶·Á¦ÐÅÏ¢ #tagMCModuleFightPowerInfo
        mfpInfo = ChPyNetSendPack.tagMCModuleFightPowerInfo()
        mfpInfo.Clear()
        
        mfpInfo.TotalFightPower = totalFightPower % ChConfig.Def_PerPointValue
        mfpInfo.TotalFightPoweEx = totalFightPower / ChConfig.Def_PerPointValue
        mfpInfo.MFPCnt = len(mfpDataList)
        mfpInfo.MFPList = mfpDataList
        NetPackCommon.SendFakePack(curPlayer, mfpInfo)
        beforeFightPower = GetFightPower(curPlayer)
        SetFightPower(curPlayer, totalFightPower)
        if totalFightPower < beforeFightPower:
            DataRecordPack.DR_FightPowerChangeInfo(curPlayer, beforeFightPower)
        highestFightPower = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FightPower_Highest, 0,
                                                           ChConfig.Def_PDictType_FightPower)
        highestFightPower += curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FightPower_HighestEx, 0, 
                                                            ChConfig.Def_PDictType_FightPower) * ChConfig.Def_PerPointValue
        if totalFightPower > highestFightPower:
            highestFightPower = totalFightPower
            NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_Highest, highestFightPower % ChConfig.Def_PerPointValue,
                                 ChConfig.Def_PDictType_FightPower)
            NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_HighestEx, highestFightPower / ChConfig.Def_PerPointValue,
                                 ChConfig.Def_PDictType_FightPower)
        GameWorld.DebugLog("×ÜÕ½Á¦: %s, ÀúÊ·×î¸ßÕ½Á¦: %s, beforeFightPower=%s" % (totalFightPower, highestFightPower, beforeFightPower), playerID)
        PlayerBillboard.UpdatePlayerFPTotalBillboard(curPlayer)
        # ¼Ç¼¿ª·þ»î¶¯Êý¾Ý£¬¿ª·þ»î¶¯Ç°XÌìÀíÂÛÉϲ»»á³¬¹ý20E£¬Ôݲ»´¦Àí
        OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_FightPower, min(totalFightPower, ChConfig.Def_UpperLimit_DWord))
        if beforeFightPower != totalFightPower:
            CrossPlayerData.OnPlayerFightPowerChange(curPlayer)
        return
    
    def __RefreshMoveSpeed(self, allAttrListBuffs):
        ## Ë¢ÐÂÒƶ¯ËÙ¶È
        curPlayer = self.__Player
        playerID = curPlayer.GetPlayerID()
        
        moveSpeedFormat = IpyGameDataPY.GetFuncCfg("MoveSpeed")
        
        if PlayerTruck.GetHaveAutoTruck(curPlayer):
            speed = IpyGameDataPY.GetFuncCfg("MoveSpeed", 3)
            GameWorld.DebugLog("ÔËïڹ̶¨ËÙ¶ÈÖµ: speed=%s" % speed, playerID)
        else:
            speed = GetSpeedNotBuff(curPlayer)
            GameWorld.DebugLog("¹¦ÄÜÒƶ¯ËÙ¶ÈÖµ: speed=%s" % speed, playerID)
            
            # Æï³Ë״̬¼ÓÉÏÆï³Ë¸½¼ÓËÙ¶È
            if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse:
                speedHorse = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SpeedHorse)
                speed += speedHorse
                GameWorld.DebugLog("    Æï³Ë״̬¸½¼ÓÖµ: %s, speed=%s" % (speedHorse, speed), playerID)
            
                
            buffBattleAttr = allAttrListBuffs[ChConfig.CalcAttr_Battle]
            buffBattleNolineAttr = allAttrListBuffs[ChConfig.CalcAttr_BattleNoline]
            #buffËÙ¶È¼Ó³É     
            buffSpeed = buffBattleAttr.get(ChConfig.TYPE_Calc_AttrSpeed, 0)
            buffSpeedPer = buffBattleNolineAttr.get(ChConfig.TYPE_Calc_AttrSpeed, 0)
            
            if buffSpeed or buffSpeedPer:
                speed = int(speed * (ShareDefine.Def_MaxRateValue + buffSpeedPer) / float(ShareDefine.Def_MaxRateValue) + buffSpeed)
                GameWorld.DebugLog("    buffÓ°ÏìºóËÙ¶ÈÖµ: speed=%s,buffSpeedPer=%s,buffSpeed=%s" % (speed, buffSpeedPer, buffSpeed), playerID)
                
            speed = max(speed, 0)   #·ÀСÓÚ0´íÎó
        if GetSpeedValue(curPlayer) != speed:
            SetSpeedValue(curPlayer, speed)
            moveSpeed = eval(FormulaControl.GetCompileFormula("MoveSpeed", moveSpeedFormat))
            curPlayer.SetSpeed(moveSpeed)
            GameWorld.DebugLog("¹«Ê½¼ÆËãºóÒƶ¯ÆµÂÊ: moveSpeed=%s ºÁÃë/¸ñ" % moveSpeed, playerID)
            
            fightPet = curPlayer.GetPetMgr().GetFightPet()
            #ÎÞ³öÕ½³èÎï
            if fightPet:
                fightPet.SetSpeed(moveSpeed)
                
        return

    ##ˢй¥»÷¼ä¸ô
    # @param self ÀàʵÀý
    # @return None
    def __SetAtkInterval(self):
        curPlayer = self.__Player
        
        atkSpeed = GetAtkSpeed(curPlayer)
        
        formula = IpyGameDataPY.GetFuncCfg("AtkInterval")
        atkInterval = 0 if not formula else eval(FormulaControl.GetCompileFormula("AtkInterval", formula))
        curPlayer.SetAtkInterval(atkInterval)
        return
    
    
    ## Ë¢ÐÂÍæ¼ÒËùÓÐÐÐΪBUFF״̬
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÍæ¼ÒËùÓÐÐÐΪBUFF״̬
    def RefreshPlayerActionState(self):
        curPlayer = self.__Player
        playerID = curPlayer.GetPlayerID()
        GameWorld.DebugLog("Start RefreshPlayerActionState!!!", playerID)
        #curTime = time.clock()
        
        #ÏÈÇå³ýËùÓÐ״̬
        OperControlManager.ClearObjActionState(curPlayer)
        
        #ÔÙ¸ù¾ÝBUFF ¼ÓÉÏ״̬
        SkillShell.CalcBuffer_ActionState(curPlayer)
    
    #---------------------------------------------------------------------
    ## Ë¢ÐÂѪÁ¿ºÍħ
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂѪÁ¿ºÍħ
    def __RestoreHPMP(self):
        curPlayer = self.__Player
        
        if not curPlayer.GetInitOK():
            #Íæ¼Òδ³õʼ»¯³É¹¦, ²»ÐÞÕýѪÁ¿ºÍħ·¨Öµ, Òò´ËʱÓпÉÄÜÒòΪijЩӰÏìÖ÷½ÇµÄÎïƷδ³õʼ»¯Íê±Ï(Èç³èÎï×°±¸)
            return
        
        curPlayerHP = GameObj.GetHP(curPlayer)
        curPlayerMaxHP = GameObj.GetMaxHP(curPlayer)
        #=======================================================================
        # curPlayerMP = curPlayer.GetMP()
        # curPlayerMaxMP = curPlayer.GetMaxMP()
        #=======================================================================
        
        if curPlayerHP > curPlayerMaxHP:
            GameObj.SetHPFull(curPlayer)
        
        #=======================================================================
        # if curPlayerMP > curPlayerMaxMP:
        #    curPlayer.SetMP(curPlayerMaxMP)
        #=======================================================================

        return
    #---------------------------------------------------------------------
    ## ³õʼ»¯Íæ¼Ò»ù±¾×´Ì¬ ÕâÀï²»¶Ô£¨ ¼ÆËãÏÖÓÐÕ½¶·ÊôÐÔÖеÄÔªËؽøÐд¦Àí £©
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks ³õʼ»¯Íæ¼Ò»ù±¾×´Ì¬ ÕâÀï²»¶Ô£¨ ¼ÆËãÏÖÓÐÕ½¶·ÊôÐÔÖеÄÔªËؽøÐд¦Àí £©
    def InitPlayerState(self):
        curPlayer = self.__Player
        #Çå¿ÕÕ½¶·ÊôÐÔ //Õ½¶·ÊôÐÔÉèÖÃÊýֵΪ0µÄ, ÓÉC++´¦Àí ÈçÔªËØÊôÐÔ,ÃüÖеÈ
        curPlayer.ClearBattleEffect()
        
        initAttrDict = {
                        #ChConfig.TYPE_Calc_AttrCurSTR:curPlayer.GetBaseSTR(),
                        #ChConfig.TYPE_Calc_AttrCurPNE:curPlayer.GetBasePNE(),
                        #ChConfig.TYPE_Calc_AttrCurPHY:curPlayer.GetBasePHY(),
                        #ChConfig.TYPE_Calc_AttrCurCON:curPlayer.GetBaseCON(),
                        #ChConfig.TYPE_Calc_AttrSpeed:curPlayer.GetBaseSpeed(),
                        ChConfig.TYPE_Calc_AttrAtkSpeed:ChConfig.Def_BaseAtkSpeed,
                        ChConfig.TYPE_Calc_AttrFightExpRate:GameWorld.GetGameWorld().GetExpRate(),
                        ChConfig.TYPE_Calc_AttrGameExpRate:GameWorld.GetGameWorld().GetExpRate(),
                        ChConfig.TYPE_Calc_AttrPetExpRate:GameWorld.GetGameWorld().GetExpRate(),
                        ChConfig.TYPE_Calc_HitSucessRate:ChConfig.Def_MaxRateValue,
                        ChConfig.TYPE_Calc_CurePer:ChConfig.Def_MaxRateValue,
                        ChConfig.TYPE_Calc_YinjiTime:IpyGameDataPY.GetFuncCfg('Yinji', 1),  # ÿXÃë×Ô¶¯Ïûʧһ¸öÓ¡¼Ç
                        }
        
        for i in xrange(1, ChConfig.Def_Calc_AllAttrType_MAX):
            if i in [ChConfig.TYPE_Calc_AttrHP, ChConfig.TYPE_Calc_AttrMP, ChConfig.TYPE_Calc_ProDef]:
                continue
            value = 0 if i not in initAttrDict else initAttrDict[i]
            EffGetSet.SetValueByEffIndex(curPlayer, i, value)
            
        #³õʼ»¯Ê°È¡¾àÀë
        if curPlayer.GetPickupDist() != ChConfig.Def_RolePickupItemDist:
            curPlayer.SetPickupDist(ChConfig.Def_RolePickupItemDist)
            
        #Íæ¼Ò³õʼ»¯¿É¹¥»÷
        if not curPlayer.GetCanAttack():
            curPlayer.SetCanAttack(True)
            
        #³õʼ»¯Áé¸ù
        SetMetal(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Metal))
        SetWood(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Wood))
        SetWater(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Water))
        SetFire(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Fire))
        SetEarth(curPlayer, curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % ShareDefine.Def_Effect_Earth))
        return True
    
    #---------------------------------------------------------------------
    ## ³õʼ»¯³¡¾°buff
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks ³õʼ»¯³¡¾°buff
    def InitMapBuffState(self):
        curPlayer = self.__Player
        
        #³õʼ»¯ÇøÓò, ĬÈÏΪÆÕͨÇøÓò
        if GameMap.GetAreaTypeByMapPos(curPlayer.GetPosX(), curPlayer.GetPosY()) != IPY_GameWorld.gatNormal:
            curPlayer.SetAreaType(IPY_GameWorld.gatNormal)
            
        return
    
    #---------------------------------------------------------------------
    ## ½«Íæ¼ÒÉèÖõ½ÖØÉúµã
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks ½«Íæ¼ÒÉèÖõ½ÖØÉúµã
    def SetToBornPlace(self):
        curPlayer = self.__Player
        mapFBType = GameWorld.GetMap().GetMapFBType()
        #Íæ¼Ò²»ÔÚ¸±±¾ÖÐ
        if mapFBType == IPY_GameWorld.fbtNull:
#            gameMap = GameWorld.GetMap()
#            rebornMapID = gameMap.GetRebornMapID()
#            rebornPosX = gameMap.GetRebornMapX()
#            rebornPosY = gameMap.GetRebornMapY()
#            
#            #ÑéÖ¤ÊÇ·ñ±¾µØͼ¸´»îµã ½øÐÐÂß¼­´¦Àí
#            if gameMap.GetMapID() == rebornMapID:
#                posX, posY = GameMap.GetNearbyPosByDis(rebornPosX, rebornPosY, ChConfig.Def_RebornPos_Area_Range)
#            else:
#                posX, posY = rebornPosX, rebornPosY
#                
#            #ÕÒ²»µ½·ÇÕÏ°­µã¸´»î£¬ÔòÉèΪÍæ¼ÒµÄÖØÉúµã¸´»î
#            if posX <= 0 or posY <= 0 or rebornMapID <= 0:
#                rebornMapID = curPlayer.GetRebornMapID()
#                posX = curPlayer.GetRebornPosX()
#                posY = curPlayer.GetRebornPosY()
            rebornMapID = curPlayer.GetRebornMapID()
            rebornPosX = curPlayer.GetRebornPosX()
            rebornPosY = curPlayer.GetRebornPosY()

        #Íæ¼ÒÔÚ¸±±¾ÖÐ
        else:
            rebornMapID = curPlayer.GetFBRebornMapID()
            rebornPosX = curPlayer.GetFBRebornPosX()
            rebornPosY = curPlayer.GetFBRebornPosY()
        
        if rebornMapID == 0:
            NotifyCode(curPlayer, "ObjectMapNonentity")
            GameWorld.Log("ÈËÎïÖØÉúµØͼID = %sÒì³£!" % (rebornMapID) , curPlayer.GetPlayerID())
            return
        
        if rebornMapID == curPlayer.GetMapID():
            GameWorld.ResetPlayerPos(curPlayer, rebornPosX, rebornPosY)
            return
        
        #°ÑÈËÎïÉèÖûØÖØÉúµã
        PlayerResetWorldPos(curPlayer, rebornMapID, rebornPosX, rebornPosY, False)
        return
    
    #---------------------------------------------------------------------
    ## Íæ¼ÒËÀÍöÂß¼­
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Íæ¼ÒËÀÍöÂß¼­
    def SetDead(self):
        #Ö÷½ÇÉèÖÃΪËÀÍö״̬
        curPlayer = self.__Player
        
        #֪ͨ¸±±¾Íæ¼ÒËÀÍö
        FBLogic.DoPlayerDead(curPlayer)
        
        #Íæ¼Ò״̬´¦Àí
        ReSetPlayerState(curPlayer)
        
        #Çå¿ÕËùÓÐËÀÍö²»±£ÁôµÄbuff
        self.__PlayerDeadClearBuff()

        #ɱËÀËùÓÐÕÙ»½µÄÁé
        KillPlayerSummonNPC(curPlayer)
        
        #ÕÙ»½»Ø³öÕ½µÄ³èÎï
        PetControl.ReCallFightPet(curPlayer)
        
        #À­ïÚÍæ¼ÒËÀÍö´¦Àí
        PlayerTruck.DoPlayerDead(curPlayer)
        #Çå¿ÕʹÓü¼ÄܼǼ
        curPlayer.ClearUseSkillRec()
        
        #¸ÄΪ¸´»îµÄʱºòË¢ÐÂ״̬
#===============================================================================
#        #Ë¢ÐÂ״̬
#        self.RefreshAllState()
#===============================================================================
        
        if GameObj.GetHP(curPlayer) != 0:
            GameObj.SetHP(curPlayer, 0)
        
        #Çå¿ÕÒƶ¯´íÎó¾àÀë
        GameWorld.ClearPlayerPosCount(curPlayer)
        
        #¼Ç¼Ö÷½ÇËÀÍö´ÎÊýºÍËÀÍöʱ¼ä
        self.SetPlayerDeadCnt(curPlayer)
        
        #ËÀÍö´¥·¢¼¼ÄÜ
        tick = GameWorld.GetGameWorld().GetTick()
        
        #֪ͨËÀÍö
        DoPlayerDead(curPlayer)
        
        #PlayerTJG.PlayerTJGReborn(curPlayer, tick)
        GameObj.ClearPyPlayerState(curPlayer)
        
        MirrorAttack.OnPlayerDead(curPlayer)
        return
    
    
    ## ¼Ç¼Ö÷½ÇËÀÍö´ÎÊý
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    def SetPlayerDeadCnt(self, curPlayer):
        #playerLv = curPlayer.GetLV()
        #¼Ç¼ËÀÍöʱ¼ä
        NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_DeadTime, int(time.time()))
        #ÉíÉÏÓÐ5²ã¸´»îÆ£ÀÍbuffʱÔټǼ
        findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]
        if not (findBuff and findBuff.GetSkill().GetSkillLV() == findBuff.GetSkill().GetSkillMaxLV()):
            return
        
#        if playerLv < int(ReadChConfig.GetEvalChConfig('BeginRecordDeadCntLV')):
#            return
        
        #ÉϴμǼµÄÍæ¼ÒËÀÍö´ÎÊý
#         lastDeadCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PlayerDeadCnt)
#         #GameWorld.Log("ÉÏ´ÎÍæ¼ÒËÀÍö´ÎÊý=%s"%lastDeadCnt)
#         
#         #ËÀÍö´ÎÊý×î´óÀÛ¼ÓÖµ
#         maxDeadCnt = int(ReadChConfig.GetEvalChConfig('PlayerDeadMaxCnt'))
#         
#         #»ñÈ¡ÉÏ´ÎËÀÍöʱ¼ä
#         lastDeadTimeTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)
#         #GameWorld.Log("»ñÈ¡ÉÏ´ÎËÀÍöʱ¼ä=%s"%lastDeadTimeTick)
#         
#         #ÿ¸ô¼¸ºÁÃë¼õÒ»´ÎËÀÍö´ÎÊý
#         timeSpace = int(ReadChConfig.GetEvalChConfig('DelDeadCntTime')) 
#         
#         #µ±Ç°Ê±¼ä
#         curGameWorldTick = int(time.time())
#         delCnt = max(curGameWorldTick - lastDeadTimeTick, 0) / timeSpace
#         
#         #GameWorld.Log("###delCnt=%s"%delCnt)
#         #µ±Ç°ËÀÍö´ÎÊý(°üÀ¨Õâ´ÎËÀµÄ)
#         curDeadCnt = min(max(lastDeadCnt - delCnt, 0) + 1, maxDeadCnt)
#         
#         #GameWorld.Log("###curDeadCnt=%s"%curDeadCnt)
#         #GameWorld.Log("###curTimeTick=%s"%curGameWorldTick)
#         #¼Ç¼µ±Ç°ËÀÍö´ÎÊý
#         NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PlayerDeadCnt, curDeadCnt)
        
        #֪ͨËÀÍöʱ¼ä
        self.NotifyPlayerDeadTime(curPlayer)
        return
    
    ## ֪ͨÉÏ´ÎËÀÍöʱ¼ä
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Íæ¼ÒËÀÍöÂß¼­, ºìÃûµôÂä
    def NotifyPlayerDeadTime(self, curPlayer):
        #Èç¹ûÓÐ5²ã¸´»îÆ£ÀÍbuff ²¢ÇÒÊDZ»Íæ¼ÒɱËÀµÄÔò֪ͨ
        findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]
        if findBuff and findBuff.GetSkill().GetSkillLV() == findBuff.GetSkill().GetSkillMaxLV():
            if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_IsAddReviveTired):
                lastDeadTimeTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)
                packData = ChPyNetSendPack.tagMCPlayerDeadTime()
                packData.DeadTime = lastDeadTimeTick
                NetPackCommon.SendFakePack(curPlayer, packData)
        return
    
    #---------------------------------------------------------------------
    ## Çå¿ÕËùÓеĿÉÒÔɾ³ýµÄbuff
    #  @param self ÀàʵÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Çå¿ÕËùÓеĿÉÒÔɾ³ýµÄbuff
    def __PlayerDeadClearBuff(self):
        curPlayer = self.__Player
        tick = GameWorld.GetGameWorld().GetTick()
        
        #ÐèÒª¿¼ÂÇbuff,deBuff,aura,incBuff,mapBuff,³ýÁËequipBuff²»¿¼ÂÇ
        PlayerClearBuff_Single(curPlayer, curPlayer.GetBuffState(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetDeBuffState(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetAura(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetIncBuff(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetMapBuff(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetActionBuffManager(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessBuffState(), ClearBuffByDie, tick)
        PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessDeBuffState(), ClearBuffByDie, tick)
        
        return
    
#---------------------------------------------------------------------
## Çå¿Õbuff(²ÎÊý -> buff¹ÜÀíÆ÷)
#  @param curPlayer Íæ¼ÒʵÀý
#  @param buffState buff¹ÜÀíÆ÷
#  @param tick ʱ¼ä´Á
#  @return ·µ»ØÖµÎÞÒâÒå
#  @remarks Çå¿Õbuff(²ÎÊý -> buff¹ÜÀíÆ÷)
def PlayerClearBuff_Single(curPlayer, buffState, funcClearBuff, tick):

    curPlayerID = curPlayer.GetPlayerID()
    index = 0
    buffSkillIDList = []
    
    passiveEff = PassiveBuffEffMng.GetPassiveEffManager().GetPassiveEff(curPlayer)
    while index < buffState.GetBuffCount():
        curBuff = buffState.GetBuff(index)
        #Òì³£
        if not curBuff:
            GameWorld.Log("###Íæ¼ÒÇå¿Õbuffʧ°Ü,Ë÷Òý = %s" % (index), curPlayerID)
            index += 1
            continue
        
        #buff²»Ïûʧ
        if funcClearBuff and funcClearBuff(curBuff):
            index += 1
            continue
        
        #BuffSkill.DoBuffDisApper(curPlayer, curBuff, tick)
        #buffSkillIDList.append([curBuff.GetSkill().GetSkillID(), curBuff.GetOwnerID(), curBuff.GetOwnerType()])
        buffSkillIDList.append(curBuff.GetSkill().GetSkillID())
        #GameWorld.DebugLog("ËÀÍöÇåÀí-----%s"%curBuff.GetSkill().GetSkillID())
        if passiveEff:
            passiveEff.DelBuffInfo(curBuff.GetSkill())
            
        #ɾ³ýÕâ¸öbuff
        buffState.DeleteBuffByIndex(index)
        
        
    SkillShell.ClearBuffEffectBySkillIDList(curPlayer, buffState, buffSkillIDList)
    return


## ËÀÍöbuffÊÇ·ñÏûʧ
#  @param curBuff: buffʵÀý
#  @return: ËÀÍöbuffÊÇ·ñÏûʧ
def ClearBuffByDie(curBuff):
    skill = curBuff.GetSkill()
    return skill.GetDieContinue() & Def_Buff_Clear_Die > 0


## ÏÂÏßbuffÊÇ·ñÏûʧ
#  @param curBuff: buffʵÀý
#  @return: ËÀÍöbuffÊÇ·ñÏûʧ
def ClearBuffByDisconnect(curBuff):
    skill = curBuff.GetSkill()
    return skill.GetDieContinue() & Def_Buff_Clear_Disconnect > 0
            
#---------------------------------------------------------------------
##´«Ëͼì²é(ÊÇ·ñ·Ç·¨µØͼ)
# @param curPlayer Íæ¼ÒʵÀý
# @param destMapID Ä¿±êµØͼID
# @return ·µ»ØÖµÕæ, ͨ¹ý
# @remarks ´«Ëͼì²é
def CheckTagCountry(curPlayer, destMapID):
    gameMap = GameWorld.GetMap()
    
    if not gameMap.IsMapIDExist(destMapID):
        GameWorld.ErrLog('###·Ç·¨µØͼÊý¾Ý£¬mapID: %s' % (destMapID), curPlayer.GetPlayerID())
        NotifyCode(curPlayer, "ObjectMapNonentity")
        return False
    
#===============================================================================
#    #ÐÂÊִ峡¾°²»ÔÊÐí½øÈëºÍ´«³ö
#    if GameWorld.GetMap().GetMapID() == 21 or destMapID == 21:
#        NotifyCode(curPlayer, "CS_VillageHead_Fail")
#        return 
#===============================================================================
    
    #¼ì²éÍæ¼ÒÊÇ·ñ´«Ë͵йú×ø±ê
    mapCountry = gameMap.GetCountryByMapID(destMapID)
    
    if not GameWorld.IsSameCountry_Name(mapCountry, curPlayer.GetCountry()):
        NotifyCode(curPlayer, "Enemy_State_No_Trans")
        return False
    
    #¼ì²é´«ËÍÖÁµÄµØͼÊÇ·ñÊÇÆÕͨµØͼ
    if gameMap.GetMapFBTypeByMapID(destMapID) != IPY_GameWorld.fbtNull:
        #¸±±¾ºÍ»î¶¯³¡¾°ÎÞ·¨´«ËÍ
        NotifyCode(curPlayer, "Carry_lhs_306641")
        return False
    
    #¼ì²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
    if not CanEnterMap(curPlayer, destMapID):
        return False
    
    #¼ì²é´ËµØͼÊÇ·ñΪָ¶¨·ÖÁ÷ÓµÓеÄ
    mapLineID = GetPlayerLineID(curPlayer)
    
    mapLineCheckDict = ReadChConfig.GetEvalChConfig('TransportMapLineCheck')
    canEnterLineID = 0
    
    for lineID, mapIDList in mapLineCheckDict.items():
        if destMapID not in mapIDList:
            continue
        
        if mapLineID == lineID:
            #´Ë·ÖÁ÷¿ÉÒÔ½øÈë
            return True

        #¼Ç¼һÏ¿ÉÒÔ½øÈëµÄÏß·
        canEnterLineID = lineID

    if canEnterLineID > 0:
        #´Ë·ÖÁ÷²»¿É½øÈë
        NotifyCode(curPlayer, "Carry_yeqian_0", [destMapID, canEnterLineID])
        return False

    #¿ÉÒÔ½øÈë
    return True
#---------------------------------------------------------------------
##²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
# @param curPlayer Íæ¼ÒʵÀý
# @param destMapID Ä¿±êµØͼID
# @return ·µ»ØÖµÕæ, ͨ¹ý
# @remarks ²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
def CanEnterMap(curPlayer, destMapID, isShowSys=True):
    #µØͼÌØÊâ¼ì²é
    #if not CheckEquipCanTrans(curPlayer, destMapID):
        #return False
    
    if not CheckLVCanEnterMap(curPlayer, destMapID, isShowSys):
        return False
    
    return True

    
##²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
# @param curPlayer Íæ¼ÒʵÀý
# @param destMapID Ä¿±êµØͼID
# @return ·µ»ØÖµÕæ, ͨ¹ý
def CheckLVCanEnterMap(curPlayer, destMapID, isShowSys=True):
    mapData = GameWorld.GetGameData().GetChinMap().GetMapByID(destMapID)
    if not mapData:
        return 
    enterLV = mapData.GetLV()

    if curPlayer.GetLV() < enterLV:
        #¶Ô²»Æ𣬸ó¡¾°ÐèÒªXX¼¶²ÅÄܽøÈë!
        if isShowSys:
            NotifyCode(curPlayer, "Carry_hwj35_0", [enterLV])
        return False
    openMapStep = mapData.GetTreasureID() #ÐèÒªÍê³ÉµÄÖ÷ÏßÈÎÎñID
    if openMapStep and not IsMapOpen(curPlayer, openMapStep):
        #GameWorld.DebugLog('¶Ô²»Æ𣬸ó¡¾°destMapID=%sÐèÒªÍê³ÉÖ÷ÏßÈÎÎñ%s²ÅÄܽøÈë!' % (destMapID, openMapStep))
        return False
    return True


def IsMapOpen(curPlayer, openMapStep):
    # Ö÷ÏßÈÎÎñÍê³Éʱ»áÉèÖñêÖ¾¿É½øµØͼ±êÖ¾
    mission_1 = QuestCommon.GetCommonMission(curPlayer)
    if not mission_1:
        return False
    if openMapStep > mission_1.GetProperty("OpenMap"):
        return False
    return True

#---------------------------------------------------------------------
##¹ØÓÚ´«ËÍ ÑéÖ¤Íæ¼Ò״̬
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÕæ, ͨ¹ý
# @remarks ¹ØÓÚ´«ËÍ ÑéÖ¤Íæ¼Ò״̬
def CheckTransState(curPlayer):
    #¿ÉÒÔ½øÈë´«Ë͵Ä״̬
    playerAction = curPlayer.GetPlayerAction()
    if playerAction in ChConfig.Def_Player_Cannot_TransState:
        #Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
        NotifyCode(curPlayer, "Carry_lhs_697674")
        return False
    
    #Òƶ¯Öв»Ö´Ðд˲Ù×÷
    if curPlayer.IsMoving():
        curPlayer.StopMove()
    
    
    if playerAction == IPY_GameWorld.paSit:
        DoPlayerStand(curPlayer)
    
    #ÇëÇó´«ËÍ״̬, ÅжϷþÎñ¶ËÏÞÖÆ
    if not OperControlManager.IsObjCanDoAction(
                                        curPlayer,
                                        ChConfig.Def_Obj_ActState_ServerAct,
                                        IPY_GameWorld.oalTransmit
                                        ):
        return False
    
    return True 
#---------------------------------------------------------------------
##Çå³ýÓÐÏÞÎÞµÐBUF
# @param curPlayer Íæ¼ÒʵÀý
# @param tick ʱ¼ä´Á
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks Çå³ýÓÐÏÞÎÞµÐBUF
def DelLimitSuperBuff(curPlayer, tick):
    if curPlayer.GetCanAttack():
        return
    
    if not tick:
        tick = GameWorld.GetGameWorld().GetTick()
        
    if BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_LimitSuperBuff, tick):
    
        PlayerControl(curPlayer).RefreshPlayerAttrByBuff()
    
#---------------------------------------------------------------------
##ÌØÊâ״̬´¦Àí
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ÌØÊâ״̬´¦Àí
def ReSetPlayerState(curPlayer):
    tick = GameWorld.GetGameWorld().GetTick()
    
    #---Íæ¼Ò״̬´¦Àí---
    curPlayerAction = curPlayer.GetPlayerAction()
    
    #Íæ¼Ò½»Ò×ÖÐ, À뿪½»Ò×
    if curPlayerAction == IPY_GameWorld.paTrade:
        PlayerTrade.LeaveTrade(curPlayer, 0)
                    
    #Íæ¼Òʼþ״̬ÖÐ, Í˳öʼþ
    elif curPlayerAction == IPY_GameWorld.paEvent:
        EventShell.DoExitEvent(curPlayer)
        
    elif curPlayerAction == IPY_GameWorld.paGameEvent:
        PlayerGameEvent.StopGameEvent(curPlayer, tick)
        
    if curPlayerAction == IPY_GameWorld.paPreparing:
        DoExitPreparing(curPlayer)
    
    #---Íæ¼Ò½»Í¨¹¤¾ß´¦Àí---
    curPlayerVehicle = curPlayer.GetPlayerVehicle()
    
    #Íæ¼ÒÆïÂíÖÐ, ÏÂÂí
    if curPlayerVehicle == IPY_GameWorld.pvHorse:
        #Ö´ÐÐÏÂÂíÂß¼­
        PlayerHorse.PlayerRideHorseDown(curPlayer, False)
        
    #Íæ¼ÒïÚ³µÖÐ, ϳµ
    elif curPlayerVehicle == IPY_GameWorld.pvTruck:
        PlayerTruck.PlayerTruckDown(curPlayer, curPlayer.GetTruck())
    
    #---ÆäËûϵͳ´¦Àí---
    
    #ÖжÏÕ½¶·¶ÔÖÅ
    ExitPlayerConfronting(curPlayer)
    
    #Çå¿Õµ±Ç°¹¥»÷¶ÔÏó
    curPlayer.SetActionObj(None)
    return
#---------------------------------------------------------------------
##³õʼ»¯Öк͵Øͼ¶Áȡʱ²»À­»Ø
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ³õʼ»¯Öк͵Øͼ¶Áȡʱ²»À­»Ø
def __CanPullPlayer(curPlayer):
    if not curPlayer.GetInitOK():
        return False
    
    if curPlayer.GetIsLoginOff():
        return False
    
    return True
#------------------------------------------------------------------------------------ 
##·µ»ØÍæ¼Òµ±Ç°ÊÇ·ñÔÚ¿ÕÏÐ״̬
# @param curPlayer Íæ¼ÒʵÀý
# @return ÊÇ·ñÔÚ¿ÕÏÐ״̬
# @remarks ·µ»ØÍæ¼Òµ±Ç°ÊÇ·ñÔÚ¿ÕÏÐ״̬£¨²ß»®²ãÃæÉϵĿÕÏУ©
def IsPlanStateNull(curPlayer):
    
    #·Ç¿ÕÏÐ״̬
    if curPlayer.GetPlayerAction() != IPY_GameWorld.paNull:
        return False
    
    #Òƶ¯ÖÐ
    if curPlayer.IsMoving():
        return False
    
    #Õ½¶·ÖÐ
    if curPlayer.IsBattleState():
        return False
    
#    #¶ÔÖÅÖÐ
#    if curPlayer.GetIsConfronting():
#        return False
    
#    #Ñ£ÔÎÖÐ
#    if curPlayer.GetAbnormalState() == IPY_GameWorld.sctFaint:
#        return False
    
    return True
#------------------------------------------------------------------------------------
##³õʼ»¯Íæ¼Ò±³°ü.
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ³õʼ»¯Íæ¼Ò±³°ü
def Init_ItemPack(curPlayer):
    packType = IPY_GameWorld.rptItem
    
    #³õʼ»¯Íæ¼Ò±³°ü
    if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():
        return
    
    #»ñÈ¡Íæ¼Ò±³°ü
    curPack = curPlayer.GetItemManager().GetPack(packType)
    
    #ĬÈÏ14¸ñ×Ó + ¿ªÆôµÄ
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
    count = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName)
    curPack.SetCount(count)
        
    #֪ͨ¿Í»§¶Ë±³°ü¸ñ×ÓÊýÄ¿
#    curPlayer.Sync_ItemCount(curPack.GetCount())
    curPack.Sync_PackCanUseCount()
    return

#------------------------------------------------------------------------------------
##³õʼ»¯Íæ¼Ò²Ö¿â.
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ³õʼ»¯Íæ¼Ò²Ö¿â
def Init_Warehouse(curPlayer):
    
    packType = IPY_GameWorld.rptWarehouse
    
    #³õʼ»¯Íæ¼Ò±³°ü
    if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():
        return
    
    #»ñÈ¡Íæ¼Ò±³°ü
    curPack = curPlayer.GetItemManager().GetPack(packType)
    
    #ĬÈÏ42¸ñ×Ó + ¿ªÆôµÄ
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
    count = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName)
    
    curPack.SetCount(count)
    
    #֪ͨ¿Í»§¶Ë
    curPack.Sync_PackCanUseCount()
    return
    



##³õʼ»¯Ñ°±¦±³°ü
# @param curPlayer Íæ¼ÒʵÀý
# @return None
def Init_TreasurePack(curPlayer):
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptTreasure)
    curPack.SetCount(ItemCommon.GetPackInitCount(ShareDefine.rptTreasure))
    
    #֪ͨ¿Í»§¶Ë
    curPack.Sync_PackCanUseCount()
    return

##³õʼ»¯Íæ¼ÒÊÕÄɹñ
# @param curPlayer Íæ¼ÒʵÀý
# @param packType ±³°üÀàÐÍ
# @return ·µ»ØÖµÎÞÒâÒå
def Init_CabinetCountByType(curPlayer, packType):
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
    if keyName == None:
        GameWorld.ErrLog("Init_Pack Error type=%s" % packType)
        return
    
    #³õʼ»¯Ê±×°ÎäÆ÷±³°ü
    curPack = curPlayer.GetItemManager().GetPack(packType)
    #ĬÈÏ14¸ñ×Ó + ¿ªÆôµÄ
    count = ChConfig.Def_PackCnt_WeaponCoat + curPlayer.NomalDictGetProperty(keyName)
    curPack.SetCount(count)
    
    #֪ͨ¿Í»§¶Ë
    curPack.Sync_PackCanUseCount()
    return

#---------------------------------------------------------------------
def IsInOperationAction(curPlayer, actName, actIDKey, crossActName="", crossActIDKey=""):
    ## Íæ¼ÒÊÇ·ñÓÐÕýÔÚ½øÐÐÖÐÔËÓª»î¶¯£¬²»º¬²ÎÓë½áÊø½×¶Î
    
    if crossActName and crossActIDKey:
        playerActID = curPlayer.NomalDictGetProperty(crossActIDKey)
        actInfo = CrossRealmPlayer.GetPlayerCrossActInfo(curPlayer, crossActName)
        actID = actInfo.get(ShareDefine.ActKey_ID, 0)
        cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
        state = actInfo.get(ShareDefine.ActKey_State, 0)
        stateJoin = actInfo.get(ShareDefine.ActKey_StateJoin, 0)
        if state and stateJoin != ShareDefine.ActStateJoin_End and actID == playerActID:
            GameWorld.DebugLog("%s»î¶¯Íæ¼ÒÕýÔÚ²ÎÓëÖÐ! cfgID=%s,actID=%s,stateJoin=%s" 
                               % (crossActName, cfgID, actID, stateJoin), curPlayer.GetPlayerID())
            return True
        
    for actInfo in PyGameData.g_operationActionDict.get(actName, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        actID = actInfo.get(ShareDefine.ActKey_ID, 0)
        state = actInfo.get(ShareDefine.ActKey_State, 0)
        stateJoin = actInfo.get(ShareDefine.ActKey_StateJoin, 0)
        playerActID = curPlayer.NomalDictGetProperty(actIDKey % actNum)
        if state and stateJoin != ShareDefine.ActStateJoin_End and actID == playerActID:
            GameWorld.DebugLog("%sÍæ¼ÒÕýÔÚ²ÎÓëÖÐ! actNum=%s,actID=%s,stateJoin=%s" 
                               % (actName, actNum, actID, stateJoin), curPlayer.GetPlayerID())
            return True
        
    return False

def RefreshOperationAction_ExpRate():
    playerManager = GameWorld.GetPlayerManager()
    for i in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(i)
        if curPlayer == None or not curPlayer.GetInitOK():
            continue
        Sync_ExpRateChange(curPlayer)
    return

##֪ͨÍæ¼Ò¾­Ñ鱶ÂÊ
# @param curPlayer Íæ¼ÒʵÀý
# @return ·µ»ØÖµÎÞÒâÒå
# @remarks ֪ͨÍæ¼Ò¾­Ñ鱶ÂÊ
def Sync_ExpRateChange(curPlayer):
    totalExpRate = GetPlayerExpRate(curPlayer)
    fightExpRate = curPlayer.GetFightExpRate() # ϵͳ¼°¹¦ÄÜÀÛ¼Ó
    fightExpRate += PlayerWorldAverageLv.GetWorldAverageLvExpRate(curPlayer) # ÊÀ½çµÈ¼¶
    fightExpRate += PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_FightExpRate) # VIP¼Ó³É
    fightExpRate += PlayerGoldInvest.GetAddFightExpRate(curPlayer)
    
    actExpRateInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ExpRate, {})# ¶à±¶¾­Ñé»î¶¯¼Ó³É
    if not PlayerTJG.GetIsTJG(curPlayer) and actExpRateInfo.get(ShareDefine.ActKey_State):
        actExpIpyData = IpyGameDataPY.GetIpyGameData("ActExpRate", actExpRateInfo.get(ShareDefine.ActKey_CfgID))
        if actExpIpyData and curPlayer.GetLV() >= actExpIpyData.GetLVLimit():
            fightExpRate += actExpIpyData.GetAddExpRate()
            
    if curPlayer.GetMapID() not in [ChConfig.Def_FBMapID_FamilyInvade]: #ÊØÎÀÈ˻ʲ»¼Ó×é¶Ó¼Ó³É
        fightExpRate += curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TeamExpRate) # ×é¶Ó
    
    #µØͼ¶à±¶¾­Ñé¼Ó³É£¬Ä¬ÈÏÊÇ1±¶²»¼Ó³É
    mapExpAddMultiple = max(0, FBCommon.GetAreaRewardMultiple(curPlayer) - 1)
    fightExpRate += mapExpAddMultiple * ChConfig.Def_MaxRateValue
    
    if totalExpRate != fightExpRate:
        curPlayer.SetDict(ChConfig.Def_PlayerKey_TotalExpRate, fightExpRate)
        curPlayer.Sync_CurExpRate(fightExpRate)
    return

##»ñÈ¡Íæ¼ÒµÄ¾­Ñ鱶ÂÊ
def GetPlayerExpRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TotalExpRate)
def GetLimitExpRate(curPlayer, limitType=None):
    ''' »ñÈ¡ÊÜÏÞ¹¦ÄÜ×ܾ­Ñ鱶ÂÊ
    @param limitType: ÊÜÏ޵ŦÄÜÀàÐÍ
    '''
    totalExpRate = GetPlayerExpRate(curPlayer)
    if limitType == None:
        return totalExpRate
    
    # ¿Û³ýÔöÖµbuffÖжÔÓ¦ÏÞÖƵļӳÉ
    buffState = curPlayer.GetIncBuff()
    for i in xrange(buffState.GetBuffCount()):
        curBuff = buffState.GetBuff(i)
        buffSkill = curBuff.GetSkill()
        for j in range(buffSkill.GetEffectCount()):
            curEffect = buffSkill.GetEffect(j)
            effectID = curEffect.GetEffectID()
            if effectID == 0:
                break
            
            if effectID != ChConfig.TYPE_Calc_AttrFightExpRate:
                continue
            
            effExpRate = curEffect.GetEffectValue(0)
            calcType = curEffect.GetEffectValue(1)
            limitTypeValue = curEffect.GetEffectValue(2) # °´Î»¼ÆËã
            
            if calcType != ChConfig.EffCalcType_LinePlus or not limitTypeValue:
                continue
            
            if limitTypeValue & pow(2, limitType):
                totalExpRate -= effExpRate
                
    return totalExpRate

##¼Ç¼Íæ¼Òʧȥ½ðÇ®µÄÁ÷Ïò¼Ç¼£¬ÏûÏ¢Öлá¼Ç¼Íæ¼ÒÓµÓеĽðÇ®ÐÅÏ¢
# @param curPlayer Íæ¼ÒʵÀý
# @param moneyType ½ðÇ®ÀàÐÍ
# @param logIndex Á÷Ïò¼Ç¼Ë÷Òý
# @param tagID ÔÚ´ËÓÃÓڼǼÌرð±êʶ(ÎïÆ·ID£©
# @param par ÔÚ´ËÓÃÓڼǼ½ð¶î
# @param msg ¼Ç¼ÌرðµÄÐÅÏ¢
# @return None 
def DataServerMoneyLog(curPlayer, moneyType, logIndex, tagID=0, par=0, msg=""):
    return

#===============================================================================
#---Íæ¼ÒÀ©Õ¹×Ö¶Î---

#---À©Õ¹×Ö¶Î2,3,5,9,12,13,14---
#---À©Õ¹×Ö¶Î1-Ö°Òµ½×¼¶£»4-µ±Ç°·À»¤Öµ£»6-Í­Ç®µã£»7-SPÕæÆøÖµ£»8-SPÕæÆøÖµÀ©Õ¹µã£»10-¿ç·þÔ¤ÈüÅÅλ£»11-¹Ù¾ôÐǼ¶£»---
# SetExAttr1 ~ SetExAttr14(DWORD uiExAttr10, bool bNotifyAll = false, bool bNotifyGameServer = false)
# @param bNotifyAll: ÊÇ·ñ¹ã²¥ËùÖÜΧÍæ¼Ò£¬Ä¬ÈÏfalse£¬Ö»»á·¢¸ø×Ô¼º
# @param bNotifyGameServer: ÊÇ·ñͬ²½GameServer£¬Ä¬ÈÏfalse
# SetExAttr15 ~ SetExAttr20(DWORD uiExAttr15) 
#     15~20À©Õ¹ÊôÐÔͬ²½·â°ü£º0309 Ñ¡½ÇµÇ¼¼ò¶ÌÐÅÏ¢¡¢0434 ÖÜΧÍæ¼Ò³öÏÖ¡¢0102 µÇ¼µØͼÍæ¼ÒÐÅÏ¢£»
#     ͬ²½Ç°¶Ë¼°GameServerÐèÒª×Ô¼ºÐ´Í¨Öª£¬ÉèÖú¯Êý×ÔÉí²»´ø֪ͨ²ÎÊý
#
# ·¢ËÍ0418°ü
# SendPropertyRefresh(int inputType, int inputValue, int inputValueEx, bool boardCast, bool includeSelf = true)
# @param : boardCast-ÊÇ·ñ¹ã²¥ÖÜΧÍæ¼Ò£»includeSelf-ÊÇ·ñ°üº¬×Ô¼º
#
# ֪ͨGsmeServer; 
# SendGameServerRefreshState(int inputType, int inputValue, int inputValueEx)

def SendPropertyRefresh(curPlayer, inputType, value, boardCast=False):
    ''' ·¢ËÍ0418°ü
    @param boardCast: ÊÇ·ñ¹ã²¥ÖÜΧÍæ¼Ò£¬Ò»¶¨»á·¢¸ø×Ô¼º
    '''
    curPlayer.SendPropertyRefresh(inputType, value % ShareDefine.Def_PerPointValue, value / ShareDefine.Def_PerPointValue, boardCast)
    return

def SendGameServerRefreshState(curPlayer, inputType, value):
    ## ͬ²½ÊôÐÔµ½GameServer IPY_GRefreshPlayerProperty
    curPlayer.SendGameServerRefreshState(inputType, value % ShareDefine.Def_PerPointValue, value / ShareDefine.Def_PerPointValue)
    return

# ½ûÑÔ Í¨ÖªgameServer
def SetGMForbidenTalk(curPlayer, value):
    ''' ÉèÖÃÊÇ·ñ½ûÑÔ
    @param value: 0-½â½û£»1-½ûÑÔ£»2-½ûÉ豸£»3-½âÉ豸
    
    ½ûÉ豸Á÷³Ì
    1.ÏÈÉèÖÃ2֪ͨǰ¶ËдÈë½ûÉ豸¼Ç¼£¨Ç°¶Ë´¦Àíµ±Îª2ʱ±¾µØÉ豸±ê¼ÇΪ½ûÉ豸£© 
    2.ÔÙÉèÖÃ1£¬´Ëʱǰºó¶Ë״̬¾ùΪ1£¬¼´½ÇÉ«½ûÑÔ
    
    ½â½ûÉ豸Á÷³Ì
    1.ÏÈÉèÖÃ3֪ͨǰ¶Ëɾ³ý½ûÉ豸¼Ç¼
    2.ÔÙÉèÖÃ0£¬´Ëʱǰºó¶Ë״̬¾ùΪ1£¬¼´½ÇÉ«½â½û
    '''
    __SetGMForbidenTalkValue(curPlayer, value)
    
    #ͬ²½ÉèÖÃÀëÏßDBÍæ¼ÒÕ˺Å״ֵ̬
    accState = curPlayer.GetAccState()
    if value == 2:
        accState = accState | pow(2, ChConfig.Def_PysForbidTalkDevice)
        accState = accState | pow(2, ChConfig.Def_PysForbidTalk)
    elif value == 1:
        accState = accState | pow(2, ChConfig.Def_PysForbidTalk)
    elif value == 3:
        if (accState & pow(2, ChConfig.Def_PysForbidTalkDevice)):
            accState = accState ^ pow(2, ChConfig.Def_PysForbidTalkDevice)
        if (accState & pow(2, ChConfig.Def_PysForbidTalk)):
            accState = accState ^ pow(2, ChConfig.Def_PysForbidTalk)
    elif (accState & pow(2, ChConfig.Def_PysForbidTalk)) > 0:
        accState = accState ^ pow(2, ChConfig.Def_PysForbidTalk)
    SetPlayerAccState(curPlayer, accState)
    return

def __SetGMForbidenTalkValue(curPlayer, value):
    curPlayer.SetGMForbidenTalk(value)
    SendGameServerRefreshState(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, value)
    GameWorld.DebugLog("__SetGMForbidenTalkValue %s" % value, curPlayer.GetPlayerID())
    return

def SetPlayerAccState(curPlayer, accState):
    curPlayer.SetAccState(accState)
    curPlayer.SetExAttr17(accState) # ͬ²½ÉèÖøÃÖµ 0309 ·â°üµÇ¼ʱÐèÒªÓõ½
    SendGameServerRefreshState(curPlayer, ShareDefine.CDBPlayerRefresh_ExAttr17, accState)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ExAttr17, accState)
    GameWorld.DebugLog("SetPlayerAccState %s" % (accState), curPlayer.GetPlayerID())
    return

def DoGMForbidenTalkOnLogin(curPlayer):
    ## ÀëÏßʱ±»½ûÑÔ£¬´ËʱDBµÄÕ˺Å״ֵ̬Ϊ½ûÑÔ״̬£¬µ«ÊÇGMOperÔÝʱûÓнûÑÔ²Ù×÷ÃüÁ¹ÊÉÏÏßʱ¼ì²éÉèÖÃÏÂÀëÏß½ûÑÔ״̬
    ## Ä¿Ç°ÀëÏßʱ±»½ûÑԵģ¬ÔÝʱֻ´¦ÀíAccState ExAttr17, GMOperÃüÁîÔݲ»´¦Àí£¬ËùÒÔΪÓÀ¾Ã½ûÑÔ
    
    if curPlayer.GetAccState() & pow(2, ChConfig.Def_PysForbidTalkDevice):
        GameWorld.Log("ÉÏÏßʱ½ÇɫΪ±»É豸½ûÑÔ״̬!", curPlayer.GetPlayerID())
        __SetGMForbidenTalkValue(curPlayer, 2)
        __SetGMForbidenTalkValue(curPlayer, 1)
    elif curPlayer.GetAccState() & pow(2, ChConfig.Def_PysForbidTalk):
        GameWorld.Log("ÉÏÏßʱ½ÇɫΪ±»½ûÑÔ״̬!", curPlayer.GetPlayerID())
        __SetGMForbidenTalkValue(curPlayer, 1)
    else:
        SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, 0)
    return

## ЭÖúÄ¿±êÍæ¼ÒID
def SetAssistTagPlayerID(curPlayer, value):
    curPlayer.SetExAttr1(value, True, False) # ²»Í¨ÖªGameServer
    NPCHurtManager.OnSetAssistTagPlayerID(curPlayer, value)
    return
def GetAssistTagPlayerID(curPlayer): return curPlayer.GetExAttr1()

## ¶ÓÎéÏà¹ØÉóºË¿ª¹Ø״̬, joinReqCheck-Èë¶ÓÉêÇëÊÇ·ñÐèÒªÉóºË; inviteCheck-×é¶ÓÑûÇëÊÇ·ñÐèÒªÉóºË;
def SetTeamCheckStateEx(curPlayer, joinReqCheck, inviteCheck): return SetTeamCheckState(curPlayer, joinReqCheck * 10 + inviteCheck)
def SetTeamCheckState(curPlayer, checkState): return curPlayer.SetExAttr2(checkState, False, True)
def GetTeamCheckState(curPlayer): return curPlayer.GetExAttr2()

## ¸±±¾¹¦ÄÜÏß·ID, ÕâÀï×ödb´æ´¢£¬·ÀÖ¹Ôںϲ¢µØͼ¸±±¾ÖеôÏßÖØÉÏʱǰ¶ËÎÞ·¨¼ÓÔØÕýÈ·µÄ³¡¾°×ÊÔ´£¬µÇ¼¼ÓÔس¡¾°Ê±»úΪ0102°ü
def SetFBFuncLineID(curPlayer, funcLineID): return curPlayer.SetExAttr3(funcLineID, False, True)
def GetFBFuncLineID(curPlayer): return curPlayer.GetExAttr3()

## ¿ç·þ״̬ËùÔÚµØͼID: 0-·Ç¿ç·þ״̬£¬·Ç0-¿ç·þ״̬¶ÔÓ¦µÄµØͼID
def GetCrossMapID(curPlayer): return curPlayer.GetExAttr5()
def SetCrossMapID(curPlayer, value):
    curPlayer.SetExAttr5(value, False, True)
    if not value:
        CrossPlayerData.ClearCrossSyncDataCache(curPlayer)
    return

## Ç°¶Ë×Ô¶¨Ò峡¾°
def GetCustomMapID(curPlayer): return curPlayer.GetExAttr14() / 1000
def GetCustomLineID(curPlayer): return curPlayer.GetExAttr14() % 1000
## ×Ô¶¨Ò峡¾°ºó¶ËÅжÏÒѽáËãºóÐèÖ±½ÓÖØÖÃΪ0£¬·Àֹǰ¶ËûÓÐÍ˳ö³¡¾°Ö±½ÓÏÂÏßµ¼ÖÂÊý¾ÝûÓÐÖØÖ㬿ÉÄÜÒý·¢¿ÉÒÔÖظ´½ø
def SetCustomMap(curPlayer, mapID, lineID):
    value = mapID * 1000 + lineID
    if value != curPlayer.GetExAttr14():
        curPlayer.SetExAttr14(value, False, True)
    return

## Í­Ç®µã, Ö§³ÖÍ­Ç®³¬20ÒÚ
def GetSilver(curPlayer): return curPlayer.GetExAttr6() * ChConfig.Def_PerPointValue + curPlayer.GetSilver()
def SetSilver(curPlayer, totalSilver):
    silver = totalSilver % ChConfig.Def_PerPointValue
    silverPoint = min(totalSilver / ChConfig.Def_PerPointValue, ChConfig.Def_UpperLimit_DWord)
    if silver != curPlayer.GetSilver():
        curPlayer.SetSilver(silver)
    if silverPoint != curPlayer.GetExAttr6():
        curPlayer.SetExAttr6(silverPoint)
    return

##VIPµ½ÆÚʱ¼ä, ÐèҪͬ²½GameServer
def GetVIPExpireTime(curPlayer): return 0
def SetVIPExpireTime(curPlayer, expireTime): return

##×î½üÒ»´ÎÌáÉýVIPµÈ¼¶Ê±¼ä
def GetVIPLVUpTime(curPlayer): return curPlayer.GetExAttr9()
def SetVIPLVUpTime(curPlayer, lvUpTime): return curPlayer.SetExAttr9(lvUpTime, False, True)

##ÁÄÌìÆøÅÝ¿ò
def GetChatBubbleBox(curPlayer): return curPlayer.GetExAttr10()
def SetChatBubbleBox(curPlayer, value): return curPlayer.SetExAttr10(value, False, True)

##ÓÎÏ·³äÖµÖ§¸¶´ú±Ò
def GetPayCoinTotal(curPlayer): return GetPayCoin(curPlayer) + GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
def GetPayCoin(curPlayer): return curPlayer.GetExAttr11()
def SetPayCoin(curPlayer, value): return curPlayer.SetExAttr11(min(value, ChConfig.Def_UpperLimit_DWord), False, False)
def PayCoinOnDay(curPlayer):
    # ÿÈÕ¹ýÌìÇå³ýʱЧ´ú±Ò
    payCoinDay = GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
    if payCoinDay > 0:
        PayMoney(curPlayer, ShareDefine.TYPE_Price_PayCoin, payCoinDay, "PayCoinOnDay")
    return

## »ñÈ¡Åå´÷µÄ³ÆºÅID
def GetTitleID(curPlayer):
    curDienstgradMgr = curPlayer.GetDienstgradManager()
    return curDienstgradMgr.GetCurGradID()

##°éÂÂ
def GetCoupleID(curPlayer):
    coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
    return coupleInfo[0] if coupleInfo else 0
def GetCoupleName(curPlayer):
    coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
    return coupleInfo[1] if coupleInfo else ""
def GetCoupleJob(curPlayer):
    coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
    return coupleInfo[2] if coupleInfo else 1
def GetBridePriceMaxID(curPlayer):
    coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
    return coupleInfo[3] if coupleInfo else 0
def GetCoupleInfo(playerID):
    if playerID not in PyGameData.g_coupleInfo:
        return
    return PyGameData.g_coupleInfo[playerID]
def SetCoupleInfo(playerID, coupleInfo):
    if not coupleInfo:
        PyGameData.g_coupleInfo.pop(playerID, None)
    else:
        PyGameData.g_coupleInfo[playerID] = coupleInfo
    return

## Íæ¼ÒËùÊô·þÎñÆ÷×éID
def GetPlayerServerGroupID(curPlayer): return curPlayer.GetExAttr13()
def UpdPlayerServerGroupID(curPlayer):
    # ¸üÐÂ×Ô¼ºµÄ·þÎñÆ÷×éID, ¿ç·þ·þÎñÆ÷²»´¦Àí
    if GameWorld.IsCrossServer():
        return
    serverGroupID = GameWorld.GetServerGroupID()
    if not serverGroupID:
        return
    playerServerGroupID = curPlayer.GetExAttr13()
    if playerServerGroupID != serverGroupID:
        curPlayer.SetExAttr13(serverGroupID, False, True)
        GameWorld.DebugLog("¸üÐÂÍæ¼ÒËùÊô·þÎñÆ÷×éID: serverGroupID=%s" % serverGroupID)
    return

##Ó°ÏìÍâ¹ÛµÄ3²¿Î»Ë÷Òý¼Ç¼ 123456789  123:ÎäÆ÷¸ñ×ÓË÷Òý 456£º¸±ÊÖ  789£ºÒ·þ
def GetFaceEquipIndexList(curPlayer):
    attr15 = curPlayer.GetExAttr15()
    return [attr15%1000, attr15/1000%1000, attr15/1000000]
def SetFaceEquipIndex(curPlayer, value): return curPlayer.SetExAttr15(value)

# ·µ»Ø×î´óµÄÁé¸ùϵ
def GetLingGenMaxIndex(curPlayer):
    return curPlayer.GetExAttr16()

def SetLingGenMaxIndex(curPlayer):
    indexList = [
                    ShareDefine.Def_Effect_Metal, # ½ð
                    ShareDefine.Def_Effect_Wood, # ľ
                    ShareDefine.Def_Effect_Water, # Ë®
                    ShareDefine.Def_Effect_Fire, # »ð
                    ShareDefine.Def_Effect_Earth, # ÍÁ
                ]
    
    
    tempList = [curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % attrID) for attrID in indexList]
    
    curPlayer.SetExAttr16(indexList[tempList.index(max(tempList))])

# ¾³½çÄѶȵȼ¶
def GetRealmDifficulty(curPlayer): return curPlayer.GetExAttr18()
def SetRealmDifficulty(curPlayer, realmDifficulty):
    ''' ÉèÖþ³½çÄѶȵȼ¶£¬ÈκεØͼ¾ù¿ÉÑ¡Ôñ
    '''
    playerID = curPlayer.GetPlayerID()
    
    if realmDifficulty:
        needRealmLV = GetDifficultyRealmLV(realmDifficulty)
        curRealmLV = curPlayer.GetOfficialRank()
        if curRealmLV < needRealmLV:
            GameWorld.DebugLog("µ±Ç°¾³½çµÍÓÚ¾³½çÄѶȣ¬ÎÞ·¨Ñ¡Ôñ! curRealmLV(%s) < %s" % (curRealmLV, needRealmLV), playerID)
            return
        
        difficultyRealmList = IpyGameDataPY.GetFuncEvalCfg("RealmDifficulty", 2)
        if needRealmLV not in difficultyRealmList:
            GameWorld.ErrLog("realmDifficulty(%s) needRealmLV(%s) not in difficultyRealmList(%s)" 
                             % (realmDifficulty, needRealmLV, difficultyRealmList), playerID)
            return
        
    GameWorld.DebugLog("SetRealmDifficulty: realmDifficulty=%s" % realmDifficulty, playerID)
    realmMapIDList = IpyGameDataPY.GetFuncEvalCfg("RealmDifficulty", 1)
    mapID = curPlayer.GetMapID()
    if mapID in realmMapIDList:
        # ÏÈÒƳý֮ǰѡµÄÄѶÈ
        for playerIDList in PyGameData.g_realmDiffPlayerDict.values():
            if playerID in playerIDList:
                playerIDList.remove(playerID)
                
        # ¼ÓÈëÐÂÄѶȣ¬0ÄѶȲ»´¦Àí
        if realmDifficulty:
            if realmDifficulty not in PyGameData.g_realmDiffPlayerDict:
                PyGameData.g_realmDiffPlayerDict[realmDifficulty] = []
            playerIDList = PyGameData.g_realmDiffPlayerDict[realmDifficulty]
            if playerID not in playerIDList:
                playerIDList.append(playerID)
                
        SetPlayerSightLevel(curPlayer, realmDifficulty)
        
    if curPlayer.GetExAttr18() != realmDifficulty:
        curPlayer.SetExAttr18(realmDifficulty)
        SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ExAttr18, realmDifficulty)
    return
def GetDifficultyRealmLV(realmDifficulty): return realmDifficulty % 1000
def GetMapRealmDifficulty(curPlayer):
    ## »ñÈ¡Íæ¼ÒÔÚ±¾µØͼÖеľ³½çÄѶȲ㼶£¬±ØÐëÔÚ¾³½çµØͼÇÒÓÐÑ¡Ôñ¾³½çÄѶȲÅË㣬·ñÔòΪĬÈÏ0£»¸ÃÄѶÈֵͬʱҲÊÇÊÓÒ°²ã¼¶
    realmDifficulty = GetRealmDifficulty(curPlayer)
    if not realmDifficulty:
        return 0
    mapID = curPlayer.GetMapID()
    realmMapIDList = IpyGameDataPY.GetFuncEvalCfg("RealmDifficulty", 1)
    if mapID not in realmMapIDList:
        return 0
    return realmDifficulty

##Íæ¼ÒÀ뿪ÏÉÃËʱ¼ä£¨Ö÷¶¯»ò±»Ì߶¼Ë㣩
def GetLeaveFamilyTimeEx(curPlayer):return curPlayer.GetExAttr19()
def SetLeaveFamilyTimeEx(curPlayer, value):
    curPlayer.SetExAttr19(value)
    curPlayer.SendGameServerRefreshState(ShareDefine.CDBPlayerRefresh_ExAttr19, value, 0)
    curPlayer.SendPropertyRefresh(ShareDefine.CDBPlayerRefresh_ExAttr19, value, 0, False)
    return

##»ñµÃÍæ¼ÒÍþÍûÖµ
def GetPrestige(curPlayer): return 0
def SetPrestige(curPlayer, value): return

##×ÜÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E
def GetFightPower(curPlayer): return curPlayer.GetFightPowerEx() * ChConfig.Def_PerPointValue + curPlayer.GetFightPower()
def SetFightPower(curPlayer, value):
    curPlayer.SetFightPower(value % ChConfig.Def_PerPointValue, value / ChConfig.Def_PerPointValue, False) # ²»Í¨ÖªGameServer bNotifyGameServer False
    return

## ÉèÖÃÄ£¿éÕ½¶·Á¦£¬×î´ó20E
def SetMFPFightPower(curPlayer, mfpType, fightPower):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPFightPower % mfpType, min(fightPower, ChConfig.Def_UpperLimit_DWord))
    return

## »ñÈ¡Ä£¿éÕ½¶·Á¦
def GetMFPFightPower(curPlayer, mfpType):
    return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPFightPower % mfpType)

## ÉèÖÃÄ£¿é¸½¼ÓÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E
def SetMFPExFightPower(curPlayer, mfpType, fightPower):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPEx % mfpType, fightPower % ChConfig.Def_PerPointValue)
    curPlayer.SetDict(ChConfig.Def_PlayerKey_MFPExPoint % mfpType, fightPower / ChConfig.Def_PerPointValue)
    return

## »ñÈ¡Ä£¿é¸½¼ÓÕ½¶·Á¦
def GetMFPExFightPower(curPlayer, mfpType):
    return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPExPoint % mfpType) * ChConfig.Def_PerPointValue + \
        curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MFPEx % mfpType)
#===============================================================================
##»ñÈ¡Íæ¼Ò·ÖÏßÐÅÏ¢
# @param curPlayer Íæ¼ÒʵÀý
# @return Íæ¼Òµ±Ç°·ÖÏßID
# @remarks 
def GetPlayerLineID(curPlayer):
    return curPlayer.GetLineID() + 1


##ÊÓÒ°ÑéÖ¤, Íâ¹ÒÊÓÒ°±äС²»»Ö¸´
# @param curPlayer Íæ¼ÒʵÀý
# @param sight ÊÓÒ°·¶Î§
# @return ÎÞÒâÒå
def SetSight(curPlayer, sight):
    import QuestCommon
    firstMission = QuestCommon.GetCommonMission(curPlayer)
    if firstMission and firstMission.GetProperty(QuestCommon.Def_NewGuyNoSight) == 1:
        curPlayer.SetSight(0)
        return
    
    #Íâ¹ÒºÅ ÊÓÒ°ÑéÖ¤
    if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_AutoCheckHack_State) \
                                      == ChConfig.Def_AutoCheck_State_Danger:
        
        if curPlayer.GetSight() > sight:
            curPlayer.SetSight(sight)
        
        return
    
    curPlayer.SetSight(sight)

##»ñÈ¡¹¥»÷¼ä¸ô
# @param curPlayer Íæ¼ÒʵÀý
# @return ¹¥»÷¼ä¸ô
def GetAtkInterval(curPlayer):
    atkInterval = curPlayer.GetAtkInterval()
    
    #Íâ¹ÒºÅ ¹¥»÷¼ä¸ôÑéÖ¤
    if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_AutoCheckHack_State) \
                                      == ChConfig.Def_AutoCheck_State_Danger:
        atkInterval *= 100
    
    return atkInterval

def AddZhenQiByKillNPC(curPlayer, npcSP, killCount=1):
    ## ɱ¹Ö¼ÓÕæÆø
    if not npcSP:
        return
    addSPValue = npcSP * killCount
    npcSPRate = PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_NPCSPRate)
    
    if npcSPRate:
        npcHPRate = ChConfig.Def_MaxRateValue + npcSPRate
        addSPValue = int(addSPValue * npcHPRate / float(ChConfig.Def_MaxRateValue))
    PlayerAddZhenQi(curPlayer, addSPValue)
    return

##Íæ¼ÒÔö¼ÓÕæÆø
# @param curPlayer Íæ¼Ò
# @param value Ôö¼ÓÊýÖµ
# @param canOverbrim ¿É·ñÒç³ö(ĬÈϲ»ÐÐ) 
# @param isSysMsg ÊÇ·ñϵͳÌáʾ(ĬÈÏÐèÒª) 
# @return None
def PlayerAddZhenQi(curPlayer, addValue, canOverbrim=False, isSysMsg=True, eventName="unknown", eventData=""):
    if addValue <= 0:
        return True
    
    curZhenQi = GetZhenQi(curPlayer)  # µ±Ç°ÕæÆø
    
    value = curZhenQi + addValue
    
    if value == curZhenQi:
        #ÕæÆøֵûÓиıä
        return False
    
    #===============================================================================================
    # if isSysMsg:
    #    #GeRen_chenxin_254483:»ñµÃÕæÆøÖµXXµã
    #    NotifyCode(curPlayer, "GeRen_chenxin_254483", [addValue])
    #===============================================================================================
    
    SetZhenQi(curPlayer, value)
    #EventReport.WriteEvent_add_zhenqi(curPlayer, eventName, eventData, addValue, value)
    return True


##Íæ¼Ò¼õÉÙÕæÆø
# @param curPlayer Íæ¼Ò
# @param lostValue ¼õÉÙÊýÖµ
# @return None
def PlayerLostZhenQi(curPlayer, lostValue, eventName="unknown", eventData=""):
    if lostValue <= 0:
        return True
    
    curZhenQi = GetZhenQi(curPlayer)  # µ±Ç°ÕæÆø
    
    value = max(0, curZhenQi - lostValue)
    if value < 0:
        GameWorld.ErrLog("curZhenQi = %s, lostValue = %s" % (curZhenQi, lostValue))
        return False
    
    #GeRen_chenxin_365899:ÏûºÄÕæÆøÖµXXµã.
    #NotifyCode(curPlayer, "GeRen_chenxin_365899", [lostValue])
    
    SetZhenQi(curPlayer, value)
    
    #EventReport.WriteEvent_lost_zhenqi(curPlayer, eventName, eventData, lostValue, value)
    return True

## SPÕæÆøÖµ - ÔÝ·ÏÆú ExAttr7¡¢ExAttr8 ¸ÄΪר¾«Ñ¡Ôñ֪ͨ£¬ÓÃÓÚÇ°¶Ë±íÏÖÆäËûÍæ¼ÒµÄ²»Í¬×¨¾«ÌØЧ
def GetZhenQi(curPlayer): return 0 #curPlayer.GetExAttr8() * ChConfig.Def_PerPointValue + curPlayer.GetExAttr7()
def SetZhenQi(curPlayer, totalZhenQi):
#    zhenQi = totalZhenQi % ChConfig.Def_PerPointValue
#    zhenQiPoint = min(totalZhenQi / ChConfig.Def_PerPointValue, ChConfig.Def_UpperLimit_DWord)
#    # Íæ¼Òµ¥¶À֪ͨ£¬²»¹ã²¥; c++½Ó¿ÚĬÈϹ㲥£¬¹ÊÕâÀïÉèÖÃFalse
#    if zhenQi != curPlayer.GetExAttr7():
#        curPlayer.SetExAttr7(zhenQi)
#    if zhenQiPoint != curPlayer.GetExAttr8():
#        curPlayer.SetExAttr8(zhenQiPoint)
    return

#===============================================================================
# #@warning: ExAttr6~ExAttr10, ÐÂÔö2¸ö²¼¶ûĬÈϲÎÊý, ÊÇ·ñ֪ͨ¿Í»§¶Ë, ÊÇ·ñ֪ͨGameServer, ĬÈÏֵΪFalse
#===============================================================================
#---------------------------------------------------------------------------

##»ñÈ¡¿ÉÃâ·Ñ¿ªÆôµÄ¸ñ×ÓÊý
# @param curPlayer Íæ¼Ò¶ÔÏó
# @param packType ±³°üÀàÐÍ
# @param openCnt ʵ¼ÊÒª¿ªÆôµÄ¸ñ×ÓÊý
# @return »ñÈ¡¿ÉÃâ·Ñ¿ªÆôµÄ¸ñ×ÓÊý
def GetCanAutoOpenPackCount(curPlayer, packType, openCnt, tick):
    if packType not in [IPY_GameWorld.rptItem, IPY_GameWorld.rptWarehouse]:
        return 0
    cfgObj = PlayerExpandPackCfgMgr.GetExpandPackCfg(curPlayer, packType)
    #ÕÒ²»µ½ÕâÖÖ±³°üµÄÅäÖÃÐÅÏ¢¶ÔÏó
    if not cfgObj:
        return 0
    #ÒѹºÂò»ò×Ô¶¯¿ªÆôµÄ¸ñ×ÓÊý
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict[packType][ChConfig.Def_PlayerPackDict_Index_Key]
    curCount = curPlayer.NomalDictGetProperty(keyName)
    
#    nextCountIndex = curCount + 1
#    infoObj = cfgObj.GetAttrInfoByInex(nextCountIndex)
#    if None == infoObj:
#        return 0
#    #¸üÐÂÏÂÍæ¼ÒµÄÔÚÏßʱ¼ä
#    UpdateOnLineTime(curPlayer, tick)
#    onlineTime = curPlayer.GetOnlineTime()
#    #ÐèÒªµÄʱ¼ä
#    needOnlineTime = infoObj["OnlineTime"]
#    #×îºóÒ»´Î×Ô¶¯¿ªÆô±³°üµÄÔÚÏßʱ¼ätick
#    lastAutoOpenPackTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick)
#    if onlineTime - lastAutoOpenPackTick > needOnlineTime:
#        return 1
#    return 0
    
    #×î´ó¿ÉÔö¼ÓµÄ±³°üÊý
    maxCanAddCount = cfgObj.GetCanAddCount()
    forCount = min(openCnt, maxCanAddCount - curCount)
    
    #¿ÉÒÔÔÙÔö¼ÓµÄ¸ñ×ÓÊý
    count = 0
    #±éÀú¿ÉÔö¼ÓµÄ±³°ü¸ñ×ÓÊý
    UpdateOnLineTime(curPlayer, tick)
    onlineTime = curPlayer.GetOnlineTime()
    lastAutoOpenPackTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick % packType)
    lastInfoObj = cfgObj.GetTotalAddAttrInfoByCount(curCount)
    notOnlineTime = 0
    if lastInfoObj:
        notOnlineTime = lastInfoObj["OnlineTime"]
#    GameWorld.Log("get online time = %s"%onlineTime)
    for i in range(forCount):
        nextCount = curCount + i + 1
        infoObj = cfgObj.GetTotalAddAttrInfoByCount(nextCount)
        if None == infoObj:
            break
        # (СÓÚ0µÄ²»¾ßÓÐÃâ·Ñ¿ªÆô¹¦ÄÜ)
        if infoObj["OnlineTime"] < 0:
            continue
        needOnlineTime = infoObj["OnlineTime"] - notOnlineTime
#        GameWorld.Log("get need online time = %s"%needOnlineTime)
        #ÒªÇóµÄÔÚÏßʱ¼ä,´óÓÚµ±Ç°µÄÔÚÏßʱ¼ä,û°ì·¨¼Ó±³°ü¸ñ×Ó
        if needOnlineTime > onlineTime - lastAutoOpenPackTick:
            break
        count += 1
    return count



## »ñÈ¡½Ú¼ÙÈÕ¾­Ñé¼Ó³É
#  @param curPlayer: Íæ¼ÒʵÀý
#  @return: ½Ú¼ÙÈÕ¾­Ñé¼Ó³É
def GetHolidayExpRate(curPlayer):
    return 0


## »ñÈ¡ÊÀ½çboss¾­Ñé¼Ó³É
#  @param curPlayer: Íæ¼ÒʵÀý
#  @return: ÊÀ½çboss¾­Ñé¼Ó³É
def GetWorldBossExpRate(curPlayer):
    return 0

## »ñÈ¡Íæ¼Òµ±Ç°µÈ¼¶Éý¼¶ËùÐè×ܾ­Ñé
#  @param playerLv Íæ¼ÒµÈ¼¶
#  @return ·µ»ØÖµ, Éý¼¶ÐèÒªµÄ×ܾ­Ñé
def GetLVUPTotalNeedExp(curPlayer):
    curLV = curPlayer.GetLV()
    #if curLV >= IpyGameDataPY.GetFuncCfg("PlayerMaxLV") and PlayerGreatMaster.IsGreatMasterOpen(curPlayer):
    #    return PlayerGreatMaster.GetTotalExpByGreatMasterLV(curPlayer.GetLV2())
    
    return GetTotalExpByPlayerLv(curLV)

## ¸ù¾ÝµÈ¼¶»ñµÃÉý¼¶ÐèÒªµÄ×ܾ­Ñé
#  @param playerLv Íæ¼ÒµÈ¼¶
#  @return ·µ»ØÖµ, Éý¼¶ÐèÒªµÄ×ܾ­Ñé
def GetTotalExpByPlayerLv(playerLV):
    lvIpyData = GetPlayerLVIpyData(playerLV)
    if not lvIpyData:
        return 0
    return GetLVUPTotalExpNeed(lvIpyData)

def GetPlayerLVIpyData(playerLV):
    lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", playerLV)
    if not lvIpyData:
        GameWorld.ErrLog("¾­Ñé±íÒì³£  lv= %s" % playerLV)
        return
    return lvIpyData

def GetLVUPTotalExpNeed(lvIpyData):
    if not lvIpyData:
        return 0
    return lvIpyData.GetExpPoint() * ChConfig.Def_PerPointValue + lvIpyData.GetExp()

def GetPlayerMaxLV(curPlayer):
    ## »ñÈ¡Íæ¼Òʵ¼Ê¿ÉÉýµÄ×î´óµÈ¼¶
    maxLV = IpyGameDataPY.GetFuncCfg("PlayerMaxLV", 1)
    curRealmLV = curPlayer.GetOfficialRank()
    realmIpyData = PlayerPrestigeSys.GetRealmIpyData(curRealmLV)
    if not realmIpyData:
        return 0
    playerMaxLV = min(maxLV, realmIpyData.GetLVMax())
    return playerMaxLV

## »ñµÃÍæ¼Òʵ¼ÊµÈ¼¶
#  @param curPlayer Íæ¼Ò
#  @return Íæ¼Òʵ¼ÊµÈ¼¶
def GetRealPlayerLv(curPlayer):
    #µ±Ç°µÈ¼¶
    realPlayerLv = curPlayer.GetLV()
    #µ±Ç°Íæ¼Ò×ܾ­Ñé
    curTotalExp = GetPlayerTotalExp(curPlayer)
    return GetRealPlayerLvEx(realPlayerLv, curTotalExp)

## »ñµÃÍæ¼Òʵ¼ÊµÈ¼¶
#  @param realPlayerLv µ±Ç°µÈ¼¶
#  @param curTotalExp ×ܾ­Ñé
#  @return Íæ¼Òʵ¼ÊµÈ¼¶
def GetRealPlayerLvEx(realPlayerLv, curTotalExp):
    #Éý¼¶ËùÐè×ܾ­Ñé
    needTotalExp = GetTotalExpByPlayerLv(realPlayerLv)
    if not needTotalExp:
        return realPlayerLv
    
    #Ä£ÄâÉý¼¶,»ñµÃʵ¼ÊµÈ¼¶
    while curTotalExp >= needTotalExp:
        realPlayerLv += 1
        curTotalExp -= needTotalExp
        needTotalExp = GetTotalExpByPlayerLv(realPlayerLv)
        if not needTotalExp:
            break
    return realPlayerLv

## »ñÈ¡Íæ¼Òµ±Ç°×ܾ­Ñé
def GetPlayerTotalExp(curPlayer):
    totalExp = curPlayer.GetTotalExp() # δÂúÒ»¸ö¾­ÑéµãµÄ¾­Ñ飬·ÇÍæ¼Òʵ¼Ê×ܾ­Ñé
    expPoint = curPlayer.GetExpPoint()
    totalMasterExp = expPoint * ChConfig.Def_PerPointValue + totalExp
    return totalMasterExp

## ÉèÖÃÍæ¼Òµ±Ç°×ܾ­Ñé, ת»¯Îª¾­Ñéµã¼°¾­Ñé
def SetPlayerTotalExp(curPlayer, totalExp):
    curExp = totalExp % ChConfig.Def_PerPointValue
    expPoint = totalExp / ChConfig.Def_PerPointValue
    
    if curPlayer.GetExpPoint() != expPoint:
        curPlayer.SetExpPoint(expPoint)
    if curPlayer.GetTotalExp() != curExp:
        curPlayer.SetTotalExp(curExp)
    #GameWorld.DebugLog("SetPlayerTotalExp totalExp=%s,expPoint=%s,curExp=%s" 
    #                   % (totalExp, expPoint, curExp), curPlayer.GetPlayerID())
    
    return

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

## ֪ͨѡÖÐÄ¿±ê
#  @param curPlayer: Íæ¼ÒʵÀý
#  @return None
def Sync_SelectObj(curPlayer, objType, objID, isSelect):
    selectObj = ChPyNetSendPack.tagMCNotifySelectObj()
    selectObj.Clear()
    selectObj.Type = objType
    selectObj.ID = objID
    selectObj.isSelect = isSelect
    NetPackCommon.SendFakePack(curPlayer, selectObj)
    return


## ͳ¼ÆÍæ¼ÒÊôÐÔ£¬ÀÛ¼Ó
#  @param attrType ÊôÐÔÀàÐÍ£¬Ð§¹ûID»òÕß×Ö·û´®
#  @param value ÊôÐÔÖµ
#  @param allAttrList ÊôÐÔÁбí
#  @return None
def CalcAttrDict_Type(attrType, value, allAttrList):
    if value == 0:
        return
    
    #[ÊôÐÔË÷Òý, ÊÇ·ñ»ù´¡ÊôÐÔ£¬(·Ç)ÏßÐÔ]
    attrInfo = ChConfig.ItemEffect_AttrDict.get(attrType, [])
    if attrInfo == []:
        return
    
    index = ChConfig.Def_CalcAttrIndexDict[(attrInfo[1], attrInfo[2])]
    
    attrDict = allAttrList[index]
    for i in attrInfo[0]:
        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,
# CalcAttr_Battle,
# CalcAttr_BattleNoline,
#===============================================================================

# ´ÓsrcAttrList¼ÆËã³öaddAttrList´øÀ´µÄ¹Ì¶¨ÊôÐÔ£¬ÓÃÓÚºóÐø¼ÆËãʹÓÃ
#===============================================================================
# def CalcAddFuncAttrByAttrList(srcAttrList, addAttrList):
#    for addKey, addValue in addAttrList[ChConfig.CalcAttr_BaseNoline].items():
#        value = srcAttrList[ChConfig.CalcAttr_Base].get(addKey, 0)
#        if value == 0:
#            continue
#        
#        addAttrList[ChConfig.CalcAttr_Base][addKey]  = addAttrList[ChConfig.CalcAttr_Base].get(addKey, 0)\
#                                                         + value*addValue / ChConfig.Def_MaxRateValue
# 
#    addAttrList[ChConfig.CalcAttr_BaseNoline] = {}
#    for addKey, addValue in addAttrList[ChConfig.CalcAttr_BattleNoline].items():
#        value = srcAttrList[ChConfig.CalcAttr_Battle].get(addKey, 0)
#        if value == 0:
#            continue
#        
#        addAttrList[ChConfig.CalcAttr_Battle][addKey]  = addAttrList[ChConfig.CalcAttr_Battle].get(addKey, 0)\
#                                                         + value*addValue / ChConfig.Def_MaxRateValue
# 
#    addAttrList[ChConfig.CalcAttr_BattleNoline] = {}
#    return addAttrList
#===============================================================================
## ÅàÑø¾³½çµÈ¼¶
def GetTrainRealmLVReal(curPlayer, funcType):
    trainRealmLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TrainRealmLV % funcType)
    return max(trainRealmLV, curPlayer.GetOfficialRank())
def SetTrainRealmLV(curPlayer, funcType, trainRealmLV):
    NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TrainRealmLV % funcType, trainRealmLV)
    SyncTrainRealmLV(curPlayer, funcType)
    return
def SyncTrainRealmLV(curPlayer, funcType=None):
    if funcType == None:
        syncFuncTypeList = range(1, 1 + 10)
    else:
        syncFuncTypeList = [funcType]
    infoList = []
    for fType in syncFuncTypeList:
        trainRealmLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TrainRealmLV % fType)
        if not trainRealmLV and funcType == None:
            continue
        lvInfo = ChPyNetSendPack.tagMCTrainRealmLV()
        lvInfo.FuncType = fType
        lvInfo.TrainRealmLV = trainRealmLV
        infoList.append(lvInfo)
    if not infoList:
        return
    clientPack = ChPyNetSendPack.tagMCTrainRealmLVInfo()
    clientPack.InfoList = infoList
    clientPack.Count = len(clientPack.InfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

## ÷ÈÁ¦µÈ¼¶
def GetCharmLV(curPlayer): return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CharmLV)
def SetCharmLV(curPlayer, charmLV):
    NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CharmLV, charmLV)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_CharmLV, charmLV)
    return

def GetTotalLingGenPoint(curPlayer):
    # ×ÜÁé¸ùµãÊý(½ðľˮ»ðÍÁ+×ÔÓɵãÊý)
    attrIDList = [ShareDefine.Def_Effect_Metal, ShareDefine.Def_Effect_Wood, ShareDefine.Def_Effect_Water, ShareDefine.Def_Effect_Fire, ShareDefine.Def_Effect_Earth]
    curTotalPoint = 0
    for attrID in attrIDList:
        curTotalPoint += curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AddPointValue % attrID)
    curTotalPoint += curPlayer.GetFreePoint()
    return curTotalPoint

# Áé¸ù - ½ðľˮ»ðÍÁ
def GetMetal(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Metal)
def SetMetal(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Metal, value)
def GetWood(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Wood)
def SetWood(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Wood, value)
def GetWater(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Water)
def SetWater(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Water, value)
def GetFire(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Fire)
def SetFire(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Fire, value)
def GetEarth(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Earth)
def SetEarth(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_Earth, value)
# Áé¸ùÆ·¼¶ - ½ðľˮ»ðÍÁ
def GetMetalQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MetalQualityLV)
def SetMetalQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_MetalQualityLV, value)
def GetWoodQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WoodQualityLV)
def SetWoodQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WoodQualityLV, value)
def GetWaterQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WaterQualityLV)
def SetWaterQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WaterQualityLV, value)
def GetFireQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FireQualityLV)
def SetFireQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FireQualityLV, value)
def GetEarthQualityLV(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_EarthQualityLV)
def SetEarthQualityLV(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_EarthQualityLV, value)

#---Íæ¼ÒÀ©Õ¹½Ó¿Ú, Õ½¶·ÊôÐÔ£¬²»´æÊý¾Ý¿â£¬Ö»Í¨Öª±¾ÈË---

##Íæ¼ÒÒƶ¯ËÙ¶ÈÖµ, ²»º¬buff¶ÔËٶȵÄÓ°Ï죻 ¹¦ÄܵȶÔËٶȵÄÓ°ÏìÖ±½Ó¸Ä±ä´ËÖµ
def GetSpeedNotBuff(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SpeedValueNotBuff)
def SetSpeedNotBuff(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SpeedValueNotBuff, value)
##Íæ¼ÒÒƶ¯ËÙ¶ÈÖµ, º¬buff¶ÔËٶȵÄÓ°Ï죻 ´ËÊýÖµ²»ÊÇÕæÕýµÄÒƶ¯Ëٶȣ¬Ö»ÊÇÓÃÓÚ¼ÆËãÒƶ¯ËٶȵIJÎÊýÖµ
def GetSpeedValue(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SpeedValue)
def SetSpeedValue(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_SpeedValue, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_SpeedValue, value, True) # Òƶ¯ËÙ¶ÈÖµÔݶ¨¹ã²¥ÖÜΧÍæ¼Ò

##»ñÈ¡Íæ¼Ò¹¥»÷Ëٶȣ¬ÓÃÓÚ¼ÆËã¹¥»÷¼ä¸ô
# @param curPlayer Íæ¼ÒʵÀý
# @return Íæ¼Ò¹¥»÷ËÙ¶È
def GetAtkSpeed(curPlayer):
    return curPlayer.GetBattleValEx1()

##ÉèÖÃÍæ¼Ò¹¥»÷Ëٶȣ¬ÓÃÓÚ¼ÆËã¹¥»÷¼ä¸ô
# @param curPlayer Íæ¼ÒʵÀý
# @return None
def SetAtkSpeed(curPlayer, value):
    curPlayer.SetBattleValEx1(value, True)
    
#---¹¥»÷»Ø¸´ÑªÁ¿±ÈÂÊ----
## »ñÈ¡Íæ¼Ò¹¥»÷»Ø¸´ÑªÁ¿±ÈÂÊ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return 
def GetAtkBackHPPer(curPlayer):
    return curPlayer.GetBattleValEx2()


## ÉèÖÃÍæ¼Ò¹¥»÷»Ø¸´ÑªÁ¿±ÈÂÊ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return None
def SetAtkBackHPPer(curPlayer, value):
    curPlayer.SetBattleValEx2(value)

## »ñÈ¡Íæ¼Ò¹¥»÷»Ø¸´À¶Á¿±ÈÂÊ
def GetAtkBackMPPer(curPlayer): return 0
def SetAtkBackMPPer(curPlayer, value): return

## Íæ¼Ò¼õ¼¼ÄÜCD±ÈÀý
def GetReduceSkillCDPer(curPlayer): return curPlayer.GetBattleValEx3()
def SetReduceSkillCDPer(curPlayer, reducePer): return curPlayer.SetBattleValEx3(reducePer)

## ³£¹æµØͼ¾­Ñ鱶ÂʼӳÉ
def GetCommMapExpRate(curPlayer):
    if GameWorld.GetMap().GetMapFBType() == IPY_GameWorld.fbtNull:
        return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CommMapExpRate)
    return 0
def SetCommMapExpRate(curPlayer, expRate): return curPlayer.SetDict(ChConfig.Def_PlayerKey_CommMapExpRate, expRate)

## ¶Ô¹ÖÎïÉ˺¦¼Ó³É
def GetNPCHurtAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NPCHurtAddPer)
def SetNPCHurtAddPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_NPCHurtAddPer, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_NPCHurtAddPer, value)
    
#---Ö°ÒµÉ˺¦¼Ó³É---
## Ä¿±êսʿÉ˺¦¼Ó³É
def GetJobAHurtAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobAHurtAddPer)
def SetJobAHurtAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobAHurtAddPer, value)
## Ä¿±ê·¨Ê¦É˺¦¼Ó³É
def GetJobBHurtAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobBHurtAddPer)
def SetJobBHurtAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobBHurtAddPer, value)
## Ä¿±ê¹­ÊÖÉ˺¦¼Ó³É
def GetJobCHurtAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobCHurtAddPer)
def SetJobCHurtAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobCHurtAddPer, value)

#---É˺¦¼õÃâ---
## NPC¹¥»÷É˺¦¼õÃâ
def GetNPCAtkReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_NPCAtkReducePer)
def SetNPCAtkReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_NPCAtkReducePer, value)
## սʿ¹¥»÷É˺¦¼õÃâ
def GetJobAAtkReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobAAtkReducePer)
def SetJobAAtkReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobAAtkReducePer, value)
## ·¨Ê¦¹¥»÷É˺¦¼õÃâ
def GetJobBAtkReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobBAtkReducePer)
def SetJobBAtkReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobBAtkReducePer, value)
## ¹­ÊÖ¹¥»÷É˺¦¼õÃâ
def GetJobCAtkReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_JobCAtkReducePer)
def SetJobCAtkReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_JobCAtkReducePer, value)

#---ÌØÊâÉ˺¦¼õÃâ---
## »áÐÄÒ»»÷É˺¦¼õÃâ¹Ì¶¨Öµ
def GetLuckyHitReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_LuckyHitReduce)
def SetLuckyHitReduce(curPlayer, value): 
    curPlayer.SetDict(ChConfig.Def_PlayerKey_LuckyHitReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_LuckyHitReduce, value)
    
## ׿Խһ»÷É˺¦¼õÃâ
def GetGreatHitReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GreatHitReducePer)
def SetGreatHitReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GreatHitReducePer, value)
## ±©»÷É˺¦¼õÃâ
def GetSuperHitReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SuperHitReduce)
def SetSuperHitReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_SuperHitReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_SuperHitReduce, value)
## ÎÞÊÓ·ÀÓùÉ˺¦¼õÃâ
def GetIgnoreDefReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_IgnoreDefReducePer)
def SetIgnoreDefReducePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_IgnoreDefReducePer, value)

#---¿¹ÌØÊâÉ˺¦¸ÅÂÊ---
## ¿¹»áÐÄÒ»»÷¸ÅÂÊ
def GetLuckyHitRateReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_LuckyHitRateReduce)
def SetLuckyHitRateReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_LuckyHitRateReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_LuckyHitRateReduce, value)
## ¿¹×¿Ô½Ò»»÷¸ÅÂÊ
def GetGreatHitRateReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GreatHitRateReduce)
def SetGreatHitRateReduce(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GreatHitRateReduce, value)
## ¿¹±©»÷¸ÅÂÊ
def GetSuperHitRateReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SuperHitRateReduce)
def SetSuperHitRateReduce(curPlayer, value): 
    curPlayer.SetDict(ChConfig.Def_PlayerKey_SuperHitRateReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_SuperHitRateReduce, value)
## ¿¹ÎÞÊÓ·ÀÓù¸ÅÂÊ
def GetIgnoreDefRateReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_IgnoreDefRateReduce)
def SetIgnoreDefRateReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_IgnoreDefRateReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_IgnoreDefRateReduce, value)
    
#---ÌØÊâÉ˺¦¸ÅÂÊ---
## ¸»ºÀÒ»»÷¸ÅÂÊ
def GetFuhaoHitRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FuhaoHitRate)
def SetFuhaoHitRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FuhaoHitRate, value)

## Á÷ѪÉ˺¦
def GetBleedDamage(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BleedDamage)
def SetBleedDamage(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_BleedDamage, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_BleedDamage, value)
    
## Boss×îÖÕÉ˺¦°Ù·Ö±È
def GetBossFinalHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BossFinalHurtPer)
def SetBossFinalHurtPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_BossFinalHurtPer, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_BossFinalHurtPer, value)
    
## ×îÖÕÉ˺¦°Ù·Ö±È
def GetFinalHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FinalHurtPer)
def SetFinalHurtPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_FinalHurtPer, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FinalHurtPer, value)
    
## ×îÖÕÉ˺¦¼õÃâ°Ù·Ö±È
def GetFinalHurtReducePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FinalHurtReducePer)
def SetFinalHurtReducePer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_FinalHurtReducePer, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FinalHurtReducePer, value)
    
## ×îÖչ̶¨É˺¦Ôö¼Ó
def GetFinalHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FinalHurt)
def SetFinalHurt(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_FinalHurt, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FinalHurt, value)
## ×îÖչ̶¨É˺¦¼õÉÙ
def GetFinalHurtReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FinalHurtReduce)
def SetFinalHurtReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_FinalHurtReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FinalHurtReduce, value)
## ¶ÔÖ¸¶¨bossÉ˺¦¼Ó³É¹Ì¶¨Öµ
def GetBossIDHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BossIDHurt)
def SetBossIDHurt(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BossIDHurt, value)
## ¶ÔÖ¸¶¨bossÉ˺¦¼Ó³É±¶ÂÊ
def GetBossIDHurtAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BossIDHurtAddPer)
def SetBossIDHurtAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BossIDHurtAddPer, value)
## ×°±¸µôÂäÖ´ÐдÎÊý¼Ó³ÉÍò·ÖÂÊ
def GetDropEquipDoCount(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_DropEquipDoCount)
def SetDropEquipDoCount(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_DropEquipDoCount, value)

# »ù´¡¹¥»÷°Ù·Ö±È
def GetBaseAtkAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseAtkAddPer)
def SetBaseAtkAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseAtkAddPer, value)
# »ù´¡ÉúÃü°Ù·Ö±È
def GetBaseMaxHPAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseMaxHPAddPer)
def SetBaseMaxHPAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseMaxHPAddPer, value)
# »ù´¡·ÀÓù°Ù·Ö±È
def GetBaseDefAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseDefAddPer)
def SetBaseDefAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseDefAddPer, value)
# »ù´¡ÃüÖаٷֱÈ
def GetBaseHitAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseHitAddPer)
def SetBaseHitAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseHitAddPer, value)
# »ù´¡ÉÁ±Ü°Ù·Ö±È
def GetBaseMissAddPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BaseMissAddPer)
def SetBaseMissAddPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BaseMissAddPer, value)
# ·¨Æ÷ÉúÃü°Ù·Ö±È
def GetFaQiMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaQiMaxHPPer)
def SetFaQiMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaQiMaxHPPer, value)
# ·¨Æ÷¹¥»÷°Ù·Ö±È
def GetFaQiAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaQiAtkPer)
def SetFaQiAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaQiAtkPer, value)
# ·¨Æ÷·ÀÓù°Ù·Ö±È
def GetFaQiDefPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaQiDefPer)
def SetFaQiDefPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaQiDefPer, value)
# Éñ±øÉúÃü°Ù·Ö±È
def GetGodWeaponMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GodWeaponMaxHPPer)
def SetGodWeaponMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GodWeaponMaxHPPer, value)
# Éñ±ø¹¥»÷°Ù·Ö±È
def GetGodWeaponAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GodWeaponAtkPer)
def SetGodWeaponAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GodWeaponAtkPer, value)
# ±¦Ê¯ÉúÃü°Ù·Ö±È
def GetStoneMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_StoneMaxHPPer)
def SetStoneMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_StoneMaxHPPer, value)
# ±¦Ê¯¹¥»÷°Ù·Ö±È
def GetStoneAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_StoneAtkPer)
def SetStoneAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_StoneAtkPer, value)
# Ѫƿ»Ö¸´Ð§¹û
def GetHPCureEnhance(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HPCureEnhance)
def SetHPCureEnhance(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HPCureEnhance, value)

# ¶îÍâÊä³öÉ˺¦
def GetOnlyFinalHurt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_OnlyFinalHurt)
def SetOnlyFinalHurt(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_OnlyFinalHurt, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_OnlyFinalHurt, value)
    return

# PVP¹¥»÷»ØѪ
def GetPVPAtkBackHP(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PVPAtkBackHP)
def SetPVPAtkBackHP(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PVPAtkBackHP, value)

# ÃüÖгɹ¦ÂÊ
def GetHitSucessRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HitSucessRate)
def SetHitSucessRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HitSucessRate, value)

# ÉÁ±Ü³É¹¦ÂÊ
def GetMissSucessRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MissSucessRate)
def SetMissSucessRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_MissSucessRate, value)

# ÖÎÁÆ¼Ó³É Ä¬ÈÏ°Ù·Ö°Ù
def GetCurePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CurePer)
def SetCurePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_CurePer, value)

# ¼ÓÉîÊܵ½É˺¦°Ù·Ö±È
def GetBeHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BeHurtPer)
def SetBeHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BeHurtPer, value)

# ³ÆºÅÉúÃü¼Ó³É
def GetTitleMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TitleMaxHPPer)
def SetTitleMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_TitleMaxHPPer, value)
# ³ÆºÅ¹¥»÷¼Ó³É
def GetTitleAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TitleAtkPer)
def SetTitleAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_TitleAtkPer, value)
# ³ÆºÅ·ÀÓù¼Ó³É
def GetTitleDefPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TitleDefPer)
def SetTitleDefPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_TitleDefPer, value)

# Í·ÏñÉúÃü¼Ó³É
def GetFaceMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaceMaxHPPer)
def SetFaceMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaceMaxHPPer, value)
# Í·Ïñ¹¥»÷¼Ó³É
def GetFaceAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaceAtkPer)
def SetFaceAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaceAtkPer, value)
# Í·Ïñ·ÀÓù¼Ó³É
def GetFaceDefPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FaceDefPer)
def SetFaceDefPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FaceDefPer, value)

# Í·Ïñ¿òÉúÃü¼Ó³É
def GetFacePicMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FacePicMaxHPPer)
def SetFacePicMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FacePicMaxHPPer, value)
# Í·Ïñ¿ò¹¥»÷¼Ó³É
def GetFacePicAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FacePicAtkPer)
def SetFacePicAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FacePicAtkPer, value)
# Í·Ïñ¿ò·ÀÓù¼Ó³É
def GetFacePicDefPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FacePicDefPer)
def SetFacePicDefPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FacePicDefPer, value)

# ×øÆï»Ã»¯ÉúÃü¼Ó³É
def GetHorseSkinMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseSkinMaxHPPer)
def SetHorseSkinMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseSkinMaxHPPer, value)
# ×øÆï»Ã»¯¹¥»÷¼Ó³É
def GetHorseSkinAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseSkinAtkPer)
def SetHorseSkinAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseSkinAtkPer, value)
# ×øÆï»Ã»¯·ÀÓù¼Ó³É
def GetHorseSkinDefPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseSkinDefPer)
def SetHorseSkinDefPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseSkinDefPer, value)

# ×øÆï¹¥»÷°Ù·Ö±È
def GetHorseAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseAtkPer)
def SetHorseAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseAtkPer, value)

# ×øÆïÉúÃü¼Ó³É
def GetHorseMaxHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseMaxHPPer)
def SetHorseMaxHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseMaxHPPer, value)

# Áé³è¹¥»÷¼Ó³É
def GetPetAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PetAtkPer)
def SetPetAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PetAtkPer, value)

# ×øÆïÅàÑøÊôÐÔ¼Ó³É
def GetHorseTrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_HorseTrainAttrPer)
def SetHorseTrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_HorseTrainAttrPer, value)

# Áé³èÅàÑøÊôÐÔ¼Ó³É
def GetPetTrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PetTrainAttrPer)
def SetPetTrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PetTrainAttrPer, value)

# ÊØ»¤ÅàÑøÊôÐÔ¼Ó³É
def GetGuardTrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_GuardTrainAttrPer)
def SetGuardTrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_GuardTrainAttrPer, value)

# ³á°òÅàÑøÊôÐÔ¼Ó³É
def GetWingTrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WingTrainAttrPer)
def SetWingTrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WingTrainAttrPer, value)

# ÃðÊÀÅàÑøÊôÐÔ¼Ó³É
def GetPeerlessWeaponTrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PeerlessWeaponTrainAttrPer)
def SetPeerlessWeaponTrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PeerlessWeaponTrainAttrPer, value)

# ß±ÉñÅàÑøÊôÐÔ¼Ó³É
def GetPeerlessWeapon2TrainAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PeerlessWeapon2TrainAttrPer)
def SetPeerlessWeapon2TrainAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PeerlessWeapon2TrainAttrPer, value)

# Á¶ÌåÊôÐÔÊôÐÔ¼Ó³É
def GetLianTiAttrPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_LianTiAttrPer)
def SetLianTiAttrPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_LianTiAttrPer, value)

def GetAttr160(curPlayer): return 0
def SetAttr160(curPlayer, value): pass

# ÏÉÃË»ÕÕÂID
def GetFamilyEmblemID(curPlayer): return curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyEmblemID)
def SetFamilyEmblemID(curPlayer, emblemID): NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyEmblemID, emblemID)

# ÏÉÃËÊÂÎñËٶȼӳÉ
def GetAffairSpeedPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AffairSpeedPer)
def SetAffairSpeedPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AffairSpeedPer, value)

# ÏÉÃËBOSSÉ˺¦¼Ó³É
def GetFamilyBossHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FamilyBossHurtPer)
def SetFamilyBossHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FamilyBossHurtPer, value)

# ÏÉÃËÁªÈüÉúÃü¼Ó³É
def GetFamilyWarHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FamilyWarHPPer)
def SetFamilyWarHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FamilyWarHPPer, value)

# ÏÉÃËÁªÈü¹¥»÷¼Ó³É
def GetFamilyWarAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FamilyWarAtkPer)
def SetFamilyWarAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FamilyWarAtkPer, value)

# ÏÉÃË´ò×ø¾­Ñé¼Ó³É
def GetFamilySitExpPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_FamilySitExpPer)
def SetFamilySitExpPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_FamilySitExpPer, value)

# ±¦Ê¯»ù´¡ÊôÐÔ°Ù·Ö±È
def GetStoneBasePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_StoneBasePer)
def SetStoneBasePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_StoneBasePer, value)

# ¾³½ç»ù´¡ÊôÐÔ°Ù·Ö±È
def GetRealmBasePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RealmBasePer)
def SetRealmBasePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_RealmBasePer, value)

# ³á°òÉúÃü°Ù·Ö±È
def GetWingHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_WingHPPer)
def SetWingHPPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_WingHPPer, value)

# Ì××°»ù´¡ÊôÐÔ°Ù·Ö±È
def GetSuiteBasePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SuiteBasePer)
def SetSuiteBasePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SuiteBasePer, value)

# Ç¿»¯»ù´¡¹¥»÷°Ù·Ö±È
def GetPlusBaseAtkPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PlusBaseAtkPer)
def SetPlusBaseAtkPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PlusBaseAtkPer, value)

## ÔÝÎÞÓÃ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return 
def GetAddBackHPPer(curPlayer):
    return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AddBackHPPer)

## ÔÝÎÞÓÃ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return None
def SetAddBackHPPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AddBackHPPer, value)
    
#---½µµÍÉúÃü»Ö¸´Ð§¹û----
## »ñÈ¡½µµÍÉúÃü»Ö¸´Ð§¹ûÍò·ÖÂÊ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return 
def GetReduceBackHPPer(curPlayer):
    return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ReduceBackHPPer)

## ÉèÖýµµÍÉúÃü»Ö¸´Ð§¹ûÍò·ÖÂÊ
#  @param curPlayer Íæ¼ÒʵÀý
#  @return None
def SetReduceBackHPPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_ReduceBackHPPer, value)

#---´¥·¢»÷ÔÎ----
def GetFaintRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrFaintRate)
def SetFaintRate(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrFaintRate, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FaintRate, value)
#---»÷Ôεֿ¹----
def GetFaintDefRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrFaintDefRate)
def SetFaintDefRate(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrFaintDefRate, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_FaintDefRate, value)
    
#---´¥·¢¶¨Éí----
def GetAtkerFreezed(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrAtkerFreezed)
def SetAtkerFreezed(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrAtkerFreezed, value)
    
#---Ôö¼Ó³ðºÞ----
def GetAddAngry(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrAddAngry)
def SetAddAngry(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrAddAngry, value)

#---Á¬»÷¼¸ÂÊ----
def GetComboRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrComboRate)
def SetComboRate(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrComboRate, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ComboRate, value)
#---Á¬»÷É˺¦----
def GetComboDamPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrComboDamPer)
def SetComboDamPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrComboDamPer, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ComboDamPer, value)
    
#---¼¼Äܹ¥»÷±ÈÀý¼õÉÙ----
def GetSkillAtkRateReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAtkRateReduce)
def SetSkillAtkRateReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAtkRateReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_SkillAtkRateReduce, value)
#---PVP¹Ì¶¨É˺¦----
def GetDamagePVP(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamagePVP)
def SetDamagePVP(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamagePVP, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamagePVP, value)
#---PVP¹Ì¶¨É˺¦¼õÉÙ----
def GetDamagePVPReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamagePVPReduce)
def SetDamagePVPReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamagePVPReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamagePVPReduce, value)
#---É˺¦Êä³ö¹Ì¶¨Öµ¼ÆËã¶ÔNPC¸½¼Ó----
def GetDamagePVE(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamagePVE)
def SetDamagePVE(curPlayer, value): 
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamagePVE, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamagePVE, value)
    
#---É˺¦Êä³ö¼ÆËã°Ù·Ö±È¶ÔÍæ¼Ò¸½¼Ó----
def GetDamagePerPVP(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamagePerPVP)
def SetDamagePerPVP(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamagePerPVP, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamagePerPVP, value)
def GetDamagePerPVPReduce(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamagePerPVPReduce)
def SetDamagePerPVPReduce(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamagePerPVPReduce, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamagePerPVPReduce, value)
    
#---ÊÜÉ˼ÆËã°Ù·Ö±È----
def GetHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrHurtPer)
def SetHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrHurtPer, value)
  
#---×Ô¶¯»Ö¸´XPÖµ±ÈÂÊ----
def GetXPRestorePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrXPRestorePer)
def SetXPRestorePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrXPRestorePer, value)

#---ħ·¨¶ÜÉ˺¦ÎüÊÕÀ¶ºÄ±ÈÂÊ----
def GetShieldMPCostRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrShieldMPCostRate)
def SetShieldMPCostRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrShieldMPCostRate, value)
  
#---20%µÄ¸ÅÂʵÖÓùÉ˺¦±ÈÂÊ----
def GetDamChanceDef(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDamChanceDef)
def SetDamChanceDef(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDamChanceDef, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_DamChanceDef, value)
    
#---µ±Ç°·À»¤Öµ£¬Ðè´æDB----
def GetProDef(curPlayer): return curPlayer.GetExAttr4()
def SetProDef(curPlayer, value):
    if GameWorld.IsCrossServer():
        curPlayer.SetExAttr4(value, True) # ¿ç·þ·þÎñÆ÷ÐèÒª¹ã²¥ÖÜΧÍæ¼Ò
    else:
        curPlayer.SetExAttr4(value)
    
#---×î´ó·À»¤Öµ----
def GetMaxProDef(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrMaxProDef)
def SetMaxProDef(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrMaxProDef, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_MaxProDef, value) # ÖÜΧÍæ¼ÒÐèҪ֪ͨ
    
#---ÉúÃüÉÏÏÞ»»ËãΪ·À»¤ÖµµÄ°Ù·Ö±È----
def GetProDefHPPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrProDefHPPer)
def SetProDefHPPer(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrProDefHPPer, value)
    #SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ProDefHPPer, value)
    
#---·À»¤ÖµÎüÊÕÉ˺¦±ÈÂÊ----
def GetProDefAbsorb(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrProDefAbsorb)
def SetProDefAbsorb(curPlayer, value):
    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrProDefAbsorb, value)
    #SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ProDefAbsorb, value)
    
#---³èÎï¹¥»÷ÌáÉýÖµ----
def GetPetMinAtk(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrPetMinAtk)
def SetPetMinAtk(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrPetMinAtk, value)
def GetPetMaxAtk(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrPetMaxAtk)
def SetPetMaxAtk(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrPetMaxAtk, value)

#---³èÎïÉ˺¦°Ù·Ö±ÈÌáÉý----ÒƵ½GameObjÏÂ
#===============================================================================
# def GetPetDamPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrPetDamPer)
# def SetPetDamPer(curPlayer, value): 
#    curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrPetDamPer, value)
#    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_PetDamPer, value)
#===============================================================================
#---³èÎï¼¼ÄÜÉ˺¦°Ù·Ö±ÈÌáÉý----
def GetPetSkillAtkRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PetSkillAtkRate)
def SetPetSkillAtkRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PetSkillAtkRate, value)
    
#---ÿ1¼¶+%s¹¥»÷, ÊýֵȡÍò·ÖÂÊ£¬Ö§³ÖСÊýËã·¨----
def GetPerLVAtk(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrPerLVAtk)
def SetPerLVAtk(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrPerLVAtk, value)
#---ÿ1¼¶+%sÉúÃü, ÊýֵΪ¹Ì¶¨Öµ----
def GetPerLVMaxHP(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrPerLVMaxHP)
def SetPerLVMaxHP(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrPerLVMaxHP, value)

#---×°±¸µôÂÊ----
def GetDropEquipPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_AttrDropEquipPer)
def SetDropEquipPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_AttrDropEquipPer, value)

#---¹¦Äܲã·ÀÓùÖµ----
def GetFuncDef(curPlayer): return EffGetSet.GetCopyFuncAttrValue(curPlayer, ChConfig.TYPE_Calc_AttrDEF)
def SetFuncDef(curPlayer, value): EffGetSet.SetCopyFuncAttrValue(curPlayer, ChConfig.TYPE_Calc_AttrDEF, 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)

# ÿXÃë×Ô¶¯Ïûʧһ¸öÓ¡¼Ç£¬ ºÁÃë¼Ç¼
def GetLostYinjiTime(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_LostYinjiTime)
def SetLostYinjiTime(curPlayer, value): 
    curPlayer.SetDict(ChConfig.Def_PlayerKey_LostYinjiTime, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_YinjiTime, value)

# µ±Ç°Ó¡¼ÇÊý
def GetYinjiCnt(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_YinjiCnt)
def SetYinjiCnt(curPlayer, value): 
    curPlayer.SetDict(ChConfig.Def_PlayerKey_YinjiCnt, value)
    SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_YinjiCnt, value)

# ¼õÉÙÖ¸¶¨¼¼ÄÜ×éCD XX%
def GetTheFBSkillsCD(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TheFBSkillsCD)
def SetTheFBSkillsCD(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_TheFBSkillsCD, value)
# ×ÆÉչ̶¨É˺¦
def GetBurnValue(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BurnValue)
def SetBurnValue(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BurnValue, value)
# ÑÓ³¤×ÆÉÕʱ¼ä°Ù·Ö±È
def GetBurnTimePer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BurnTimePer)
def SetBurnTimePer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BurnTimePer, value)
# ¼õÒƶ¯ËٶȰٷֱÈ
def GetSubSpeedPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SubSpeedPer)
def SetSubSpeedPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SubSpeedPer, value)

# ¼¼ÄÜÉ˺¦ÔöÇ¿
def GetSkillAddPer1(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer1)
def SetSkillAddPer1(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer1, value)
def GetSkillAddPer2(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer2)
def SetSkillAddPer2(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer2, value)
def GetSkillAddPer3(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer3)
def SetSkillAddPer3(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer3, value)
def GetSkillAddPer4(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer4)
def SetSkillAddPer4(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer4, value)
def GetSkillAddPer5(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer5)
def SetSkillAddPer5(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer5, value)
def GetSkillAddPer6(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer6)
def SetSkillAddPer6(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer6, value)
def GetSkillAddPer7(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillAddPer7)
def SetSkillAddPer7(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillAddPer7, value)

# Êܵ½¼¼ÄÜÉ˺¦¼õÉÙ
def GetSkillReducePer1(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer1)
def SetSkillReducePer1(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer1, value)
def GetSkillReducePer2(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer2)
def SetSkillReducePer2(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer2, value)
def GetSkillReducePer3(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer3)
def SetSkillReducePer3(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer3, value)
def GetSkillReducePer4(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer4)
def SetSkillReducePer4(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer4, value)
def GetSkillReducePer5(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer5)
def SetSkillReducePer5(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer5, value)
def GetSkillReducePer6(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer6)
def SetSkillReducePer6(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer6, value)
def GetSkillReducePer7(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SkillReducePer7)
def SetSkillReducePer7(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_SkillReducePer7, value)

#---ÖïÏÉÒ»»÷¸ÅÂÊ---
def GetZhuXianRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ZhuxianRate)
def SetZhuXianRate(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_ZhuxianRate, value)

#---ÖïÏÉ»¤Ìå¼õÉË---
def GetZhuXianReducePer(curPlayer): return 0#curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ZhuXianReducePer)
def SetZhuXianReducePer(curPlayer, value): return #curPlayer.SetDict(ChConfig.Def_PlayerKey_ZhuXianReducePer, value)

## ¼ÆË㹦Äܱ³°üÎïÆ·ÊôÐÔ 
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @param packType ±³°üÀàÐÍ
#  @param allAttrListEquip ÊôÐÔÁбí
#  @return None
def CalcFuncPackItem(curPlayer, packType, allAttrListEquip):
    #===========================================================================
    # funcPack = curPlayer.GetItemManager().GetPack(packType)
    # equipPartIndexList = ChConfig.Pack_EquipPart_CanPlusStar.get(packType, [])
    # 
    # #Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
    # for equipIndex in range(0, funcPack.GetCount()):
    #    
    #    curEquip = funcPack.GetAt(equipIndex)
    #    if curEquip.IsEmpty():
    #        continue
    #    
    #    #¼ÆËãЧ¹û
    #    for i in range(0, curEquip.GetEffectCount()):
    #        curEffect = curEquip.GetEffectByIndex(i)
    #        if not curEffect:
    #            break
    #        
    #        effectID = curEffect.GetEffectID()
    #        if effectID == 0:
    #            #×îºóÒ»¸ö
    #            break
    #        
    #        effectValue = curEffect.GetEffectValue(0)
    #        if not effectValue:
    #            continue
    #        
    #        #Ìí¼ÓÎïƷЧ¹ûµÄÊôÐÔÖµ
    #        CalcAttrDict_Type(effectID, effectValue, allAttrListEquip)
    #    
    #    
    #===========================================================================
    return

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

## ÉèÖñ£´æ¹¦ÄÜÊÂÏȼÆËãºÃµÄÊôÐÔÖµ
def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList, insidePerAttrDict=None, customAttrDict=None):
    # ÉèÖÃֵ֮ǰÏÈÇå¿ÕÖØÖÃ
    # @param customAttrDict: ×Ô¶¨ÒåµÄÊôÐÔÐÅÏ¢£¬±ØÐëÊǸñʽ {"×Ô¶¨ÒåÊôÐÔÃèÊöÃûkey":ÊôÐÔÐÅÏ¢, ...}  ×Ô¶¨ÒåÊôÐÔÃèÊöÃûkey - ½¨Ò鲻ͬ¹¦ÄܵãÖ®¼ä²»ÒªÖظ´
    ClearCalcAttrListValue(curPlayer, funcIndex)
    if insidePerAttrDict == None:
        insidePerAttrDict = {}
    if customAttrDict == None:
        customAttrDict = {}
        
    battleAttrDict = allAttrList[ChConfig.CalcAttr_Battle]
    if ChConfig.TYPE_Calc_PerLVAtk in battleAttrDict:
        # ÿ1¼¶¼ÓµÄ¹¥»÷Á¦²»Ò»¶¨Âú1µã£¬ËùÒÔÕâÀï°´Íò·ÖÂÊÀ´Ë㣬֧³ÖСÊýËã·¨
        addAtk = int(curPlayer.GetLV() * battleAttrDict[ChConfig.TYPE_Calc_PerLVAtk] / float(ShareDefine.Def_MaxRateValue))
        battleAttrDict[ChConfig.TYPE_Calc_AttrATKMin] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrATKMin, 0) + addAtk
        battleAttrDict[ChConfig.TYPE_Calc_AttrATKMax] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrATKMax, 0) + addAtk
        
    if ChConfig.TYPE_Calc_PerLVMaxHP in battleAttrDict:
        # ÿ1¼¶¼ÓµÄÉúÃüÖµ²»»áÉÙÓÚ1µã£¬ËùÒÔÖ±½Ó³Ë
        addMaxHP = curPlayer.GetLV() * battleAttrDict[ChConfig.TYPE_Calc_PerLVMaxHP]
        battleAttrDict[ChConfig.TYPE_Calc_AttrMaxHP] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrMaxHP, 0) + addMaxHP
        
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_playerFuncAttrDict:
        PyGameData.g_playerFuncAttrDict[playerID] = {}
    funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
    funcAttrDict[funcIndex] = [allAttrList, insidePerAttrDict, customAttrDict]
    #GameWorld.DebugLog("±£´æ¹¦ÄܵãÊôÐÔ: funcIndex=%s, %s, %s" % (funcIndex, allAttrList, insidePerAttrDict))
    return

def GetCalcAttrListValue(curPlayer, funcIndex):
    ## »ñÈ¡¹¦ÄܵãÔ¤ÏȼÆËãµÄËù¼ÓÊôÐÔÖµ
    attrList = [{} for _ in range(4)]
    insidePerAttrDict = {}
    customAttrDict = {}
    if isinstance(funcIndex, int):
        funcIndexList = [funcIndex]
    elif isinstance(funcIndex, list):
        funcIndexList = funcIndex
    else:
        return attrList, insidePerAttrDict, customAttrDict
    
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_playerFuncAttrDict:
        return attrList, insidePerAttrDict, customAttrDict
    funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
    for funcIndex in funcIndexList:
        if funcIndex not in funcAttrDict:
            continue
        funcAttrList, funcInsidePerAttrDict, funcCustomAttrDict = funcAttrDict[funcIndex]
        for i, attrDict in enumerate(attrList):
            curAttrDict = funcAttrList[i]
            AddAttrDictValue(attrDict, curAttrDict)
        customAttrDict.update(funcCustomAttrDict)
        AddAttrDictValue(insidePerAttrDict, funcInsidePerAttrDict)
    return attrList, insidePerAttrDict, customAttrDict

## ÖØÖûº´æ
def ClearCalcAttrListValue(curPlayer, funcIndex):
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_playerFuncAttrDict:
        return
    funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
    funcAttrDict.pop(funcIndex, None)
    return

def AddAttrListValue(attrList):
    addAttrList = [{} for _ in range(4)]
    for aList in attrList:
        for i in ChConfig.CalcAttrIndexList:
            AddAttrDictValue(addAttrList[i], aList[i])
    return addAttrList

## ÊôÐÔÖµ×ÖµäÀÛ¼Ó
def AddAttrDictValue(dict1, dict2):
    for key, value in dict2.items():
        if key not in dict1:
            dict1[key] = value
        else:
            aValue = dict1[key]
            if key in ChConfig.TYPE_Calc_DeclineList:
                # ÕâÖÖËã·¨µÄÊôÐÔÒ»°ãÊÇÍò·ÖÂʵģ¬×î´ó²»³¬¹ý°Ù·Ö°Ù£¬¹ÊÔÝĬÈÏÍò·ÖÂÊ, ÈôÓв»ÊÇÍò·ÖÂʵÄÊôÐÔÔÙ×ö´¦Àí
                dict1[key] = 10000 - (10000 - aValue) * (10000 - value)
            else:
                dict1[key] = aValue + value
    return

#-------------------------------------------------------------------------------
## ÉèÖÃÍæ¼Ò×ÖµäÖµ, ´æ¿â
def NomalDictSetProperty(curPlayer, key, value, dType=0):
    if CrossPlayerData.IsNeedProcessCrossPlayer(curPlayer) and key not in \
        [ChConfig.Def_PDict_FightPower_Total, ChConfig.Def_PDict_FightPower_TotalEx, ChConfig.Def_PlayerKey_CrossRegisterMap]:
        playerID = curPlayer.GetPlayerID()
        changeDict = PyGameData.g_crossPlayerDictChangeInfo.get(playerID, {})
        changeDict[(key, dType)] = value
        PyGameData.g_crossPlayerDictChangeInfo[playerID] = changeDict
        
    if value == 0:
        curPlayer.NomalDictDelProperty(key, dType)
        return
    # 2^31 - 1
    curPlayer.NomalDictAddProperty(key, min(value, ChConfig.Def_UpperLimit_DWordEx), dType)
    return

## ֪ͨף¸£Öµ
def Sync_BlessValue(curPlayer, blessType, value, multiple=0):
    itemList = []

    valuePack = ChPyNetSendPack.tagMCSyncSingleBlessValue()
    valuePack.Clear()
    valuePack.Type = blessType
    valuePack.Value = value
    valuePack.Multiple = multiple
    itemList.append(valuePack)
    
    sendPack = ChPyNetSendPack.tagMCSyncBlessValue()
    sendPack.Clear()
    sendPack.TypeCnt = len(itemList)
    sendPack.BlessInfo = itemList
    
    #֪ͨ¿Í»§¶Ë
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

#ͬ²½ÉèÖà Íæ¼ÒºÍ³èÎï¼°ÒÑÕÙ»½µÄÕÙ»½ÊÞ ÊÓÒ°²ã
def SetPlayerSightLevel(curPlayer, sightLevel):
    # µ±ÊÓÒ°ÉèÖÃ0ʱ£¬ÔÚ¾³½çµØͼÔò×Ô¶¯ÉèÖÃÒÑÑ¡ÔñµÄ¾³½çÄѶÈÊÓÒ°
    if sightLevel == 0:
        realmDifficulty = GetMapRealmDifficulty(curPlayer)
        if realmDifficulty:
            sightLevel = realmDifficulty
            GameWorld.DebugLog("¾³½çµØͼ×Ô¶¯ÉèÖÃÒÑÑ¡ÔñµÄ¾³½çÄѶÈÊÓÒ°: sightLevel=%s" % sightLevel)
            
    curPlayer.SetSightLevel(sightLevel)
    rolePet = curPlayer.GetPetMgr().GetFightPet()
    #ÎÞ³öÕ½³èÎï
    if rolePet:
        rolePet.SetSightLevel(sightLevel)
    
    for i in range(curPlayer.GetSummonCount()):
        curSummon = curPlayer.GetSummonNPCAt(i)
        if not curSummon:
            continue
        curSummon.SetSightLevel(sightLevel)
    return