#!/usr/bin/python
# -*- coding: GBK -*-
#
#
##@package AIPlayerRandomRun
# @todo: Ëæ»úÅÜAI
#
# @author:ifo
# @date 2010-01-01 15:30
# @version 1.1
#
# @change: "2012-08-30 16:30" whx Ð޸ĿçµØͼËæÅÜ
#
# ¼òҪ˵Ã÷Ëæ»úÅÜAI
# ÏêϸÃèÊö None

VER = "2012-08-30 16:30"

import base64
import time
import math
import random
import logging

from AI.AIBase import *
from ConfigurationReader import ConfigIniReader
from DataReader import *

from Protocol.PacketsSend import tagCPlayerMove
from Protocol.PacketsSend import tagCPlayerStopMove
from Protocol.PacketsSend import tagCChangeMap

#OBJ״̬
[PS_Null,
PS_Move,
PS_Event] = range(3)

#OBJÀàÐÍ
[
gotNone,
gotPlayer,
gotNPC,
gotItem] = range(4)
   

## Íæ¼ÒÒƶ¯Ïà¹ØÊý¾Ý 
#
# None  
class PlayerMoveInfo:
    
    ## ³õʼ»¯Êý¾Ý
    #  @param mapMove : Òƶ¯¶ÔÏó
    #  @return None
    #  @remarks
    def __init__(self,mapMove):
        self.__PlayerState = PS_Null
        self.__MoveTick = 0      #ÉÏÒ»´ÎÒƶ¯µÄʱ¼ä
        self.__StartPosX = 0
        self.__StartPosY = 0
        self.__Speed = 0
        self.__DestPosX = 0
        self.__DestPosY = 0
        self.__processTick = 0
        self.__MapMove = mapMove
    
    
    ## ÉèÖÃʱ¼ä
    #  @param None : None
    #  @return None
    #  @remarks
    def SetProcessTick(self,processTick):
        self.__processTick = processTick 
    
    
    ## »ñȡʱ¼ä
    #  @param None : None
    #  @return None
    #  @remarks
    def GetProcessTick(self):
        return self.__processTick
    
    
    ## »ñÈ¡Òƶ¯Ê±¼ä
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def GetMoveTick(self):
        return self.__MoveTick
    
    
    ## ÉèÖÃÒƶ¯Ê±¼ä
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def SetMoveTick(self, tick):
        self.__MoveTick = tick
    

    ## »ñÈ¡Ä¿±êλÖÃ
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def GetDestPosX(self):
        return self.__DestPosX
    
    ## ÉèÖÃÄ¿±êλÖÃ
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def SetDestPosX(self, value):
        self.__DestPosX = value
   
   
   ## »ñÈ¡Ä¿±êλÖÃ
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def GetDestPosY(self):
        return self.__DestPosY
    
    
    ## ÉèÖÃÄ¿±êλÖÃ
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def SetDestPosY(self, value):
        self.__DestPosY = value
    
    
    ## »ñÈ¡Òƶ¯ËÙ¶È
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def GetSpeed(self):
        return self.__Speed
    
    
    ## ÉèÖÃÒƶ¯ËÙ¶È
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def SetSpeed(self, value):
        self.__Speed = value
   
    
    ## »ñÈ¡Íæ¼Ò״̬
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick  
    def GetState(self):
        return self.__PlayerState
    
    
    ## ÉèÖÃÍæ¼Ò״̬
    #  @param None : None
    #  @return None
    #  @remarks#MoveTick
    def SetState(self, state):
        self.__PlayerState = state
    
    
    ## »ñÈ¡¿ªÊ¼Òƶ¯Î»ÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def GetStartPosY(self):
        return self.__StartPosY
    
    
    ## ÉèÖÿªÊ¼Òƶ¯Î»ÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def SetStartPosY(self, pos):
        self.__StartPosY = int(pos)
    
    
    ## »ñÈ¡¿ªÊ¼Òƶ¯Î»ÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def GetStartPosX(self):
        return self.__StartPosX
    
    
    ## ÉèÖÿªÊ¼Òƶ¯Î»ÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def SetStartPosX(self, pos):
        self.__StartPosX = int(pos)
      

