#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package MirrorAttack
#
# @todo:¾µÏñÕ½¶·
# @author hxp
# @date 2024-10-17
# @version 1.0
#
# ÏêϸÃèÊö: ¾µÏñÕ½¶·£¬Ö§³ÖÓëÍæ¼Ò¾µÏñÊý¾ÝÕ½¶·£¬ÒÔNPCΪս¶·ÊµÀý£¬Ö§³Ö¿ìËÙÕ½¶·
#
#-------------------------------------------------------------------------------
#"""Version = 2024-10-17 15:00"""
#-------------------------------------------------------------------------------

import GameWorld
import ChPlayer
import ChConfig
import EffGetSet
import PlayerPet
import PetControl
import PyGameData
import ShareDefine
import PlayerHorse
import IPY_GameWorld
import PlayerControl
import OperControlManager
import PlayerViewCacheTube
import PassiveBuffEffMng
import GameWorldProcess
import ChNetSendPack
import IpyGameDataPY
import AttackCommon
import SkillCommon
import PlayerState
import SkillShell
import CommFunc
import PlayerFB
import GameMap
import FBLogic
import GameObj

import time
import math

Def_StateTimeList = [3, 60, 10] # ĬÈϽ׶Îʱ³¤£¬Ãë
Mirror_StartMoveTick = "Mirror_StartMoveTick"

class MirrorBattle():
    ## ij³¡Õ½¶·
    
    def __init__(self):
        self.Clear()
        return
    
    def Clear(self):
        self.isChangeMap = 0 # ÊÇ·ñÇÐͼս¶·µÄ
        self.isSysbg = False # ÊÇ·ñϵͳºǫ́½øÐÐÕ½¶·µÄ£¬Íæ¼ÒÎÞ¸ÐÖª£¬½öÖªµÀ½á¹û
        self.requestID = 0 # ÇëÇóID£¬Ò»°ãÊÇÍæ¼ÒID»òÕßϵͳ×Ô¶¨µÄID£¬Èçijһ³¡PKµÄ±êʶÐÅÏ¢
        self.playerID = 0 # ËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0
        self.battleID = 0 # ¸Ã³¡Õ½¶·µÄID£¬Ò»°ãÍæ¼Ò·¢ÆðµÄΪplayerID£¬ÏµÍ³·¢ÆðµÄΪ´óÓÚÊ®ÒÚµÄÖµ£¬¼´ 1000000000 + ¸Ãϵͳ³¡´Î¶ÔÓ¦¹¦ÄÜÖµ
        self.mapID = 0 # ¹¦ÄÜmapID£¬´ú±íijһ¸ö¹¦ÄÜ
        self.funcLineID = 0
        self.batState = 0 # ״̬£º0-ÎÞ£»1-×¼±¸ÖУ»2-Õ½¶·ÖУ»3-¿ìËÙ½áÊøÖУ¬4-½áÊø
        self.stateTick = 0 # ½×¶Î״̬±ä¸üʱtick
        self.stateTickRemain = 0 # ½×¶ÎÊ£Óàʱ³¤£¬tick
        self.mirrorIDDict = {} # ¸Ã³¡ËùÓÐÍæ¼Ò¾µÏñʵÀýID¶ÔÓ¦ÕæʵID {playerID:realPlayerID, ...}
        self.realIDDict = {} # ¸Ã³¡ËùÓÐÕæʵÍæ¼Ò¶ÔÓ¦³õʼÐÅÏ¢ {playerID:{k:v, ...}, ...}
        self.playerFactionDict = {} # ¸Ã³¡ËùÓÐÍæ¼ÒÕóÓªÐÅÏ¢£¬ÕæʵÍæ¼Ò+¾µÏñÍæ¼Ò {playerID:faction, ...}
        self.playerAutoSkillInfo = {} # Íæ¼Ò×Ô¶¯Êͷż¼ÄÜÁбí {playerID:[skillTypeID, ...], ...}
        self.deadPlayerIDList = [] # Òѱ»»÷ɱµÄÍæ¼ÒIDÁбí
        self.tagPlayerIDList = [] # ¶ÔÊÖÕæʵÍæ¼ÒIDÁбí
        
        self.isLogout = False # ÊÇ·ñÏÂÏßµÄ
        self.isQuick = False # ÊÇ·ñ¿ìËÙÕ½¶·½áÊøµÄ
        self.isWin = False # ÊÇ·ñ»ñʤ
        self.winFaction = 0 # »ñʤÕóÓª
        # ½áËãʱѪÁ¿Ã÷ϸ
        self.curHP = 0
        self.curHPMax = 0
        self.tagHP = 0
        self.tagHPMax = 0
        return
    
    def GetTagPlayerID(self): return self.tagPlayerIDList[0] if self.tagPlayerIDList else 0
    
    def SyncFBStepTime(self, tick):
        #curPlayer.Sync_TimeTick(IPY_GameWorld.tttWaitStart, 0, max(notify_tick, 0), True)
        if self.isSysbg:
            return
        self.CaclStateTick(tick)
        state = self.batState
        if state == ChConfig.Def_MirrorBatState_Prepare:
            self.__SyncRealPlayerTick(ChConfig.tttWaitStart, self.stateTickRemain)
        elif state == ChConfig.Def_MirrorBatState_Fight:
            self.__SyncRealPlayerTick(ChConfig.tttTowerTake, self.stateTickRemain)
        elif state == ChConfig.Def_MirrorBatState_Over:
            self.__SyncRealPlayerTick(ChConfig.tttLeaveMap, self.stateTickRemain)
        return
    
    def __SyncRealPlayerTick(self, msgType, msgTick):
        playerMgr = GameWorld.GetMapCopyPlayerManager()
        for playerID in self.realIDDict.keys():
            curPlayer = playerMgr.FindPlayerByID(playerID)
            if not curPlayer:
                continue
            curPlayer.Sync_TimeTick(msgType, 0, msgTick, True)
        return
    
    def ChangeBattleState(self, state, tick):
        GameWorld.DebugLog("¾µÏñÕ½¶·½×¶Î±ä¸ü: mapID=%s,state=%s" % (self.mapID, state), self.battleID)
        self.batState = state
        self.stateTick = tick        
        self.stateTickRemain = self.GetStateTickMax()
        self.SyncFBStepTime(tick)
        return
        
    def CaclStateTick(self, tick):
        ## ¼ÆËã״̬ʱ³¤£¬·µ»ØÊ£Óàʱ³¤tick
        stateTickMax = self.GetStateTickMax()
        passTick = tick - self.stateTick # Òѹýʱ³¤
        self.stateTickRemain = max(0, stateTickMax - passTick) # Ê£Óàʱ³¤
        return self.stateTickRemain
    
    def GetStateTickRemain(self): return self.stateTickRemain
    def GetStateTickMax(self):
        fightTimeLimitDict = IpyGameDataPY.GetFuncEvalCfg("MirrorAttack", 1, {})
        stateTimeList = fightTimeLimitDict.get(self.mapID, []) # ½×¶Îʱ³¤Áбí
        if not stateTimeList or len(stateTimeList) != 3:
            stateTimeList = Def_StateTimeList
            
        state = self.batState
        stateTime = 0
        if state == ChConfig.Def_MirrorBatState_Prepare:
            stateTime = stateTimeList[0]
        elif state == ChConfig.Def_MirrorBatState_Fight:
            stateTime = stateTimeList[1]
        elif state == ChConfig.Def_MirrorBatState_Over:
            stateTime = stateTimeList[2]
        return stateTime * 1000
    
    def CalcHPPer(self):
        ## ½áË㵱ǰ½×¶ÎË«·½ÕóӪʣÓàѪÁ¿Õ¼±È£¬Ò»°ãÓÃÓÚ½áËã¼ÆËã
        if not self.curHPMax or not self.tagHPMax:
            return 0, 0
        curHPPer = round(self.curHP / float(self.curHPMax) * 100, 2)
        tagHPPer = round(self.tagHP / float(self.tagHPMax) * 100, 2)
        return curHPPer, tagHPPer
    def CalcRemainTimePer(self):
        ## ½áË㵱ǰ½×¶ÎÊ£Óàʱ¼äÕ¼±È£¬Ò»°ãÓÃÓÚ½áËã¼ÆËã
        remainTimePer = round(self.stateTickRemain / float(self.GetStateTickMax()) * 100)
        return remainTimePer
    
    def AddBattlePlayer(self, curPlayer, faction, posX=0, posY=0):
        playerID = curPlayer.GetPlayerID()
        realPlayerID = curPlayer.GetRealPlayerID()
        if realPlayerID:
            self.mirrorIDDict[playerID] = realPlayerID
        else:
            self.realIDDict[playerID] = {"SightLevel":curPlayer.GetSightLevel(), "Faction":curPlayer.GetFaction()}
        self.playerFactionDict[playerID] = faction
                
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleID, self.battleID)
        if posX and posY:
            curPlayer.ResetPos(posX, posY)
        curPlayer.SetCanAttack(True)
        curPlayer.SetFaction(faction)
        PlayerControl.SetPlayerSightLevel(curPlayer, self.battleID) # ÊÓÒ°²ã¼¶Ä¬ÈÏΪս³¡ID£¬Ã¿³¡Õ½¶·µÄÍæ¼Ò¶ÀÁ¢ÊÓÒ°
        PlayerControl.SetSight(curPlayer, ChConfig.Def_PlayerSight_Default * 3)
        GameObj.SetHPFull(curPlayer) # »ØÂúѪ
        PlayerControl.SetProDef(curPlayer, PlayerControl.GetMaxProDef(curPlayer))
        SkillCommon.ResetAllSkillCD(curPlayer) # ÖØÖü¼ÄÜCD
        return
    
    def GetPlayerAutoUseSkillList(self, curPlayer):
        playerID = curPlayer.GetPlayerID()
        if playerID in self.playerAutoSkillInfo:
            return self.playerAutoSkillInfo[playerID]
        
        # J.¼¼ÄÜ´îÅä±í.xlsx ÅäÖõļ¼ÄÜ
        job = curPlayer.GetJob()
        defaultSkillList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetSkillMatchCount()):
            ipyData = ipyDataMgr.GetSkillMatchByIndex(index)
            skills = ipyData.GetSkills()
            if job > len(skills):
                continue
            defaultSkillList.append(skills[job - 1])
            
        playerSetting = curPlayer.GetSetting()
        autoUseSkillList = CommFunc.ParseSetting_AutoSkillList(playerSetting, defaultSkillList)
        curJobCommAtkSkillIDList = IpyGameDataPY.GetFuncEvalCfg("JobFitterSkill", job)
        # ÆÕ¹¥·Å×îºó
        for commSkillID in curJobCommAtkSkillIDList:
            autoUseSkillList.append(commSkillID)
        GameWorld.DebugLog("¼ÓÔØÍæ¼ÒÉèÖõÄ×Ô¶¯¼¼ÄÜ: %s" % autoUseSkillList, playerID)
        self.playerAutoSkillInfo[playerID] = autoUseSkillList
        return autoUseSkillList
    
