#!/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 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 PlayerActGarbageSorting
import GY_Query_CrossRealmReg
import PlayerTongTianLing
import PlayerCrossRealmPK
import FunctionNPCCommon
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 PlayerTask
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 not curPlayer.GetSpeed():
        return False
    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[:3]
        appointID = mailItem[3] if len(mailItem) > 3 else 0
        if appointID:
            UserData = {ShareDefine.Def_CItemKey_AppointID:appointID}
            itemDict = {'ItemID':itemID, 'Count':itemCnt, 'IsAuctionItem':isAuctionItem, 'UserData':UserData}
            combineItemList.append(str(itemDict))
        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
#---------------------------------------------------------------------
##É±ËÀÍæ¼ÒËùÓÐµÄÕÙ»½ÊÞËÀÍö
# @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)
    
    #Àë¿ªµØÍ¼Çå¿Õ¶ñÒâ¹¥»÷×Ô¼ºÍæ¼ÒÐÅÏ¢
    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 È·±£ÊÇ´Ó±¾µØÍ¼ÖÐÀëÏßµÄ²Å¿ÉÊ¹ÓÃ
    # @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:
            ipyData = IpyGameDataPY.GetIpyGameData("CreateRole", curPlayer.GetRoleType())
            if not ipyData:
                return
            mapID, posX, posY = ipyData.GetCreateRoleMap()
            lineID = 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 PlayerCrossRealmPK.GetIsCrossPKMatching(curPlayer):
        NotifyCode(curPlayer, "CrossMap3")
        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
    
    ## ¿ç·þPKÆ¥ÅäÖÐ
    if PlayerCrossRealmPK.GetIsCrossPKMatching(curPlayer):
        if isNotify:
            NotifyCode(curPlayer, "CrossMatching8", [mapID])            
        return ShareDefine.EntFBAskRet_CrossPKMatching
    
    ## ¿ç·þµØÍ¼ÖÐ
    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 ÈËÎïËùÔÚµÄ³¡¾°³õÊ¼»¯#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ËùÖ¸¶¨µÄµØÍ¼µÄÄ³Ò»ÄÚ²¿·ÖÏß£¬ÕâÀïµÄÄ³Ò»ÄÚ²¿·ÖÏßÏÞÓÚ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 = GetPayCoin(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
        #âýÓ¢°æ£º »Ö¸´°óÓñ£¬µ«ÊÇ²»Ê¹ÓÃÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔò£¬Ô­À´ÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔòÒ»ÑùÎªÄ¬ÈÏ¿ÛÏÉÓñ 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)
        if curPlayerPayCoin < price:
            return False
        #ÓÐ×ã¹»µÄÇ®Ö§¸¶
        SetPayCoin(curPlayer, curPlayerPayCoin - price)
        
    #×Ô¶¨Òå»õ±Ò
    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:
        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)
    
    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)
    #===========================================================================
    
    # ³ý×êÊ¯¼°°ó×êÍâ£¬Î´Ö¸¶¨²Ù×÷ÀàÐÍµÄ²»¼ÇÂ¼
    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
    # Á÷ÏòÓÃ 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 == ShareDefine.TYPE_Price_PayCoin:
        playerID = curPlayer.GetPlayerID()
        nowMoney = GetMoneyReal(curPlayer, type_Price)
        orderInfo = infoDict.get("orderInfo", "")
        GameWorld.Log("¼ÇÂ¼ÏûºÄ´ú±Ò: eventName=%s,price=%s,nowMoney=%s,orderInfo=%s" % (eventName, price, nowMoney, orderInfo), playerID)
        GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [2, price, nowMoney], orderInfo, 1)
    #===========================================================================
    # 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]:
    #    
    #    # ½ð±ÒÎ´Ö¸¶¨Ïû·ÑÀàÐÍµÄ²»¼ÇÂ¼
    #    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 isSysHint and priceType != ShareDefine.TYPE_Price_BourseMoney:
        #Í¨Öª¿Í»§¶ËµÃµ½½ðÇ®
        NotifyCode(curPlayer, "GetMoney", [priceType, value])
        
    __GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict)
    
    return True