## Òƶ¯ 
#
# None  
class MapMove:
    moveIsErrIdList = [] 
    
    ## ³õʼ»¯Êý¾Ý
    #  @param ai : AI¶ÔÏó
    #  @return None
    #  @remarks
    def __init__(self,ai):
        self.__WaitFlag = None
        self.__PlayerMoveFunc = None
        self.__PlayerDestMapID = 0
        self.__PlayerDestPosX = 0
        self.__PlayerDestPosY = 0
        self.__PlayerMoveMapList = []
        self.__PlayerMoveWayPoint = list()

        self.__AllTransportData = TransportDataReader.GetTransportData().GetAllTransportData()
        
        if self.__PlayerMoveFunc != None:
            self.__PlayerMoveFunc.close()
        self.__PlayerMoveFunc = self.PlayerMoveYield()
        self.__WaitFlag = self.__PlayerMoveFunc.next()
        
        self.__temWayList = []
        self.__temFindMap = {}
        self.__temAllResult = []
        
        self.__ai = ai
        
        
    ## »ØËÝ
    #  @param None : None
    #  @return None
    #  @remarks
    def __FindWayListTraceBack(self, srcMapID, destMapID):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        
        if srcMapID == destMapID:
            curWay = []
            for way in self.__temWayList:
                curWay.append(way)
            self.__temAllResult.append(curWay)
            return

        
        if self.__AllTransportData.has_key(srcMapID) == False:
            return
        
        if self.__temFindMap.has_key(srcMapID):
            #ÒѾ­×ß¹ýÏÂÒ»²½, ²»¼ÌÐø
            return
        
        #¼Ç¼ÏÂÕâÒ»²½
        self.__temFindMap[srcMapID] = True
        wayList = self.__AllTransportData[srcMapID]
        
        for way in wayList:
            self.__temWayList.append(way)
            self.__FindWayListTraceBack(way.TargetMapID, destMapID)
            self.__temWayList.pop()
        return

    
    ## #»ñµÃ·¾¶
    #  @param None : None
    #  @return None
    #  @remarks
    def GetWayList(self,srcMapID, destMapID):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return []
        
        self.__temWayList = []
        
        self.__temFindMap = {}
        
        self.__temAllResult = []
        
        self.__FindWayListTraceBack(srcMapID, destMapID)
        
        minList = []
        self.__temAllResult.sort()
        if len(self.__temAllResult) == 0:
            return minList
        return self.__temAllResult[0]
    
    
    ## #Òƶ¯¶ÓÁÐ
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerMoveYield(self):
        
        while 1:
            yield 'start_move'
            while 1:
                if self.__PlayerAtPos(self.__PlayerDestMapID, self.__PlayerDestPosX, self.__PlayerDestPosY) == True:
                    #logging.debug('MapPos is in: %d, %d, %d'%(self.__PlayerDestMapID, self.__PlayerDestPosX, self.__PlayerDestPosY))
                    break
                
                #logging.debug('MoveToMapPos: %d, %d, %d'%(self.__PlayerDestMapID, self.__PlayerDestPosX, self.__PlayerDestPosY))
                #¿çµØͼѰ·
                self.PlayerFindWay(self.__PlayerDestMapID, self.__PlayerDestPosX, self.__PlayerDestPosY)
            
            
                while 1:
                    if len(self.__PlayerMoveMapList) != 0:
                        destPosX = self.__PlayerMoveMapList[0].PosX
                        destPosY = self.__PlayerMoveMapList[0].PosY
                    else:
                        destPosX = self.__PlayerDestPosX
                        destPosY = self.__PlayerDestPosY
                        
                    #µ¥¸öµØͼµÄ×ß·´¦Àí
                    if self.__PlayerAtPos(self.__ai.robot.GetPlayerInfo().GetMapID(), destPosX, destPosY) == True:
                        #logging.debug('a Map is in: %d, %d'%(destPosX, destPosY))
                        self.PlayerStop(destPosX, destPosY)
                        self.__ai.StopMove()
                        break 
                        
                    while 1:
                        #µ¥¸öµØͼµÄ×ß·´¦Àí
                        if self.__PlayerAtPos(self.__ai.robot.GetPlayerInfo().GetMapID(), destPosX, destPosY) == True:
                            #logging.debug('DestPos is in: %d, %d'%(destPosX, destPosY))
                            self.PlayerStop(destPosX, destPosY)
                            self.__ai.StopMove()
                            break 
    
                        if destPosX == 0 or destPosY == 0:
                            raise  Exception("Dest Pos Error!")    
                                    
                        #logging.debug('MoveToPos: (%d, %d)->(%d, %d)'%(self.__ai.robot.GetPlayerInfo().GetPos()[0], self.__ai.robot.GetPlayerInfo().GetPos()[1], destPosX, destPosY))
                        self.PlayerFindWayInMap(destPosX, destPosY)
                        if len(self.__PlayerMoveWayPoint) == 0:
#                            logging.debug('NAME = %s'%(self.__ai.robot.GetPlayerInfo().GetPlayerName()))
                            logging.debug('PlayerMoveError: (%d, %d)'%(destPosX, destPosY))
                            self.PlayerMoveSuccess()
                            
                            playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
                            if playerId not in MapMove.moveIsErrIdList:
                                MapMove.moveIsErrIdList.append(playerId)
                                logging.debug('Ìí¼Ó11moveIsErrIdList=%s'%str(MapMove.moveIsErrIdList))
                            continue
                        
                        while len(self.__PlayerMoveWayPoint) != 0:
                            curPos = self.__PlayerMoveWayPoint.pop(0)
                            
#                            for i in range(len(self.__PlayerMoveWayPoint)):
#                                logging.debug('######index = %s,,__PlayerMoveWayPoint=(%s,%s)'%(i,self.__PlayerMoveWayPoint[i].X,self.__PlayerMoveWayPoint[i].Y))
                            
                            while 1:
                                #Òƶ¯µ½ÕâÀï
                                self.__ai.StartMove(curPos.X, curPos.Y)
                                #logging.debug('Move %d, %d -> %d, %d'%(self.__ai.robot.GetPlayerInfo().GetPos()[0], self.__ai.robot.GetPlayerInfo().GetPos()[1], curPos.X, curPos.Y))
                                self.PlayerMove(curPos.X, curPos.Y)

                                yield 'over'
                                
                                #ÓпÉÄܱ»·þÎñÆ÷ÖØÖÃ, ËùÒÔ±ØÐëÑéÖ¤Õâ¸ö
                                if self.__PlayerAtPos(self.__ai.robot.GetPlayerInfo().GetMapID(), curPos.X, curPos.Y) == False:
                                    continue
                                
                                #logging.debug('DestPos is in : %d, %d'%(curPos.X, curPos.Y))
                                break
                        
                #µ¥¸öµØͼÒѾ­µ½´ïÄ¿µÄµØ    
                if len(self.__PlayerMoveMapList) == 0:
                    #Ä¿±êÒÑ´ïµ½
                    continue
                
                #Çл»µØͼ
                self.__ai.StopMove()
                    
                
                if self.__PlayerMoveMapList[0].count==8:
                    #Çл»µØͼ
                    #logging.debug('changeMap : %d -> %d'%(self.__PlayerMoveMapList[0].MapID, self.__PlayerMoveMapList[0].TargetMapID))
                    self.PlayerChangeMap(self.__PlayerMoveMapList[0].RefreshID)
                    yield 'active'
                    
                    self.__ai.robot.GetPlayerInfo().GetMapID()
                    #logging.debug('changeMap Successful, curMapID: %d'%self.__ai.robot.GetPlayerInfo().GetMapID())
                    #×ßÏÂÒ»¸öµØͼ
                    self.__PlayerMoveMapList.pop(0)
                    continue
            continue
        return
    
    
    ## #Í£Ö¹·¢°ü
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerStop(self,stopPosX,stopPosY):
        pack = tagCPlayerStopMove()
        pack.PosX = stopPosX
        pack.PosY = stopPosY
        self.__ai.robot.Send(pack)
    
    
    ## #Òƶ¯·¢°ü
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerMove(self,destPosX, destPosY):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        
        pack = tagCPlayerMove()
        pack.StartX,pack.StartY = self.__ai.robot.GetPlayerInfo().GetPos()
        pack.DestX = destPosX
        pack.DestY = destPosY
        self.__ai.robot.Send(pack)  
          
    
    ## #ÇеØͼ·¢°ü
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerChangeMap(self, transPortID):
        pack = tagCChangeMap()
        pack.TransportID = transPortID
        self.__ai.robot.Send(pack) 
        
   
    ## #·¢ÃüÁî¶ÓÁÐ
    #  @param None : None
    #  @return None
    #  @remarks
    def SendPlayerMoveYield(self,ret):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        
        if self.__WaitFlag == ret:
            self.__WaitFlag = self.__PlayerMoveFunc.send(ret)