def AddMirrorBattle(battleID, mapID=0, funcLineID=0, requestID=0, isSysbg=False, playerID=0):
    ## Ôö¼Ó¾µÏñÕ½¶·¹ÜÀí
    # @param battleID: Õ½¶·ID
    battle = None
    if battleID and battleID not in PyGameData.g_mirrorBattleDict:
        battle = MirrorBattle()
        battle.battleID = battleID
        battle.mapID = mapID
        battle.funcLineID = funcLineID
        battle.requestID = requestID
        battle.isSysbg = isSysbg
        battle.playerID = playerID
        PyGameData.g_mirrorBattleDict[battleID] = battle
    return battle

def GetMirrorBattle(curPlayer):
    ## »ñÈ¡Íæ¼ÒʵÀýËùÊôµÄÕ½³¡
    if curPlayer.GetRealPlayerID():
        return GetMirrorBattleByID(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MirrorBattleID))
    return GetMirrorBattleByID(curPlayer.GetPlayerID())

def GetMirrorBattleByID(battleID):
    battle = None
    if battleID in PyGameData.g_mirrorBattleDict:
        battle = PyGameData.g_mirrorBattleDict[battleID]
    # ²»»áÖ´ÐУ¬½öΪÁË´úÂë±à¼­.ʱ³öÌáʾ
    if False:
        battle = MirrorBattle()
    return battle

def ClearMirrorBattleByID(battleID):
    ## Çå³ý¾µÏñÕ½¶·
    battle = PyGameData.g_mirrorBattleDict.pop(battleID, None)
    if not battle:
        return
    ownerPlayerID = battle.playerID
    isSysbg = battle.isSysbg
    isQuick = battle.isQuick
    GameWorld.DebugLog("Çå³ý¾µÏñÕ½¶·: battleID=%s,ownerPlayerID=%s,isSysbg=%s,isQuick=%s" % (isSysbg, ownerPlayerID, isSysbg, isQuick), battleID)
    playerMgr = GameWorld.GetPlayerManager()
    tick = GameWorld.GetGameWorld().GetTick()
    
    # »ØÊÕ¾µÏñÍæ¼Ò
    for mirrorID in battle.mirrorIDDict.keys():
        mirrorPlayer = playerMgr.FindPlayerByID(mirrorID)
        if mirrorPlayer:
            PlayerControl.DeleteMirror(mirrorPlayer, isSysbg) # ϵͳ³¡ÑÓ³Ù»ØÊÕ
            
    # ÖØÖÃÕæʵÍæ¼Ò
    for realPlayerID, info in battle.realIDDict.items():
        curPlayer = playerMgr.FindPlayerByID(realPlayerID)
        if not curPlayer:
            continue
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleID, 0)
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleTime, 0)
        if curPlayer.GetPlayerAction() == IPY_GameWorld.paDie or GameObj.GetHP(curPlayer) <= 0:
            ChPlayer.PlayerRebornByType(curPlayer, ChConfig.rebornType_System, tick, isAddSuperBuff=False)
        curPlayer.SetFaction(info.get("Faction", 0))
        PlayerControl.SetPlayerSightLevel(curPlayer, info.get("SightLevel", 0))
        PlayerControl.SetSight(curPlayer, ChConfig.Def_PlayerSight_Default)
        
        if not isQuick:
            continue
        
        GameObj.SetHPFull(curPlayer) # »ØÂúѪ
        PlayerControl.SetProDef(curPlayer, PlayerControl.GetMaxProDef(curPlayer))
        SkillCommon.ResetAllSkillCD(curPlayer) # ÖØÖü¼ÄÜCD
        curPlayer.SetAttackTick(tick)
        ChPlayer.__Sync_ClientBuff(curPlayer)
        
    # ËùÊôÍæ¼Ò
    curPlayer = playerMgr.FindPlayerByID(ownerPlayerID)
    if curPlayer:
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleID, 0)
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleTime, 0)
        
    # Èç¹ûÊÇÕæʵµØͼս¶·µÄ£¬¹Ø±Õ¸±±¾
    if battle.isChangeMap:
        GameWorldProcess.CloseFB(GameWorld.GetGameWorld().GetTick())
    return