def __GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict):
    # ³ý×êÊ¯¼°°ó×êÍâ£¬Î´Ö¸¶¨²Ù×÷ÀàÐÍµÄ²»¼ÇÂ¼
    
    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
        
    DataRecordPack.DR_GiveMoney(curPlayer, eventName, priceType, value, addDataDict)
    EventReport.WriteEvent_virtual_resource(curPlayer, priceType, giveType, 1, value,
                                            ShareDefine.Def_UserAction_Money_Get, addDataDict)
    
    if priceType == ShareDefine.TYPE_Price_PayCoin:
        playerID = curPlayer.GetPlayerID()
        nowMoney = GetMoneyReal(curPlayer, priceType)
        orderInfo = addDataDict.get("orderInfo", "")
        GameWorld.Log("¼ÇÂ¼»ñµÃ´ú±Ò: eventName=%s,value=%s,nowMoney=%s,orderInfo=%s" % (eventName, value, nowMoney, orderInfo), playerID)
        GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [1, value, nowMoney], orderInfo, 1)
#===============================================================================
#    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_AtkBackHP) # ¹¥»÷»Ø¸´ÑªÁ¿
        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()
        
        #»ñÈ¡²ß»®ÅäÖÃµÄ±í¸ñ
        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 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¼¶ºó ÒÔÇ°ÊÇ¼Ó¼¼ÄÜµãÏÖ¸Ä³ÉÖ±½ÓÉý¼¶ºó¶Á±í¼Ó¼¼ÄÜ
    #  @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

        # ¼ì²é×î´óµÈ¼¶
        if curLV >= maxLV and curTotalExp >= maxLVExpStore:
            self.__NotifyExpFull(curPlayer, "GeRen_admin_825676")
            #GameWorld.DebugLog("¾­ÑéÒÑÂú£¡ÒÑÂú¼¶£¡curLV=%s" % (curLV), 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:
            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
                PlayerTask.UpdTaskValue(curPlayer, ChConfig.TaskType_LV)
                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()
        roleType = curPlayer.GetRoleType()
        ipyData = IpyGameDataPY.GetIpyGameData("CreateRole", roleType)
        if not ipyData:
            return
        baseAttrIDList = ipyData.GetBaseAttrIDList()
        baseAttrValueList = ipyData.GetBaseAttrValueList()
        allAttrList = [{} for _ in range(4)]
        
        # ³õÊ¼ÊôÐÔ
        if baseAttrIDList and baseAttrValueList and len(baseAttrIDList) == len(baseAttrValueList):
            for i, attrID in enumerate(baseAttrIDList):
                CalcAttrDict_Type(attrID, baseAttrValueList[i], allAttrList)
        #GameWorld.DebugLog("³õÊ¼¼ÓÊôÐÔ: %s" % allAttrList)
        
        # µÈ¼¶³É³¤ÊôÐÔ
        LV = curPlayer.GetLV()
        lvAttrDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAttr%s" % job, 1)
        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)
        
        #ÔÚ´Ë´¦°ÑËùÓÐÊôÐÔµÄ²»Í¬Í¨Öª¸ø¿Í»§¶Ë
        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):
        GameWorld.DebugLog("Start RefreshAllState!!!")
        
        self.RefreshPlayerActionState()
        self.RefreshPlayerAttrState(billboardFunc, isForce)
        return
    
    
    ## ÖØ¼ÆËã²¢Ë¢ÐÂÍæ¼ÒËùÓÐ×´Ì¬, Ä¿Ç°Ö»ÓÃÓëÇÐ»»µØÍ¼
    #  @param self ÀàÊµÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÍæ¼ÒËùÓÐ×´Ì¬
    def ReCalcAllState(self):
        GameWorld.DebugLog("Start ReCalcAllState!!!")
        curPlayer = self.__Player
        
        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)
        self.RefreshAllState(isForce=True)
        GameWorld.DebugLog("End ReCalcAllState!!!")
        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
        
        GameWorld.DebugLog("Start RefreshPlayerAttrByBuffEx!!!")
        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)
        #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!!!")
        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²ã¼¶£º°Ù·Ö±È¿É¶Ô¹¦ÄÜ°Ù·Ö±È¼Ó³ÉµÄÊôÐÔ½øÐÐ¶þ´Î¼Ó³É
            
                    ¹¦ÄÜÄ£¿é£º¶¨ÒåÒ»¸ö¹¦ÄÜ£¬±ÈÈçÁé¸ùÄ£¿é£¬Ò»¸öÄ£¿é¿ÉÄÜ°üº¬¶à¸ö¹¦ÄÜµã
                    ¹¦ÄÜµã£ºÄ³¸öÄ£¿éÏÂµÄ¸÷¸öÊôÐÔ¹¦ÄÜµã£¬ÈçÁé¸ùÄ£¿é¿ÉÄÜ°üº¬ Áé¸ù»ù´¡¡¢Áé¸ùÆ·ÖÊ Á½¸ö¹¦ÄÜµãÊôÐÔ
        
                    °Ù·Ö±È¼Ó³ÉÖµ£º°Ù·Ö±È¼Ó³ÉÊôÐÔÖµ²»±»³ý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) # ¹Å±¦¶¨Î»Îª¶Ô¹áÍ¨ËùÓÐÓÎÏ·¹¦ÄÜÏµÍ³µÄÊôÐÔÍæ·¨£¬ËùÒÔÃ¿´Î¶¼ÖØÐÂË¢ÐÂ
        
        GameWorld.DebugLog("Start RefreshPlayerAttrStateEx!!!")
        
        #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)
        #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))
            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))
            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))
        GameWorld.DebugLog("¹¦ÄÜµãÊôÐÔ: %s(%s), %s, ÄÚ²ã°Ù·Ö±È¸½¼Ó: %s" 
                           % (ChConfig.Def_CalcAttrFunc_LingGenQuailty, ChConfig.FuncIndexName.get(ChConfig.Def_CalcAttrFunc_LingGenQuailty, ""), lingGenQualityAttrList, lingGenQualityInsidePerAttrDict))
        
        #self.PrintAttr(curPlayer, "»ù´¡ºó")
        
        # 3.¼ÆËãÕ½¶·ÊôÐÔ
        #    3.1 Õ½¶·ÊôÐÔ²ã¼¶½»²æÓ°Ïì»ùÖµÊýÖµ»ã×Ü
        #        »ù´¡²ã¼¶(½ÇÉ«»ù´¡ÊôÐÔ)
        baseAttrList = AddAttrListValue([funcAttrInfoList[ChConfig.Def_CalcAttrFunc_RoleBase],
                                         funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGen],
                                         funcAttrInfoList[ChConfig.Def_CalcAttrFunc_LingGenQuailty],
                                         ])
        #GameWorld.DebugLog("»ù´¡²ã¼¶: %s" % baseAttrList)
        
        #        ¹¦ÄÜµã½»²æÓ°Ïì·ÇÏßÐÔ²ã¶ÔÓ¦ÊôÐÔ»ùÖµÁÐ±í
        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],
                           }
        #    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))
            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]
                useAttrDict = funcAttrPerInfo[noLineAttrType][ChConfig.CalcAttr_Battle] # Ä¬ÈÏÔö¼ÓµÄÊÇÕ½¶·ÏßÐÔ
                for attrType in addAttrTypeList:
                    # Ä¬ÈÏÌáÉýµÄÊôÐÔÔÚÏßÐÔÕ½¶·ÊôÐÔÀï
                    if attrType not in useAttrDict:
                        continue
                    baseValue = useAttrDict[attrType] # Ö»ÊÇÓÃµ½Ä¿±ê¹¦ÄÜµÄ»ùÖµ
                    addValue = int(baseValue * attrRate)
                    addAttrDict[attrType] = addAttrDict.get(attrType, 0) + addValue
                    #GameWorld.DebugLog("    attrID=%s,per=%s,rate=%s,baseValue=%s,attrType=%s,addValue=%s" % (noLineAttrType, addAttrPer, attrRate, baseValue, attrType, addValue))
                    
            if addAttrDict:
                # Ôö¼ÓµÄÊýÖµÍ³¼Æµ½°Ù·Ö±ÈÊôÐÔËùÊô¹¦ÄÜµã
                # Èç·ûÎÄÓÐ¸öÎäÆ÷¹¥»÷°Ù·Ö±ÈÔö¼ÓÊôÐÔ£¬Ôö¼ÓµÄÊýÖµÊôÓÚ·ûÎÄ¹¦ÄÜ£¬²»ÊôÓÚÎäÆ÷¹¦ÄÜµãµÄ£¬Ö»ÊÇ»ùÖµÊ¹ÓÃÁËÎäÆ÷¹¥»÷     
                funcCrossAttrPerInfoDict[i] = addAttrDict # ÏÈ¶¼Í³¼ÆÍêºóÔÙÀÛ¼Óµ½¶ÔÓ¦¹¦ÄÜÊôÐÔÀï£¬²»È»¿ÉÄÜ»áµ¼ÖÂ¹¦ÄÜ»ùÖµ±ä¸ü
                
        GameWorld.DebugLog("½»²æÓ°ÏìÊôÐÔ: %s" % funcCrossAttrPerInfoDict)
        
        #    3.3 Í³¼ÆËùÓÐ¹¦ÄÜ¹Ì¶¨ÊôÐÔÓ°ÏìÀÛ¼Ó
        allFixAttrDict = {} # ¹Ì¶¨ÊôÐÔ²ã¼¶×ÜÊôÐÔ»ùÖµ
        for funcIndex, funcAttrList in enumerate(funcAttrInfoList):
            # ¼¼ÄÜÄ£¿é²»¼ÆÈë¹¦ÄÜ¹Ì¶¨ÊôÐÔ¡¢²»¼ÆÕ½Á¦
            if funcIndex in ChConfig.CalcAttrFuncSkillList:
                continue
            AddAttrDictValue(allFixAttrDict, funcAttrList[ChConfig.CalcAttr_Battle])
            
        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)
        GameWorld.DebugLog("¹Ì¶¨°Ù·Ö±È¸½¼ÓÊôÐÔ: %s" % fixAttrPerAddExDict)
        
        # 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)
        
        # 5.±»¶¯¼¼ÄÜ¸½¼ÓÊôÐÔ£¬²»ËãÕ½Á¦
        passiveSkillAttrList = [{} for _ in range(4)]
        SkillShell.CalcPassiveAttr_Effect(curPlayer, passiveSkillAttrList)  # ÊôÐÔÀà¼¼ÄÜÓëbuffÍ¬²ã
        for funcIndex in ChConfig.CalcAttrFuncSkillList:
            passiveSkillAttrList = AddAttrListValue([passiveSkillAttrList, funcAttrInfoList[funcIndex]])    
        GameWorld.DebugLog("ÎÞÕ½Á¦±»¶¯ÊôÐÔ: %s" % passiveSkillAttrList)
        
        skillFixAttrExDict = {}
        skillFixAddPerDict = passiveSkillAttrList[ChConfig.CalcAttr_BattleNoline]
        for fixAttrType, addPer in skillFixAddPerDict.items():
            if fixAttrType not in allFixAttrDict:
                continue
            curFixValue = allFixAttrDict[fixAttrType]
            addValueEx = int(curFixValue * addPer / 10000.0)
            skillFixAttrExDict[fixAttrType] = addValueEx
        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, passiveSkillAttrList[ChConfig.CalcAttr_Battle])
        CalcLineEffect.ChangePlayerAttrInLineEffectList(curPlayer, skillFixAttrExDict)
                
        #ÌØÊâÖ¸¶¨ÊôÐÔ¹«Ê½
        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)
            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!!!")
        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
        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)
        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
        GameWorld.DebugLog("Õ½Á¦¹¦ÄÜµã: %s" % ChConfig.MFPTypeAttrFuncIndexDict)
        GameWorld.DebugLog("Ä£¿éÕ½Á¦: %s" % mfpDict)
        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))
        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
        
        moveSpeedFormat = IpyGameDataPY.GetFuncCfg("MoveSpeed")
        
        if PlayerTruck.GetHaveAutoTruck(curPlayer):
            speed = IpyGameDataPY.GetFuncCfg("MoveSpeed", 3)
            GameWorld.DebugLog("ÔËïÚ¹Ì¶¨ËÙ¶ÈÖµ: speed=%s" % speed)
        else:
            speed = GetSpeedNotBuff(curPlayer)
            GameWorld.DebugLog("¹¦ÄÜÒÆ¶¯ËÙ¶ÈÖµ: speed=%s" % speed)
            
            # Æï³Ë×´Ì¬¼ÓÉÏÆï³Ë¸½¼ÓËÙ¶È
            if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse:
                speedHorse = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_SpeedHorse)
                speed += speedHorse
                GameWorld.DebugLog("    Æï³Ë×´Ì¬¸½¼ÓÖµ: %s, speed=%s" % (speedHorse, speed))
            
                
            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))
                
            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)
            
            fightPet = curPlayer.GetPetMgr().GetFightPet()
            #ÎÞ³öÕ½³èÎï
            if fightPet:
                fightPet.SetSpeed(moveSpeed)
                
        return

    ##Ë¢ÐÂ¹¥»÷¼ä¸ô
    # @param self ÀàÊµÀý
    # @return None
    def __SetAtkInterval(self):
        curPlayer = self.__Player
        
        atkSpeed = GameObj.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):
        GameWorld.DebugLog("Start RefreshPlayerActionState!!!")
        #curTime = time.clock()
        curPlayer = self.__Player
        
        #ÏÈÇå³ýËùÓÐ×´Ì¬
        OperControlManager.ClearObjActionState(curPlayer)
        
        #ÔÙ¸ù¾ÝBUFF ¼ÓÉÏ×´Ì¬
        SkillShell.CalcBuffer_ActionState(curPlayer)
    
    #---------------------------------------------------------------------
    ## Ë¢ÐÂÑªÁ¿ºÍÄ§
    #  @param self ÀàÊµÀý
    #  @return ·µ»ØÖµÎÞÒâÒå
    #  @remarks Ë¢ÐÂÑªÁ¿ºÍÄ§
    def __RestoreHPMP(self):
        curPlayer = self.__Player
        
        if not curPlayer.GetInitOK():
            #Íæ¼ÒÎ´³õÊ¼»¯³É¹¦, ²»ÐÞÕýÑªÁ¿ºÍÄ§·¨Öµ, Òò´ËÊ±ÓÐ¿ÉÄÜÒòÎªÄ³Ð©Ó°ÏìÖ÷½ÇµÄÎïÆ·Î´³õÊ¼»¯Íê±Ï(Èç³èÎï×°±¸)
            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)
        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 ²¢ÇÒÊÇ±»Íæ¼ÒÉ±ËÀµÄÔòÍ¨Öª
        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 = ChConfig.Def_PlayerFirstLoginOpenBackCnt + 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 = ChConfig.Def_FirstLogin_OpenWareHouseCnt + 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(ChConfig.Def_PackCnt_Treasure)
    
    #Í¨Öª¿Í»§¶Ë
    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¼Ó³É
    
    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 GetPayCoin(curPlayer): return curPlayer.GetExAttr11()