#        else:
#            logging.debug('SendPlayerMoveYield1 wait : %s != %s'%(self.__WaitFlag, ret))
#            logging.debug('NAME = %s'%(self.__ai.robot.GetPlayerInfo().GetPlayerName()))


    ## ÊÇ·ñÒѾ­µ½´ïÖ¸¶¨Î»ÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def __PlayerAtPos(self,mapID, destX, destY):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return True
        
        if self.__ai.robot.GetPlayerInfo().GetMapID() != mapID:
            return False

        curPosX,curPosY = self.__ai.robot.GetPlayerInfo().GetPos()

        if int(abs(curPosX - destX)) > 0:
            return False
        
        if int(abs(curPosY - destY)) > 0:
            return False
        
        return  True

    
    ## »ñµÃ·µã
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerFindWay(self,mapID, destPosX, destPosY):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        
        self.__PlayerMoveMapList = self.GetWayList(self.__ai.robot.GetPlayerInfo().GetMapID(), mapID)
        
#        logging.debug('%s->%s:%s'%(self.__ai.robot.GetPlayerInfo().GetMapID(), mapID, self.__PlayerMoveMapList))
        self.__PlayerDestMapID = mapID
        self.__PlayerDestPosX = int(destPosX)
        self.__PlayerDestPosY = int(destPosY)
        
        return
    

    ## ±¾µØͼÄÚѰ·¾¶
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerFindWayInMap(self,destPosX, destPosY):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        self.__PlayerMoveWayPoint = list()
        curPosX,curPosY = self.__ai.robot.GetPlayerInfo().GetPos()
        startPosX = int(curPosX)
        startPosY = int(curPosY)
        destPosX = int(destPosX)
        destPosY = int(destPosY)
        self.__AStartPath = MapDataReader.GetMapData().GetMapDataByID(self.__ai.robot.GetPlayerInfo().GetMapID()).GetAStarPath()
        self.__AStartPath.Find(startPosX, startPosY, destPosX, destPosY)
        
        for i in range(self.__AStartPath.GetWayPointCount()):
            curPos = self.__AStartPath.AtWayPoint(i)
            
            if i == 0 and curPos.X == startPosX and curPos.Y == startPosY:
                continue
            self.__PlayerMoveWayPoint.append(curPos)
        
        
    ## Òƶ¯³É¹¦
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerMoveSuccess(self):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        self.__PlayerMoveMapList = list()
        self.__ai.StopMove()
        return



    ## ¿ªÊ¼Òƶ¯
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerMapMove(self, mapID, destPosX, destPosY):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        self.__PlayerDestMapID = mapID
        self.__PlayerDestPosX = destPosX
        self.__PlayerDestPosY = destPosY
        self.SendPlayerMoveYield('start_move')
        

    ## ½áÊøÒƶ¯
    #  @param None : None
    #  @return None
    #  @remarks
    def PlayerForceStopMove(self):
        playerId = self.__ai.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return
        self.SendPlayerMoveYield('over')
        return