def CreateMirrorPlayer(battleID, mirrorPlayerID, mirrorPlayerData, posX=0, posY=0, faction=0, curPlayer=None):
    ''' ´´½¨¾µÏñÍæ¼Ò 
    @param battleID: ËùÊôµÄÕ½¶·ID
    @param mirrorPlayerID: Ä¿±ê¾µÏñÍæ¼ÒID
    @param mirrorPlayerData: Ä¿±ê¾µÏñÍæ¼ÒÊý¾Ý
    @param curPlayer: Ö´Ðд´½¨µÄÍæ¼Ò
    '''
    
    battle = GetMirrorBattleByID(battleID)
    if not battle:
        GameWorld.ErrLog("ûÓиþµÏñÕ½¶·ID£¬ÎÞ·¨´´½¨Íæ¼Ò¾µÏñ! battleID=%s" % battleID)
        return
    mapID = battle.mapID
    funcLineID = battle.funcLineID
    
    playerID = 0
    if curPlayer:
        playerID = curPlayer.GetPlayerID()
        
    # playerDataΪbase64ºóµÄÊý¾Ý
    mirrorPlayer = GameWorld.GetGameWorld().CreateMirrorPlayer(mirrorPlayerData, posX, posY)
    if not mirrorPlayer:
        GameWorld.ErrLog("CreateMirrorPlayer mirrorPlayerID=%s,posX=%s,posY=%s,faction=%s" 
                         % (mirrorPlayerID, posX, posY, faction), playerID)
        return
    if not battle.isChangeMap:
        PlayerControl.SetCustomMap(mirrorPlayer, mapID, funcLineID)
    else:
        PlayerControl.SetCustomMap(mirrorPlayer, 0, 0)        
    mirrorID = mirrorPlayer.GetID()
    realPlayerID = mirrorPlayer.GetRealPlayerID()
    dataFightPower = PlayerControl.GetFightPower(mirrorPlayer)
    GameWorld.DebugLog("CreateMirrorPlayer mirrorID=%s,realPlayerID=%s,mapID=%s,funcLineID=%s,posX=%s,posY=%s,faction=%s,dataFightPower=%s,,accID=%s" 
                       % (mirrorID, realPlayerID, mapID, funcLineID, posX, posY, faction, dataFightPower, mirrorPlayer.GetAccID()), playerID)
    if faction != 1:
        battle.tagPlayerIDList.append(realPlayerID)
        
    ChPlayer.InitPlayerPack(mirrorPlayer)
    PlayerHorse.PlayerRideHorseUp(mirrorPlayer, False, False)
    
    #ÊÇ·ñ¾µÏñÍæ¼Ò ÅÐ¶Ï mirrorPlayer.GetRealPlayerID()ÊÇ·ñΪ0
    #python×Ô¼º´¦Àí£¬ÒÔÏÂÂß¼­£¬¿ÉÒÔÔÚDoPlayerLoginº¯Êý×îºó ÅжÏÊǾµÏñÍæ¼Òºóͳһ´¦Àí
    #index = mirrorPlayer.GetIndex()
    #tick = GameWorld.GetGameWorld().GetTick()
    #ChPlayer.PlayerLogin
    #PlayerEventCounter.GameServer_InitOK(index, tick)
    #ChPlayer.LoadMapOK(index, tick)
    #GameServerRefresh.GameSever_PlayerInitOK(index, tick)
    mirrorPlayer.SendToBServerServerInitOK()
    mirrorPlayer.SetMapLoadOK(True)
    #½«Íæ¼Ò·ÅÖÃÔÚÕâ¸öµØͼÉÏ
    mirrorPlayer.InitPos(mirrorPlayer.GetPosX(), mirrorPlayer.GetPosY())
    #°ÑÍæ¼ÒÉèÖÃΪ³õʼ»¯³É¹¦×´Ì¬
    mirrorPlayer.SetCanAttack(True)
    mirrorPlayer.SetCanMove(True)
    mirrorPlayer.SetIsNeedProcess(True)
    mirrorPlayer.SetInitOK(True)
    mirrorPlayer.EndLoadMap()
    mirrorPlayer.SetGameServerInitOK(True)
    
    #Ë¢±»¶¯¡¢ÊôÐÔ
    PassiveBuffEffMng.OnLoadMapGFPassive(mirrorPlayer)
    mirrorControl = PlayerControl.PlayerControl(mirrorPlayer)
    mirrorControl.ReCalcAllState()
    refreshFightPower = PlayerControl.GetFightPower(mirrorPlayer)
    if refreshFightPower != dataFightPower:
        GameWorld.ErrLog("CreateMirrorPlayer mirrorID=%s,realPlayerID=%s,dataFightPower=%s != refreshFightPower=%s" 
                         % (mirrorID, realPlayerID, dataFightPower, refreshFightPower), playerID)
        
    battle.AddBattlePlayer(mirrorPlayer, faction, posX, posY)
    
    #×îºóÉèÖÿɼû£¬Ë¢ÐÂÊÓÒ°
    mirrorPlayer.SetVisible(True)
    mirrorPlayer.RefreshView()
    
    #Áé³èÓÐЩÊôÐÔÈ¡Ö÷ÈËÍæ¼Ò£¬ËùÒÔÔÚÍæ¼ÒË¢ÍêÊôÐÔºó´¦Àí£¬Ò²±ØÐëÔÚÖ÷ÈËË¢ÐÂÊÓÒ°ºó´¦Àí£¬²»È»³öÏÖ·â°ü˳Ðò¿ÉÄܲ»¶Ô£¬µ¼ÖÂÇ°¶ËÎÞ·¨ÏÔʾÁé³è
    PetControl.DoLogic_PetLoadMapOK(mirrorPlayer)
    
    if GameWorld.GetGameWorld().GetDebugLevel():
        DebugLogPlayerInfo(mirrorPlayer)
        if playerID == realPlayerID:
            DebugLogPlayerInfo(curPlayer)
    return mirrorPlayer

def DebugLogPlayerInfo(curPlayer):
    playerID = curPlayer.GetPlayerID()
    GameWorld.DebugLog("-------------- DebugLogPlayerInfoÍæ¼ÒÐÅÏ¢ --------------", playerID)
    realPlayerID = curPlayer.GetRealPlayerID()
    posX = curPlayer.GetPosX()
    posY = curPlayer.GetPosY()
    faction = curPlayer.GetFaction()
    sightLevel = curPlayer.GetSightLevel()
    sight = curPlayer.GetSight()
    GameWorld.DebugLog("realPlayerID=%s,posX=%s,posY=%s,faction=%s,sightLevel=%s,sight=%s" 
                       % (realPlayerID, posX, posY, faction, sightLevel, sight), playerID)
    GameWorld.DebugLog("ÉúÃü=%s/%s, »¤¶Ü=%s/%s" 
                       % (GameObj.GetHP(curPlayer), GameObj.GetMaxHP(curPlayer), 
                          PlayerControl.GetProDef(curPlayer), PlayerControl.GetMaxProDef(curPlayer)), playerID)
    
    # ÊôÐÔ
    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("AttrInfo=%s" % attrInfo, playerID)
    GameWorld.DebugLog("FightPower=%s" % (PlayerControl.GetFightPower(curPlayer)), playerID)
    
    # ¼¼ÄÜ
    skillDict = {}
    skillManager = curPlayer.GetSkillManager()
    for i in range(0 , skillManager.GetSkillCount()):
        curSkill = skillManager.GetSkillByIndex(i)
        if not curSkill:
            continue
        funcType = curSkill.GetFuncType()
        if funcType not in skillDict:
            skillDict[funcType] = {}
        skillInfo = skillDict[funcType]
        skillInfo[curSkill.GetSkillID()] = curSkill.GetSkillName()
    for funcType, skillInfo in skillDict.items():
        skillIDList = skillInfo.keys()
        skillIDList.sort()
        GameWorld.DebugLog("Skill FuncType=%s,count=%s,%s" % (funcType, len(skillIDList), skillIDList), playerID)
    
    # ±»¶¯
    passiveEff = PassiveBuffEffMng.GetPassiveEffManager().GetPassiveEff(curPlayer)
    if passiveEff:
        GameWorld.DebugLog("±»¶¯Ð§¹û £º%s" % passiveEff.AffectSkillDict, playerID)
        GameWorld.DebugLog("Ñ¡Öеı»¶¯¼¼ÄÜЧ¹û £º%s" % passiveEff.AffectPassiveSkillSetDict, playerID)
        GameWorld.DebugLog("±»¶¯BUFFЧ¹û £º%s" % passiveEff.AffectBuffDict, playerID)
        GameWorld.DebugLog("ÉñÊÞ±»¶¯Ð§¹û £º%s" % passiveEff.AffectDogzSkillDict, playerID)
    else:
        GameWorld.DebugLog("ÎÞ¼¼Äܱ»¶¯Ð§¹û!", playerID)
        
    fightPet = curPlayer.GetPetMgr().GetFightPet()
    if fightPet:
        GameWorld.DebugLog("³öÕ½³èÎï¼¼ÄÜ%s-%s" % PlayerPet.GetPetLearnSkill(curPlayer), playerID)
        passiveEff = PassiveBuffEffMng.GetPassiveEffManager().GetPassiveEff(fightPet)
        if passiveEff:
            GameWorld.DebugLog("³èÎï±»¶¯Ð§¹û £º%s" % passiveEff.AffectSkillDict, playerID)
            GameWorld.DebugLog("³èÎï±»¶¯BUFFЧ¹û £º%s" % passiveEff.AffectBuffDict, playerID)
        else:
            GameWorld.DebugLog("ÎÞ¼¼Äܱ»¶¯Ð§¹û!", playerID)
            
    # ÎïÆ·
    for packType in [IPY_GameWorld.rptEquip, ShareDefine.rptPet, ShareDefine.rptDogzEquip]:
        curPack = curPlayer.GetItemManager().GetPack(packType)
        itemCount = 0
        for i in range(0, curPack.GetCount()):
            item = curPack.GetAt(i)
            if not item.GetItemTypeID():
                continue
            itemCount += 1
            #GameWorld.DebugLog("packType=%s,i=%s,itemID=%s,userData=%s" % (packType, i, item.GetItemTypeID(), item.GetUserData()))
        GameWorld.DebugLog("packType:%s,count=%s/%s" % (packType, itemCount, curPack.GetCount()), playerID)
        
    GameWorld.DebugLog("-------------------------------------------------------", playerID)
    return