def SetPayCoin(curPlayer, value): return curPlayer.SetExAttr11(min(value, ChConfig.Def_UpperLimit_DWord), False, False)

## »ñÈ¡Åå´÷µÄ³ÆºÅ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 - 100
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 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.GetNeedLV())
    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¶ÔËÙ¶ÈµÄÓ°Ïì£» ´ËÊýÖµ²»ÊÇÕæÕýµÄÒÆ¶¯ËÙ¶È£¬Ö»ÊÇÓÃÓÚ¼ÆËãÒÆ¶¯ËÙ¶ÈµÄ²ÎÊýÖµ
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) # ÒÆ¶¯ËÙ¶ÈÖµÔÝ¶¨¹ã²¥ÖÜÎ§Íæ¼Ò
    
# PVP¹¥»÷»ØÑª
def GetPVPAtkBackHP(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_PVPAtkBackHP)
def SetPVPAtkBackHP(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_PVPAtkBackHP, 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 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 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 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

# ÃüÖÐ³É¹¦ÂÊ
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 GetBeHurtPer(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_BeHurtPer)
def SetBeHurtPer(curPlayer, value): curPlayer.SetDict(ChConfig.Def_PlayerKey_BeHurtPer, 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 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 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)

#---Ä§·¨¶ÜÉËº¦ÎüÊÕÀ¶ºÄ±ÈÂÊ----
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)
            
    mapSightType = GameMap.GetMapSightType()
    if mapSightType == ChConfig.SightType_Private:
        sightLevel = curPlayer.GetPlayerID() # Ç¿ÖÆÎªË½ÓÐ²ã¼¶
        
    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

def SetPlayerSightLevelByMap(curPlayer):
    playerID = curPlayer.GetPlayerID()
    sightLevel = playerSightLevel = curPlayer.GetSightLevel()
    mapSightType = GameMap.GetMapSightType()
    if mapSightType == ChConfig.SightType_Private:
        sightLevel = playerID
    else:
        # Ä¬ÈÏ¹«¹²ÊÓÒ° ChConfig.SightType_Public
        if playerSightLevel == playerID:
            sightLevel = 0 # Ë½ÈËÊÓÒ°Ç¿ÖÆ¸ÄÎª¹«¹²ÊÓÒ°
        else:
            # ¹«¹²ÊÓÒ°×ñÑ­ÆäËû×Ô¶¨ÒåÊÓÒ°²ã¼¶Âß¼­
            return
    
    if sightLevel == playerSightLevel:
        return
    GameWorld.DebugLog("µØÍ¼ÇÐ»»Íæ¼ÒÊÓÒ°: mapSightType=%s,playerSightLevel=%s to sightLevel=%s" 
                       % (mapSightType, playerSightLevel, sightLevel), playerID)
    SetPlayerSightLevel(curPlayer, sightLevel)
    return