## ×Ô¶¯ÅÜ
#
# ¼Ì³ÐAIBase 
class AIPlayerRandomRun(AIBase):
    
    ## ËùÓÐAI±ØÐë²ÉÓÃÕâÖй̶¨µÄ³õʼ»¯Ô­ÐÍ£¬ÒÔ±ãAIMgr×Ô¶¯¼ÓÔØ
    #  @param isAutoRunRound : ³õʼ»¯ÊÇ·ñ×Ô¶¯À´»ØÅÜ
    #  @return None
    #  @remarks
    def __init__(self, robot, isAutoRunRound=True):
        logging.debug("###´´½¨AIPlayerRandomRunʵÀý####type ")
        #´ËAIÐèÒªÖÜÆÚÐÔ±»µ÷Óã¬ËùÒÔÉèÖÃΪÆôÓÃTimer
        AIBase.__init__(self, robot, 0.01, True, True )
        
        self.robot = robot
        self.isAutoRunRound = False#isAutoRunRound
        self.mapMove = MapMove(self)
        self.playerMoveInfo = PlayerMoveInfo(self.mapMove)
#        self.curMapId = self.robot.GetPlayerInfo().GetMapID()
        
        if self.isAutoRunRound:
            try:
                self.runRange = [(103,53,111),(116,71,45),(108,53,237)]
            except:
                self.runRange = [(103,53,111),(116,71,45),(108,53,237)]
            
            self.maxIndex = len(self.runRange) - 1
            
            self.curRandPos = self.runRange[random.randint(0, self.maxIndex)]
    
        
    ## Òƶ¯µ½Ä³¸öλÖÃ
    #  @param posX:¹¥»÷¶ÔÏóÀàÐÍ
    #  @param posY:¹¥»÷¶ÔÏóID
    #  @return Boolean
    #  @remarks ÊÇ·ñÒƶ¯µ½¸ÃλÖÃ
    def MoveToPos(self, mapId, posX, posY):
        tick = time.clock()
        tick = tick * 1000      #¸ÄΪºÁÃëÖÆ
        
        self.playerMoveInfo.SetProcessTick(tick)
        
        self.ProcessMove(tick)
        
        self.mapMove.PlayerMapMove(mapId, posX, posY)

        curPosX,curPosY = self.robot.GetPlayerInfo().GetPos()
        curMapId = self.robot.GetPlayerInfo().GetMapID()
        
        if (curMapId, curPosX,curPosY) == (mapId, posX, posY):
            return True
        
        return False
    
        
    ## ÏòAIMgr×¢²áÏûÏ¢»Øµ÷º¯Êý
    #  @param None : None
    #  @return None
    #  @remarks
    def _RegisterPacket(self, aiMgr ):
        aiMgr.RegNetMsg(0x0505, self.OnRoleMoveFail, True)
        aiMgr.RegNetMsg(0x0402, self.OnPlayerResetPos, True)
        aiMgr.RegNetMsg(0x0418, self.OnObjInfoRefresh, True)
        aiMgr.RegNetMsg(0x0403, self.OnPlayerLoginLoadOK, False)
    
    ## Ñ­»·µ÷ÓÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def _Process(self):
        if self.robot.GetIsLoginOK() == False:
            return
        
        if self.playerMoveInfo.GetState() != PS_Move:
            return
        
        playerId = self.robot.GetPlayerInfo().GetPlayerID()
        if playerId in MapMove.moveIsErrIdList:
            return

        if self.isAutoRunRound:
            moveMapId, movePosX, movePosY = self.curRandPos
            
            if self.MoveToPos(moveMapId, movePosX, movePosY):
                self.curRandPos = self.runRange[random.randint(0, self.maxIndex)]
            
            return
        
        
    ## »ñµÃÁ½µã¾àÀë
    #  @param None : None
    #  @return None
    #  @remarks
    def GetDistance(self,srcX, srcY, destX, destY):
        return math.sqrt(pow(srcX - destX, 2) + pow(srcY - destY, 2))
    
    
    ## Òƶ¯ÖеÄλÖÃ
    #  @param None : None
    #  @return None
    #  @remarks
    def MovePos(self,srcX, srcY, destX, destY, curMoveDist):
        if curMoveDist == 0:
            return  srcX, srcY
    
        totalDist = self.GetDistance(srcX, srcY, destX, destY)
        if totalDist == 0:
            return  srcX, srcY
       
        resultX = curMoveDist * (destX - srcX)/ float(totalDist) + srcX
        resultY = curMoveDist * (destY - srcY)/ float(totalDist) + srcY
        return resultX, resultY 


    ## ͨÓÃÒƶ¯
    #  @param None : None
    #  @return None
    #  @remarks
    def ProcessMove(self, tick):
        if self.playerMoveInfo.GetState() != PS_Move:
            #µ±Ç°×´Ì¬²»ÎªÒƶ¯
            return
        
        curPosX,curPosY = self.robot.GetPlayerInfo().GetPos()

        if abs(curPosX - self.playerMoveInfo.GetDestPosX()) <= 1 and abs(curPosY - self.playerMoveInfo.GetDestPosY()) <= 1:
            #ÒѾ­µ½´ïÄ¿µÄµØ
            self.robot.GetPlayerInfo().SetPosX(self.playerMoveInfo.GetDestPosX())
            self.robot.GetPlayerInfo().SetPosY(self.playerMoveInfo.GetDestPosY())
            self.StopMove()
            self.mapMove.SendPlayerMoveYield('over')
            return
        
        speed = self.playerMoveInfo.GetSpeed()
        
        if speed == 0:
#            logging.debug('speed = 0, error!')
            self.playerMoveInfo.SetSpeed(284)
            speed = self.playerMoveInfo.GetSpeed()
        
        if tick - self.playerMoveInfo.GetMoveTick() < self.playerMoveInfo.GetSpeed():
            return
        
        diffTime = tick - self.playerMoveInfo.GetMoveTick()
        dist = diffTime / float(speed)
        
        x, y = self.MovePos(self.playerMoveInfo.GetStartPosX(), self.playerMoveInfo.GetStartPosY(), self.playerMoveInfo.GetDestPosX(), self.playerMoveInfo.GetDestPosY(), dist)

        self.robot.GetPlayerInfo().SetPosX(x)
        self.robot.GetPlayerInfo().SetPosY(y)


    ## ÈËÎ￪ʼÒƶ¯
    #  @param None : None
    #  @return None
    #  @remarks
    def StartMove(self, destX, destY):
        self.playerMoveInfo.SetState(PS_Move)
        self.playerMoveInfo.SetStartPosX(self.robot.GetPlayerInfo().GetPos()[0])
        self.playerMoveInfo.SetStartPosY(self.robot.GetPlayerInfo().GetPos()[1])
        self.playerMoveInfo.SetDestPosX(destX)
        self.playerMoveInfo.SetDestPosY(destY)
        self.playerMoveInfo.SetMoveTick(self.playerMoveInfo.GetProcessTick())
    
    
    ## ÈËÎïÍ£Ö¹Òƶ¯
    #  @param None : None
    #  @return None
    #  @remarks
    def StopMove(self):
        self.playerMoveInfo.SetState(PS_Null)
        self.playerMoveInfo.SetDestPosX(0)
        self.playerMoveInfo.SetDestPosY(0)


    ## ÈËÎïÊôÐÔË¢ÐÂ
    #  @param None : None
    #  @return None
    #  @remarks
    def OnObjInfoRefresh(self,packOnObjInfoRefresh):
#        logging.debug("#########Role Speed#########type = %s"%packOnObjInfoRefresh.ObjType)
        if packOnObjInfoRefresh.ObjType == gotPlayer:
            #ÕÒµ½Íæ¼Ò
            if packOnObjInfoRefresh.ObjID == self.robot.GetPlayerInfo().GetPlayerID():
                #PosX
                if packOnObjInfoRefresh.RefreshType == 25:
                    self.robot.GetPlayerInfo().SetPosX(packOnObjInfoRefresh.Value)
                #PosY
                elif packOnObjInfoRefresh.RefreshType == 26:
                    self.robot.GetPlayerInfo().SetPosY(packOnObjInfoRefresh.Value)
                #Speed
                elif packOnObjInfoRefresh.RefreshType == 71:
                    self.playerMoveInfo.SetSpeed(284)