#// A1 09 ͬ²½´ò°üÍæ¼ÒÊý¾Ý #tagCMSycnPlayerPackData
#
#struct tagCMSycnPlayerPackData
#{
#    tagHead        Head;
#};
def OnSycnPlayerPackData(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    PlayerViewCacheTube.UpdateGameServerPlayerCache(curPlayer, tick, forcePackData=True)
    return

#// B4 11 ¾µÏñÕ½¶· #tagCMMirrorFight
#
#struct    tagCMMirrorFight
#{
#    tagHead        Head;
#    DWORD        MapID;    // ×Ô¶¨ÒåµØͼID£¬È羺¼¼³¡µÈ
#    WORD        FuncLineID;
#    DWORD        TagPlayeID;    // Ä¿±êÍæ¼ÒID£¬Ö§³Ö¿ç·þÍæ¼ÒID
#    BYTE        CmdType;    // ÃüÁîÀàÐÍ: 0-´´½¨Õ½¶·£»1-¿ªÊ¼Õ½¶·£»2-Õ½¶·ÖÐÌø¹ý£»3-²»´´½¨Õ½¶·Ö±½ÓµÃ½á¹û
#};
def OnMirrorFight(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    mapID = clientData.MapID
    funcLineID = clientData.FuncLineID
    tagPlayeID = clientData.TagPlayeID
    cmdType = clientData.CmdType
    
    if not tagPlayeID:
        return
    
    playerID = curPlayer.GetPlayerID()
    #if tagPlayeID == playerID:
    #    GameWorld.DebugLog("²»ÄÜ´ò×Ô¼º!", playerID)
    #    return
    
    # ´´½¨Õ½¶·£¬Íæ¼Ò×ÔÉí²ÎÓë
    if cmdType == 0:
        OnRequestCreateMirrorBattle(mapID, funcLineID, playerID, [[playerID], [tagPlayeID]], False, curPlayer, True)
        return
    
    # ¿ªÊ¼Õ½¶·£¬¸ÃÁ÷³Ì¸ÄΪºó¶Ë¿ØÖÆ
    #if cmdType == 1:
    #    battle = GetMirrorBattle(curPlayer)
    #   if battle:
    #        OnMirrorBattleStart(battle.battleID)
    #    return
    
    # Õ½¶·ÖÐÌø¹ý
    if cmdType == 2:
        battle = GetMirrorBattle(curPlayer)
        if battle:
            DoMirrorBattleQuick(battle.battleID, isClick=True)
        return
    
    # ²»Õ½¶·Ö±½ÓÌø¹ý£¬¼´Íæ¼ÒûÓвÎÓ룬´´½¨ÏµÍ³Õ½¶·³¡£¬Ö®ºóÀ©Õ¹
    if cmdType == 3:
        OnRequestCreateMirrorBattle(mapID, funcLineID, playerID, [[playerID], [tagPlayeID]], True, curPlayer)
        return
    
    # ¿É²»×öÑéÖ¤£¬PK½áÊøºóÓɸ÷¸ö¹¦ÄÜ×ÔÐÐ×ö½áËãÑéÖ¤
    return

def OnRequestCreateMirrorBattle(mapID, funcLineID, requestID, factionPlayerList, isSysbg=False, curPlayer=None, isChangeMap=False):
    ''' ÇëÇó´´½¨¾µÏñÕ½¶·£¬Ö§³Ö¶à¶Ô¶à£¬Ö§³Ö¿ç·þ£¬±¾·þ¿ç·þµØͼÖоù¿ÉÖ±½ÓÇëÇó
    @param mapID: ¹¦ÄܵØͼID
    @param funcLineID: ¹¦ÄܵØͼÏß·ID
    @param requestID: ÇëÇóID£¬Èç¹ûÊÇÍæ¼Ò·¢ÆðµÄ£¬Ò»°ã´«ÈëÍæ¼ÒID£»Èç¹ûÊÇϵͳ·¢ÆðµÄ£¬ÓÉϵͳ×ÔÐоö¶¨£¬±ÈÈçroomIDÖ®Àà
    @param factionPlayerList: Õ½¶·µÄÕóÓªÍæ¼ÒÁбí [[ÕóÓª1Íæ¼ÒID, ...], [ÕóÓª2Íæ¼ÒID, ...]]
    @param isSysbg: ÊÇ·ñºǫ́ս¶·£¬Ä¬ÈÏ·ñ£¬µ«ÊÇϵͳ·¢ÆðµÄĬÈÏÊÇ
    @param curPlayer: ·¢ÆðµÄÍæ¼Ò£¬Îª¿Õʱ´ú±íϵͳ·¢Æð´´½¨µÄ
    @param isChangeMap: ÊÇ·ñÇÐÕ½¶·³¡¾°µØͼ
    '''
    
    playerID = 0
    curTime = int(time.time())
    if curPlayer:
        if GameWorld.IsCrossServer():
            GameWorld.DebugLog("¿ç·þ·þÎñÆ÷Öв»ÔÊÐíÍæ¼Ò¾µÏñÕ½¶·ÇëÇó!", playerID)
            return
        if not FBLogic.OnMirrorBattleRequest(curPlayer, mapID, funcLineID, factionPlayerList):
            GameWorld.DebugLog("µ±Ç°²»ÔÊÐí¸Ã¾µÏñÕ½¶·ÇëÇó! mapID=%s,funcLineID=%s" % (mapID, funcLineID), playerID)
            return
        playerID = curPlayer.GetPlayerID()
        if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MirrorBattleID):
            GameWorld.DebugLog("¾µÏñÕ½¶·³¡¾°ÖУ¬ÎÞ·¨ÇëÇó!", playerID)
            return
        # ÇëÇócdÑéÖ¤
        requestTime = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MirrorBattleTime)
        if requestTime and (curTime - requestTime) <= 20: # 20ÃëÄÚ²»Öظ´ÇëÇó
            PlayerControl.NotifyCode(curPlayer, "RequestLater")
            return
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleTime, curTime)
    else:
        isSysbg = True # ϵͳ·¢ÆðµÄĬÈϺǫ́ս¶·
        
    mirrorIDList = [] # ÐèҪʹÓþµÏñµÄÍæ¼ÒIDÁбí
    for faction, batPlayerIDList in enumerate(factionPlayerList, 1):
        for batPlayerID in batPlayerIDList:
            if batPlayerID == playerID and faction == 1 and not isSysbg:
                # ×Ô¼º²»Óã¬Ê¹ÓÃ×ÔÉí½øÐÐÕ½¶·¼´¿É
                continue
            if batPlayerID not in mirrorIDList:
                mirrorIDList.append(batPlayerID)
                
    # Õ½¶·Ïà¹ØµÄÊý¾Ý
    msgData = {"mapID":mapID, "funcLineID":funcLineID, "factionPlayerList":factionPlayerList, "isSysbg":isSysbg}
    
    # ·¢ËÍGameServerÇëÇóÍæ¼Ò´ò°üÊý¾Ý
    requestTime = curTime # ÇëÇóµÄʱ¼ä´Á£¬Ã¿¸öÍæ¼Ò×î¶àÔÊÐíͬʱ´æÔÚÒ»³¡Õ½¶·£¬Ã¿´ÎÖØÐÂÇëÇóºó¸²¸ÇÊý¾Ý
    sceneMapID = GameWorld.GetGameWorld().GetRealMapID()
    sendMsg = {"msgType":"MirrorBattle", "msgData":msgData, "mirrorIDList":mirrorIDList, 
               "requestTime":requestTime, "requestID":requestID, "sceneMapID":sceneMapID, "playerID":playerID}
    
    if isChangeMap:
        # ĬÈÏÇе½PKµØͼ
        sendMsg["isChangeMap"] = 1
        PlayerControl.PlayerEnterFB(curPlayer, mapID, funcLineID, reqInfoEx=sendMsg)
        return True
    
    # Íæ¼Ò×ÔÉíÐèÒªÓþµÏñµÄÇé¿ö
    if isSysbg and playerID and playerID in mirrorIDList:
        PlayerViewCacheTube.NormalSyncPackData(curPlayer)
        
    sendMsg = str(sendMsg)
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "ReuestPlayerPackData", sendMsg, len(sendMsg))
    GameWorld.DebugLog("ÇëÇó´´½¨¾µÏñÕ½¶·: %s" % sendMsg, playerID)
    return True

def OnMirrorBattleEnterMapInit(curPlayer, tick):
    ''' ¾µÏñÕ½¶·³õʼ»¯  - ÐèÒªÇÐͼµÄ£¬Íæ¼ÒÇÐͼ³É¹¦»òµØͼÊÕµ½´ò°üÊý¾Ýͬ²½Ê±»á´¥·¢£¬¼´ÕâÁ½¸öÌõ¼þ¶¼×¼±¸ºÃºó²Å¿ªÊ¼³õʼ»¯
    '''
    if not curPlayer or curPlayer.IsEmpty() or not curPlayer.GetMapLoadOK():
        return
    
    battle = GetMirrorBattle(curPlayer)
    if battle:
        GameWorld.DebugLog("¾µÏñÕ½¶·Íæ¼Ò¶ÏÏßÖØÁ¬³É¹¦!", curPlayer.GetPlayerID())
        curPlayer.SetDict(ChConfig.Def_PlayerKey_MirrorBattleID, battle.battleID)
        curPlayer.SetFaction(1)
        PlayerControl.SetPlayerSightLevel(curPlayer, battle.battleID)
        PlayerControl.SetSight(curPlayer, ChConfig.Def_PlayerSight_Default * 3)
        battle.SyncFBStepTime(tick)
        return
    
    playerID = curPlayer.GetPlayerID()
    if playerID not in PyGameData.g_playerReqEnterFBEx:
        return
    reqInfo = PyGameData.g_playerReqEnterFBEx[playerID]
    if not reqInfo or len(reqInfo) != 2:
        return
    msgInfo, packDataDict = reqInfo
    OnMirrorBattleInit(msgInfo, packDataDict, curPlayer)
    return

def OnMirrorBattleInit(msgInfo, packDataDict, curPlayer=None):
    ''' ¾µÏñÕ½¶·³õʼ»¯ 
    @param msgInfo: OnRequestCreateMirrorBattle ·¢ËÍGameServerµÄÐÅÏ¢
    @param packDataDict: ·µ»ØÐèÒªµÄÍæ¼Ò´ò°üÊý¾Ý {playerID:packData, ...}
    @param curPlayer: Èç¹ûÊÇÍæ¼Ò·¢ÆðµÄÔò²»Îª¿Õ
    '''
    
    requestID = msgInfo["requestID"]
    playerID = msgInfo.get("playerID", 0)
    msgData = msgInfo["msgData"]
    
    mapID = msgData.get("mapID", 0)
    funcLineID = msgData.get("funcLineID", 0)
    factionPlayerList = msgData.get("factionPlayerList", [])
    isSysbg = msgData.get("isSysbg", 0) # ϵͳºǫ́ս¶·
    
    battleID = 0
    if isSysbg:
        sysBattleIDStart = 1000000000 # ϵͳ³¡´ÓÊ®ÒÚ¿ªÊ¼
        for num in range(sysBattleIDStart, sysBattleIDStart + 1000):
            if num not in PyGameData.g_mirrorBattleDict:
                battleID = num
                break
    elif playerID:
        battleID = playerID
        
    battle = AddMirrorBattle(battleID, mapID, funcLineID, requestID, isSysbg, playerID)
    if not battle:
        GameWorld.ErrLog("¾µÏñÕ½³¡IDÒÑ´æÔÚ! battleID=%s,msgInfo=%s" % (battleID, msgInfo), requestID)
        return
    battle.isChangeMap = msgInfo.get("isChangeMap", 0)
    GameWorld.DebugLog("¾µÏñÕ½¶·³õʼ»¯: msgData=%s,packIDList=%s" % (msgData, packDataDict.keys()), battleID)
    
    factionPosList = OnGetMirrorBattlePos(mapID, funcLineID, isSysbg, curPlayer)
    if not factionPosList:
        return
    for faction, batPlayerIDList in enumerate(factionPlayerList, 1):
        posInfo = factionPosList[faction - 1]
        factionPosX, factionPosY = posInfo
        for index, batPlayerID in enumerate(batPlayerIDList):
            posX, posY = factionPosX, factionPosY + index * 5
            if curPlayer and batPlayerID == playerID and faction == 1 and not isSysbg:
                battle.AddBattlePlayer(curPlayer, faction, posX, posY)
                continue
            
            packData = packDataDict.get(batPlayerID)
            if not packData:
                GameWorld.ErrLog("³õʼ»¯¾µÏñÕ½¶·Ê±Ã»ÓÐÍæ¼Ò¾µÏñÊý¾Ý! batPlayerID=%s" % batPlayerID, playerID)
                continue
            
            CreateMirrorPlayer(battleID, batPlayerID, packData, posX, posY, faction, curPlayer)
            
    tick = GameWorld.GetGameWorld().GetTick()
    battle.ChangeBattleState(ChConfig.Def_MirrorBatState_Prepare, tick)
    
    if not isSysbg:
        return
    
    # ϵͳ³¡Ä¬ÈÏÖ±½Ó¿ªÊ¼¡¢¿ìËÙÕ½¶·½áÊø
    OnMirrorBattleStart(battleID)
    DoMirrorBattleQuick(battleID)
    ClearMirrorBattleByID(battleID)
    return