#                    self.playerMoveInfo.SetSpeed(packOnObjInfoRefresh.Value)
#                    logging.debug("Role Speed: %d"%self.playerMoveInfo.GetSpeed())
    
    
    ## #05 05 Ö÷½ÇÒƶ¯Ê§°Ü#tagRoleMoveFail
    #  @param None : None
    #  @return None
    #  @remarks
    def OnRoleMoveFail(self, packOnRoleMoveFail):
        logging.debug('Ö÷½ÇÒƶ¯Ê§°Ü#tagRoleMoveFail')
#        playerId = self.robot.GetPlayerInfo().GetPlayerID()
#        if playerId not in MapMove.moveIsErrIdList:
#            MapMove.moveIsErrIdList.append(playerId)
#            logging.debug('Ö÷½ÇÒƶ¯Ê§°Ü£¬Ìí¼Ó11moveIsErrIdList=%s'%str(MapMove.moveIsErrIdList))
            
        #logging.debug('NAME = %s'%(self.__ai.robot.GetPlayerInfo().GetPlayerName()))
        self.robot.GetPlayerInfo().SetPosX(packOnRoleMoveFail.PosX)
        self.robot.GetPlayerInfo().SetPosY(packOnRoleMoveFail.PosY)
        self.StopMove()
        return
    
    
    ## #04 02 Ë¢ÐÂÈËÎïÔÚ±¾µØͼÖеÄλÖÃ#tagPlayerResetPos
    #  @param None : None
    #  @return None
    #  @remarks
    def OnPlayerResetPos(self, packOnPlayerResetPos):
        logging.debug('Ë¢ÐÂÈËÎïÔÚ±¾µØͼÖеÄλÖÃ#tagPlayerResetPos')
        self.robot.GetPlayerInfo().SetPosX(packOnPlayerResetPos.PosX)
        self.robot.GetPlayerInfo().SetPosY(packOnPlayerResetPos.PosY)
        self.mapMove.PlayerForceStopMove()
        return
    
    
    ## 04 03 Íæ¼ÒµÇ¼Êý¾Ý·¢ËÍÍê±ÏOK#tagPlayerLoginLoadOK
    #  @param None : None
    #  @return bool
    #  @remarks
    def OnPlayerLoginLoadOK(self, packOnPlayerLoginLoadOK):
        logging.debug(' Íæ¼ÒµÇ¼Êý¾Ý·¢ËÍÍê±ÏOK#tagPlayerLoginLoadOK')
        self.mapMove.SendPlayerMoveYield('active')
        return
    
    
    
    """
                    ʵÏÖ¸÷ÖÖÏûÏ¢»Øµ÷º¯Êý£¬
        1. Ïò·þÎñ¶Ë·¢°ü¿ÉʹÓÃÀàËÆ
        onlineR = tagCOnlineReturn()
        self.robot.Send( onlineR )
        
        2.Èç¹ûÐèÒªÏòRobot±£´æÊý¾Ý£¬ÔòÊÂÏÈÈ·ÈÏÕâЩÊý¾ÝÊÇ·ñÖ»ÊÇAIÔËÐÐÏà¹Ø£¬
                      ¶øÓëʹÓÃRobotµÄÆäËûÀàµÄʵÀýÎÞ¹Ø
                    Èç¹ûÊÇÕâÖÖÇé¿ö£¬Çë²»Òª±£´æµ½Robot£¬¶øÓ¦¸ÃÔÚ¶ÔÓ¦µÄAIµÄ×ÓÀàÄÚ±£´æÊý¾Ý
                    
        3.Èç¹ûÐèÒªÖÜÆÚÐԻص÷£¬ÔòÔÚ__init__ʱÉèÖÃTimer£¬ÌáʾÖØÔØ_Processº¯Êý
    """