def OnGetMirrorBattlePos(mapID, lineID, isSysbg=False, curPlayer=None):
    if isSysbg:
        if curPlayer:
            posX, posY = curPlayer.GetPosX(), curPlayer.GetPosY()
        else:
            gameMap = GameWorld.GetMap()
            posX, posY = gameMap.GetRebornMapX(), gameMap.GetRebornMapY() # ϵͳս¶·Ä¬ÈÏÈ¡µ±Ç°µØͼµÄ¸´»îµã£¬ÐèÒªÓÅ»¯
        if not GameWorld.GetMap().CanMove(posX, posY):
            GameWorld.ErrLog("¾µÏñÕ½¶·´´½¨×ø±êÒì³£! posX=%s, posY=%s" % (posX, posY))
            return
        factionPosList = [[posX, posY], [posX, posY]]
    else:
        factionPosDict = IpyGameDataPY.GetFuncEvalCfg("MirrorAttack", 4, {})
        factionPosList = factionPosDict.get(mapID, [[10, 7], [40,37]])
    return factionPosList

def OnMirrorBattleStart(battleID):
    ## ¾µÏñÕ½¶·¿ªÊ¼
    battle = GetMirrorBattleByID(battleID)
    if not battle:
        return
    if battle.batState >= ChConfig.Def_MirrorBatState_Fight:
        return
    tick = GameWorld.GetGameWorld().GetTick()
    battle.ChangeBattleState(ChConfig.Def_MirrorBatState_Fight, tick)
    return

def ProcessPlayerMirrorAI(curPlayer, tick):
    ## ¾µÏñÕ½¶·AI
    battle = GetMirrorBattle(curPlayer)
    if not battle:
        return
    
    playerID = curPlayer.GetPlayerID()
    realPlayerID = curPlayer.GetRealPlayerID()
    if realPlayerID:
        # ÓõÚÒ»¸ö¶ÔÊÖ¾µÏñÍæ¼ÒÀ´¶¨Ê±ÅжÏÕ½¶·½×¶Î£¬ÒòΪÍæ¼Ò×ÔÉí¿ÉÄÜ»áµôÏߣ¬ËùÒÔ²»ÓÃ×Ô¼º£¬¶øÓþµÏñÍæ¼Ò
        if realPlayerID == battle.GetTagPlayerID():
            if battle.stateTick and battle.CaclStateTick(tick) <= 0:
                if battle.batState == ChConfig.Def_MirrorBatState_Prepare:
                    OnMirrorBattleStart(battle.battleID)
                elif battle.batState == ChConfig.Def_MirrorBatState_Fight:
                    OnMirrorAttackOver(battle.battleID)
                elif battle.batState == ChConfig.Def_MirrorBatState_Over:
                    ClearMirrorBattleByID(battle.battleID)
    else:
        # ³£¹æÕ½¶·Ï£¬ÕæʵÍæ¼Ò²»´¦Àí£¬ÓÉÍæ¼Ò×ÔÐпØÖÆ
        if not battle.isQuick:
            return
        
    if battle.batState != ChConfig.Def_MirrorBatState_Fight:
        #GameWorld.DebugLog("¾µÏñÍæ¼Ò½ö×ÔÓÉÕ½¶·×´Ì¬ÏÂÐèÒª´¦Àí! battleID=%s,batState=%s" % (battle.battleID, battle.batState), playerID)
        return
    
    if GameObj.GetHP(curPlayer) <= 0:
        #GameWorld.DebugLog("¾µÏñÍæ¼ÒÒѱ»»÷ɱ", playerID)
        return
    
    # ¹¥»÷¼ä¸ô
    if tick - curPlayer.GetPlayerAttackTick() < curPlayer.GetAtkInterval():
        #GameWorld.DebugLog("¹¥»÷¼ä¸ô: %s < %s" % (tick - curPlayer.GetPlayerAttackTick(), curPlayer.GetAtkInterval()), playerID)
        return
    
    PyGameData.g_singleAtkRecordList = []
    autoUseSkillList = battle.GetPlayerAutoUseSkillList(curPlayer)
    #GameWorld.DebugLog("¾µÏñAI¹¥»÷: autoUseSkillList=%s" % (autoUseSkillList), playerID)
    
    if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse:
        PlayerHorse.PlayerRideHorseDown(curPlayer)
        
    isOK = False
    actionObj = PlayerState.__GetCanAttack_ObjDetel(curPlayer, tick)
    if actionObj:
        isOK = PlayerAttack(curPlayer, actionObj, tick, autoUseSkillList, battle.isQuick)
        
    if not isOK:
        curFaction = curPlayer.GetFaction()
        playerMgr = GameWorld.GetMapCopyPlayerManager()
        for batPlayerID, faction in battle.playerFactionDict.items():
            if faction == curFaction:
                continue
            if actionObj and actionObj.GetID() == batPlayerID:
                continue
            tagObj = playerMgr.FindPlayerByID(batPlayerID)
            isOK = PlayerAttack(curPlayer, tagObj, tick, autoUseSkillList, battle.isQuick)
            if isOK:
                break
            
    PyGameData.g_singleAtkRecordList = None
    if isOK:
        # ÿ´Î´¦Àí½öÖ´ÐÐÒ»´Î³É¹¦ÐÐΪ
        return
    
    return

def PlayerAttack(curPlayer, tagObj, tick, autoUseSkillList, isQuick=False):
    ## Íæ¼Ò¹¥»÷£¬ ²Î¿¼¼¼ÄÜʹÓà #def UseSkillEx(index, clientData, tick):
    if not tagObj or GameObj.GetHP(tagObj) <= 0:
        return
    playerID = curPlayer.GetPlayerID()
    posX, posY = curPlayer.GetPosX(), curPlayer.GetPosY()
    tagObjType, tagObjID = tagObj.GetGameObjType(), tagObj.GetID()
    tagPosX, tagPosY = tagObj.GetPosX(), tagObj.GetPosY()
    curPlayer.SetActionObj(tagObj)
    
    curPlayer.ClearUseSkillRec()
    curPlayer.SetAttackTargetPos(posX, posY)
    curPlayer.SetUseSkillPosX(tagPosX)
    curPlayer.SetUseSkillPosY(tagPosY)
    curPlayer.SetUseSkillTagType(tagObjType)
    curPlayer.SetUseSkillTagID(tagObjID)
    
    needMoveto = False # ÓпÉÊͷŵļ¼ÄÜÓÅÏÈÊͷż¼ÄÜ£¬Ã»ÓеĻ°ÔÙÒƶ¯
    useSkillResult = False
    skillMgr = curPlayer.GetSkillManager()
    for skillTypeID in autoUseSkillList:
        curSkill = skillMgr.FindSkillBySkillTypeID(skillTypeID)
        if not curSkill:
            continue
        skillID = curSkill.GetSkillID()
        
        #CheckSkillCondition
        #±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
        if SkillCommon.isPassiveSkill(curSkill):
            continue
        #»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
        if SkillCommon.RefreshSkillRemainTime(curSkill, tick) != 0:
            continue
        
        if not AttackCommon.CheckPlayerAttackDist(curPlayer, tagObj, curSkill, True):
            needMoveto = True
            continue
        
        curPlayer.SetUseSkill(curSkill.GetSkillData())
        useSkillData = curPlayer.GetUseSkill()
        if not PlayerState.__DoClientUseSkillEx(curPlayer, useSkillData, tick):
            #GameWorld.DebugLog("        ¼¼Äܹ¥»÷ʧ°Ü: playerID=%s,tagID=%s,skillID=%s" % (playerID, tagObjID, skillID))
            continue
        useSkillResult = True
        #GameWorld.DebugLog("        ¼¼Äܹ¥»÷³É¹¦: playerID=%s,tagID=%s,skillID=%s" % (playerID, tagObjID, skillID))
        
        if useSkillData and useSkillData.GetSkillID() != ChConfig.Def_SkillID_Somersault:
            # ¸úËæÍæ¼ÒͬƵÂʹ¥»÷
            PetControl.PetFight(curPlayer, tick)
            PlayerState.SummonFollowAtk(curPlayer, tick)
        break
    
    curPlayer.ClearUseSkillRec()
    
    if useSkillResult:
        curPlayer.SetAttackTick(tick)
    else:
        if needMoveto:
            MoveToObj(curPlayer, tagObj, tick, isQuick)
            return
        
    curPlayer.SetDict(Mirror_StartMoveTick, 0)
    return useSkillResult

def MoveToObj(curPlayer, tagObj, tick, isQuick=False):
    #²»¿ÉÒƶ¯ÐÐΪ״̬, ·þÎñ¶ËÏÞÖÆ
    if not OperControlManager.IsObjCanDoAction(curPlayer,
                                               ChConfig.Def_Obj_ActState_ServerAct,
                                               IPY_GameWorld.oalMove):
        return
    
    curPosX, curPosY = curPlayer.GetPosX(), curPlayer.GetPosY()
    destX = tagObj.GetPosX()
    destY = tagObj.GetPosY()
    # ËõСÁ½¸ñ×ÓÓÃÓÚÇ°·½Ò»Ð¡Æ¬ÇøÓò
    resultPos = GameMap.GetEmptyPlaceInArea(destX, destY, 1)
    moveDestX = resultPos.GetPosX()
    moveDestY = resultPos.GetPosY()
    
    if isQuick:
        curPlayer.ChangePos(moveDestX, moveDestY)
        #GameWorld.DebugLog("---Ö±½ÓÉèÖÃ×ø±ê: %s,%s to %s,%s, %s,%s" % (curPosX, curPosY, moveDestX, moveDestY, curPlayer.GetPosX(), curPlayer.GetPosY()), curPlayer.GetID())
        return
    
    startMoveTick = curPlayer.GetDictByKey(Mirror_StartMoveTick)
    if not startMoveTick:
        curPlayer.SetDict(Mirror_StartMoveTick, tick)
        #GameWorld.DebugLog("---ÉèÖÿªÊ¼Òƶ¯: %s,%s to %s,%s, tick=%s" % (curPosX, curPosY, moveDestX, moveDestY, tick), curPlayer.GetID())
        return
    
    speed = curPlayer.GetSpeed()
    if not speed:
        return
    
    interval = tick - startMoveTick
    moveDist = interval / float(speed)
    #GameWorld.DebugLog("---¼ÆËãλÒÆ: moveDist=%s,speed=%s,interval=%s(%s-%s)" % (moveDist, speed, interval, tick, startMoveTick), curPlayer.GetID())
    if moveDist <= 0:
        return
    
    m_DestPosX, m_DestPosY = moveDestX, moveDestY
    m_StartPosX, m_StartPosY = curPosX, curPosY
    m_DestDist = GameWorld.GetDistEx(m_StartPosX, m_StartPosY, m_DestPosX, m_DestPosY, False)
    updPosX = int(math.ceil(moveDist * (m_DestPosX - m_StartPosX) / m_DestDist + m_StartPosX))
    updPosY = int(math.ceil(moveDist * (m_DestPosY - m_StartPosY) / m_DestDist + m_StartPosY))
    
    cDist = GameWorld.GetDistEx(curPosX, curPosY, updPosX, updPosY, False)
    if cDist <= 1:
        #GameWorld.DebugLog("--------------------Ôݲ»Òƶ¯: cDist=%s,updPos(%s,%s),curPos(%s,%s),m_DestPos(%s,%s),m_DestDist=%s" 
        #                   % (cDist, updPosX, updPosY, curPosX, curPosY, moveDestX, moveDestY, m_DestDist), curPlayer.GetID())
        return
    #GameWorld.DebugLog("--------------------¸üÐÂ×ø±ê: cDist=%s,updPos(%s,%s),curPos(%s,%s),m_DestPos(%s,%s),m_DestDist=%s" 
    #                   % (cDist, updPosX, updPosY, curPosX, curPosY, moveDestX, moveDestY, m_DestDist), curPlayer.GetID())
    curPlayer.ChangePos(updPosX, updPosY)
    curPlayer.SetDict(Mirror_StartMoveTick, tick)
    
    sendPack = ChNetSendPack.tagObjMove()
    sendPack.Clear()
    sendPack.ObjID = curPlayer.GetID()
    sendPack.ObjType = curPlayer.GetGameObjType()
    sendPack.MoveType = IPY_GameWorld.mtNormal
    sendPack.DestPosX = updPosX
    sendPack.DestPosY = updPosY
    sendPack.Speed = speed
    sendPack.StartPosX = curPosX
    sendPack.StartPosY = curPosY
    curPlayer.NotifyAll(sendPack.GetBuffer(), sendPack.GetLength())
    return

def DoMirrorBattleQuick(battleID, isLogout=False, isClick=False):
    ## Ö´ÐпìËÙÕ½¶·
    battle = GetMirrorBattleByID(battleID)
    if not battle:
        return
    if battle.batState != ChConfig.Def_MirrorBatState_Fight:
        return
    if battle.isQuick:
        #²»Öظ´´¥·¢´¦Àí
        return
    mapID = battle.mapID
    if not battle.isSysbg:
        if isClick:
            quickLimitMapIDList = IpyGameDataPY.GetFuncEvalCfg("MirrorAttack", 2)
            if mapID in quickLimitMapIDList:
                GameWorld.DebugLog("Õ½¶·Öв»ÔÊÐíµã»÷¿ìËÙÕ½¶·! mapID=%s" % mapID, battle.playerID)
                return
    tick = GameWorld.GetGameWorld().GetTick()
    battle.isQuick = True
    battle.isLogout = isLogout
    battle.CaclStateTick(tick)
    
    playerMgr = GameWorld.GetMapCopyPlayerManager()
    perLoopTick = 100 # ÿ´ÎÑ­»·ÊÓΪÒѹýºÁÃë
    maxLoopCount = battle.stateTickRemain / perLoopTick # Ñ­»·´ÎÊýÉÏÏÞ
    GameWorld.DebugLog("------------------------ ¾µÏñPK¿ìËÙ½áËã ------------------------", battleID)
    GameWorld.DebugLog("¾µÏñPK¿ìËÙ½áËã: isLogout=%s,maxLoopCount=%s,tick=%s,stateTickRemain=%s" 
                       % (isLogout, maxLoopCount, tick, battle.stateTickRemain), battleID)
    
    # ÆÁ±Î·¢°ü
    for batPlayerID in battle.realIDDict.keys():
        curPlayer = playerMgr.FindPlayerByID(batPlayerID)
        if not curPlayer:
            continue
        curPlayer.SetForbiddenSyncClientState(True)
        
    for loopCount in range(maxLoopCount):
        if battle.batState != ChConfig.Def_MirrorBatState_Fight:
            # ¿ÉÄÜ»¹Ã»Ñ­»·Íê±Ï¾Í½áÊøÁË
            break
        tick += perLoopTick # ÐÞ¸Äÿ´ÎÑ­»·µÄtick
        #GameWorld.DebugLog("    loopCount=%s,tick=%s,stateTickRemain=%s" % (loopCount, tick, battle.stateTickRemain), battleID)
        for batPlayerID in battle.playerFactionDict.keys():
            if batPlayerID in battle.deadPlayerIDList:
                continue
            curPlayer = playerMgr.FindPlayerByID(batPlayerID)
            if not curPlayer or GameObj.GetHP(curPlayer) <= 0:
                continue
            # ˢж¨Ê±´¦ÀíµÄbuffЧ¹û
            SkillShell.ProcessPersistBuff(curPlayer, tick)
            
            #Ë¢ÐÂÍæ¼ÒBuffʱ³¤
            reFlashBuff = PlayerState.ProcessRefreshBuffState(curPlayer, tick)
            
            attrBuffResult, actBuffResult = PlayerState.ProcessRefreshActionBuffState(curPlayer, tick)
            playerControl = PlayerControl.PlayerControl(curPlayer)
            if actBuffResult:
                playerControl.RefreshPlayerActionState()
                
            #´Ë´¦²ÅÊÇÕæÕýµÄË¢ÐÂÈËÎïÊôÐÔÖµ£¬ÐèË¢ÊôÐÔÂß¼­Ó¦ÔÚ´ËÐÐÇ°µ÷ÓÃ
            if not playerControl.RefreshPlayerAttrStateEx():
                if reFlashBuff or attrBuffResult:
                    playerControl.RefreshPlayerAttrByBuff()
                # ֻˢBUFFÇé¿ö
                playerControl.RefreshPlayerAttrByBuffEx() 
                
            ProcessPlayerMirrorAI(curPlayer, tick)
            
    # ûÓлñʤ·½
    if not battle.winFaction:
        GameWorld.DebugLog("ûÓл÷°Ü¶Ô·½ÕóÓª!", battleID)
        OnMirrorAttackOver(battleID)
    return True

def OnPlayerDead(curPlayer):
    battleID = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_MirrorBattleID)
    if not battleID:
        return
    battle = GetMirrorBattleByID(battleID)
    if not battle:
        return
    playerID = curPlayer.GetPlayerID()
    curFaction = curPlayer.GetFaction()
    if playerID not in battle.deadPlayerIDList:
        battle.deadPlayerIDList.append(playerID)
    GameWorld.DebugLog("¾µÏñÕ½¶·Õ½³¡Íæ¼Ò±»»÷ɱ! playerID=%s,curFaction=%s,deadPlayerIDList=%s" 
                       % (playerID, curFaction, battle.deadPlayerIDList), battleID)
    
    winFaction = 0
    for batPlayerID, faction in battle.playerFactionDict.items():
        if faction != curFaction:
            winFaction = faction
            continue
        if batPlayerID not in battle.deadPlayerIDList:
            #GameWorld.DebugLog("ÏàͬÕóÓª»¹ÓÐδ±»»÷ɱµÄÍæ¼Ò£¡")
            return
        
    # ͬÕóÓª¶¼±»»÷ɱÁË£¬½áËãʤ¸º
    battle.winFaction = winFaction
    GameWorld.DebugLog("ijһÕóÓªÒѱ»»÷°Ü! winFaction=%s" % winFaction, battleID)
    OnMirrorAttackOver(battleID)
    return

def OnMirrorAttackOver(battleID):
    battle = GetMirrorBattleByID(battleID)
    if not battle:
        return
    if battle.batState >= ChConfig.Def_MirrorBatState_Over:
        # ÒѾ­½áËã¹ý
        return
    tick = GameWorld.GetGameWorld().GetTick()
    if not battle.stateTickRemain:
        battle.CaclStateTick(tick)
    # Ôݶ¨Ã»»÷ɱËãÊ䣬·¢Æð·½Îª1
    if not battle.winFaction:
        battle.winFaction = 2
    battle.isWin = 1 if battle.winFaction == 1 else 0
    mapID = battle.mapID
    funcLineID = battle.funcLineID
    winFaction = battle.winFaction
    isQuick = battle.isQuick
    isLogout = battle.isLogout
    GameWorld.DebugLog("¾µÏñÕ½¶·½áÊø: mapID=%s,funcLineID=%s,winFaction=%s,isWin=%s,isQuick=%s,isLogout=%s" 
                       % (mapID, funcLineID, winFaction, battle.isWin, isQuick, isLogout), battleID)
    
    playerMgr = GameWorld.GetMapCopyPlayerManager()
    
    #¿ìËÙÕ½¶·½áÊøµÄ¶îÍâ´¦Àí
    if isQuick:
        for playerID in battle.realIDDict.keys():
            curPlayer = playerMgr.FindPlayerByID(playerID)
            if not curPlayer:
                continue
            curPlayer.SetForbiddenSyncClientState(False)
            
        for playerID in battle.playerFactionDict.keys():
            curPlayer = playerMgr.FindPlayerByID(playerID)
            if not curPlayer:
                continue
            # ÖØÐÂ֪ͨ×îÖÕѪÁ¿¼°×´Ì¬
            GameObj.SetHP(curPlayer, GameObj.GetHP(curPlayer))
            if playerID in battle.deadPlayerIDList:
                curPlayer.SetDead(curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerID),
                                  curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerType))
                
    #ͳ¼ÆÃ÷ϸ
    for playerID, faction in battle.playerFactionDict.items():
        player = playerMgr.FindPlayerByID(playerID)
        if not player:
            continue
        player.StopMove()
        realPlayerID = player.GetRealPlayerID()
        hp = GameObj.GetHP(player)
        hpMax = GameObj.GetMaxHP(player)
        fightPower = PlayerControl.GetFightPower(player)
        
        GameWorld.DebugLog("Ê£ÓàѪÁ¿: %s/%s, »¤¶Ü:%s/%s,playerID=%s,realPlayerID=%s,faction=%s,fightPower=%s" 
                           % (hp, hpMax, PlayerControl.GetProDef(player), PlayerControl.GetMaxProDef(player), playerID, realPlayerID, faction, fightPower), battleID)
        if faction == 1:
            battle.curHP += hp
            battle.curHPMax += hpMax
        else:
            battle.tagHP += hp
            battle.tagHPMax += hpMax
            
    FBLogic.OnMirrorBattleOver(battleID, mapID)
    
    # ¸Ä±ä״̬Ðè·ÅÔÚ×îºó
    battle.ChangeBattleState(ChConfig.Def_MirrorBatState_Over, tick)
    return

def DoPlayerLeaveFB(curPlayer, tick):
    ##Íæ¼ÒÖ÷¶¯À뿪¸±±¾
    if curPlayer.GetRealPlayerID():
        return
    battle = GetMirrorBattle(curPlayer)
    if not battle:
        return
    GameWorld.DebugLog("Íæ¼ÒÖ÷¶¯Í˳ö¾µÏñÕ½¶·Ç¿ÖÆ¿ìËÙ½áËãÕ½¶·!", curPlayer.GetPlayerID())
    DoQuickOverByExit(curPlayer)
    return

def DoExitFB(curPlayer, tick):
    ##Íæ¼ÒÍ˳ö¸±±¾
    if curPlayer.GetRealPlayerID():
        return
    battle = GetMirrorBattle(curPlayer)
    if not battle:
        return
    # Í˳öʱ»¹ÓÐÕ½³¡Êý¾ÝÒ»°ãÊǵôÏߵģ¬ÒòΪÖ÷¶¯Í˳öĬÈÏÇ¿ÖƽáËã
    mapID = battle.mapID
    logoutQuickLimitMapIDList = IpyGameDataPY.GetFuncEvalCfg("MirrorAttack", 3)
    if mapID in logoutQuickLimitMapIDList:
        GameWorld.DebugLog("µôÏß²»ÔÊÐí¿ìËÙÕ½¶·! mapID=%s" % mapID, battle.playerID)
        return
    GameWorld.DebugLog("Íæ¼ÒµôÏßÍ˳ö¾µÏñÕ½¶·¿ìËÙ½áËãÕ½¶·!", curPlayer.GetPlayerID())
    DoQuickOverByExit(curPlayer)
    return

def DoQuickOverByExit(curPlayer):
    ## Ö´ÐÐÍ˳ö¿ìËÙ½áËã
    
    battle = GetMirrorBattle(curPlayer)
    if not battle:
        return
    
    battleID = battle.battleID
    if battle.batState < ChConfig.Def_MirrorBatState_Fight:
        OnMirrorBattleStart(battleID) # »¹Î´¿ªÊ¼ÔòÇ¿ÖÆ¿ªÊ¼
        
    # Èç¹û»¹ÔÚÕ½¶·ÖУ¬Ö±½Ó¿ìËÙÖ´ÐÐÕ½¶·½á¹û
    if battle.batState == ChConfig.Def_MirrorBatState_Fight:
        DoMirrorBattleQuick(battle.battleID, isLogout=True)
        
    ClearMirrorBattleByID(battleID)        
    return