#!/usr/bin/python
# -*- coding: GBK -*-
#
#
##@package HighLadder.py
#
# @todo:ÌìÌݾº¼¼³¡GameServer
#
# @author xmnathan
# @date 2010-01-01 10:00
# @version 2.4
# @note:
# @change: "2014-08-08 10:30" xmnathan ÌìÌݾº¼¼³¡
# @change: "2014-08-11 17:30" xmnathan ÌìÌݾº¼¼³¡Ä¬ÈÏ¿ÉÌôÕ½ÅÅλÁбí
# @change: "2014-08-11 18:30" xmnathan ÌìÌݾº¼¼³¡Ôö¼ÓÌôսǰ¼¸Ãû³É¹¦ÏµÍ³Ìáʾ
# @change: "2014-08-18 16:30" xmnathan ÌìÌݾº¼¼³¡Ôö¼ÓÌôսʱÅÅÃû±ä¸üϵͳÌáʾ
# @change: "2014-08-19 14:30" xmnathan ÌìÌݾº¼¼³¡ÌôÕ½ÁбíËæ»úÑ¡È¡
# @change: "2014-08-21 09:39" xmnathan ÌìÌݾº¼¼³¡  ÅÅÐаñID ID2±ØÐ붼´æͬһ¸öÖµ£¬·â°ü·¢µÄÊÇID2
# @change: "2014-09-09 16:40" xmnathan ÌìÌݾº¼¼³¡¿ÉÌôÕ½ÁбíÌí¼Ó¸Ä³ÉÃû´Î
# @change: "2014-11-10 10:30" xmnathan PlayerBillboardͳһ¿½±´ÅÅÐаñ×òÈÕ°ñ
# @change: "2014-12-22 20:30" xmnathan ¾º¼¼³¡Ã¿ÈÕÅÅÐн±Àø²éѯ·À·¶
# @change: "2015-01-14 20:30" hxp Ôö¼Ó¸ù¾ÝÌôÕ½´ÎÊýÒ»¶¨¼¸ÂʸøÎïÆ·
# @change: "2015-07-13 10:30" ljd ÅÅÐаñ¼ÓÍæ¼Òƽ̨²ÎÊýName2,ƽ̨ÐÅϢȡֵ
# @change: "2016-10-27 16:00" hxp »ñÈ¡¿ÉÌôÕ½Ãû´ÎÁбíÂß¼­ÓÅ»¯
# @change: "2016-11-07 21:40" xdh Ô¤·À±¨´í
# @change: "2016-12-13 21:00" xdh Ôö¼ÓJJCÒ»´ÎÐÔÅÅÃû½±Àø
#------------------------------------------------------------------------------ 
#"""Version = 2016-12-13 21:00"""
#------------------------------------------------------------------------------ 

import GameWorld
import ShareDefine
import IPY_GameServer
import ReadChConfig
import ChGameToMapPyPack
import NetPackCommon
import PlayerControl
import PlayerBillboard
import ChPyNetSendPack
import random
    
(
Def_TopPlayer_Count, # ²é¿´ÌìÌݶ¥¼¶Íæ¼ÒÁбíµÄλÊý
Def_StartOrder, # ÌìÌÝÍæ¼ÒĬÈÏÆðʼλÖÃ(Ë÷Òý´Ó0Æð)
Def_CanFightCount, #  ¿ÉÌôÕ½Íæ¼ÒÏÔʾ¸öÊý
Def_HighOrderAtleastCnt, # ¿ÉÌôÕ½µÄÍæ¼ÒÖÁÉÙÐè°üº¬¶àÉÙÃû×ÔÉíÅÅÃûºóµÄÍæ¼Ò
Def_MinOrder, # ÌìÌÝÍæ¼Ò½ø°ñ×îµÍÃû´Î
Def_Rec_Count, # ¶ÔÕ½¼Ç¼ÌõÊý
Def_CanFightOrderList, # ¿ÉÖ±½ÓÌôÕ½µÄÅÅÃû
) = range(7)

def GetHighLadderCfg(index):
    hladderCfg = ReadChConfig.GetEvalChConfig("HighLadderDef")
    if index < 0 or index >= len(hladderCfg):
        return 0
    return hladderCfg[index]

##//1A 11 ÌìÌݾº¼¼³¡²éѯ¶¥¼¶Íæ¼ÒÁбí#tagCHightLadderTopPlayerQuery
#struct	tagCHightLadderTopPlayerQuery
#{
#	tagHead Head;
#};
#  @param index, tick
#  @return None
def OnHightLadderTopPlayerQuery(index, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    if not curPlayer:
        return
    curPlayer.Sync_HightLadderTopPlayer(GetHighLadderCfg(Def_TopPlayer_Count))
    return


##//1A 12 ÌìÌݾº¼¼³¡²éѯµ±Ç°Î»ÖÿÉÌôÕ½Íæ¼ÒÁбí#tagCHightLadderCanFightPlayerQuery
#struct	tagCHightLadderCanFightPlayerQuery
#{
#	tagHead Head;
#	DWORD	PlayerID;
#};
#  @param index, tick
#  @return None
def OnHightLadderCanFightPlayerQuery(index, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    if not curPlayer:
        return
    recvPack = IPY_GameServer.IPY_CHightLadderCanFightPlayerQuery()
    
    PlayerID = recvPack.GetPlayerID()
    Sync_HightLadderCanFightPlayer(curPlayer, PlayerID)
    curPlayer.Sync_HighLadderPlayerVsRec()
    return
##֪ͨ ÌìÌݾº¼¼³¡²éѯµ±Ç°Î»ÖÿÉÌôÕ½Íæ¼ÒÁбí
#  @param curPlayer, PlayerID
#  @return
def Sync_HightLadderCanFightPlayer(curPlayer, PlayerID):
            
    myOrder = GetPlayerOrder(PlayerID)
    curPlayer.Begin_AddHightLadderCanFightPlayer(myOrder)
    #Ìí¼Ó¿É¶ÔÕ½Íæ¼Ò ¡­¡­
    highOrderList, lowOrderList = GetCanFightOrder(myOrder)
    highAtleastCnt = GetHighLadderCfg(Def_HighOrderAtleastCnt)
    canFightCnt = GetHighLadderCfg(Def_CanFightCount)
    randomList = []
    if highAtleastCnt:
        if highOrderList:
            randomList = random.sample(highOrderList, min(len(highOrderList), highAtleastCnt)) # ÖÁÉÙÐè°üº¬µÄ
            for order in randomList:
                highOrderList.remove(order) # ÏÈ°ÑÒÑÑ¡³öÀ´µÄÒƳý£¬ºóÃæ¸öÊý²»¹»Ê±»¹ÐèÒª´ÓÖÐÑ¡Ôñ
            
        GameWorld.DebugLog("ÖÁÉÙÐè°üº¬µÄ: highAtleastCnt=%s, randomList=%s, highOrderList=%s" 
                           % (highAtleastCnt, randomList, highOrderList))
    
    if lowOrderList:
        randomList += random.sample(lowOrderList, min(len(lowOrderList), max(0, canFightCnt - len(randomList)))) # »¹ÐèÌí¼ÓµÄ
    GameWorld.DebugLog("Ëæ»úÌí¼ÓlowOrderList: randomList=%s" % randomList)
    
    # Èç¹û»¹²»¹»
    if len(randomList) < canFightCnt:
        if highOrderList:
            randomList += random.sample(highOrderList, canFightCnt - len(randomList)) # »¹ÐèÌí¼ÓµÄ
        GameWorld.DebugLog("»¹²»¹»ÔòÌí¼Ó֮ǰµÄhighOrderList: randomList=%s" % randomList)
        
    randomList.sort()
    GameWorld.DebugLog("×îÖÕËæ»úÌôÕ½Áбí: myOrder=%s,randomList=%s" % (myOrder, randomList))
    for orderIndex in randomList:
        curPlayer.Add_HightLadderCanFightPlayer(orderIndex)
    curPlayer.Sync_HightLadderCanFightPlayer()        
    return

## »ñÈ¡Íæ¼Òµ±Ç°Ãû´Î
#  @param PlayerID
#  @return myOrder
def GetPlayerOrder(PlayerID):
    myPlayerData = GameWorld.GetHightLadderMgr().FindPlayerData(PlayerID)
    myOrder = GetHighLadderCfg(Def_StartOrder)
    if myPlayerData:
        myOrder = myPlayerData.GetOrder()
    return myOrder

## ¸ù¾Ý¹æÔò»ñÈ¡¿ÉÌôÕ½ÅÅÃûÁбí
#  @param myOrder
#  @return None
def GetCanFightOrder(myOrder):
    '''
    @todo: ¸ù¾ÝÍæ¼ÒÅÅÃû»ñÈ¡¿ÉÌôÕ½µÄÍæ¼ÒÅÅÃûÁбí
    @param myOrder: Íæ¼ÒÃû´Î
    @return: ¿ÉÌôÕ½µÄ½Ï¸ßÅÅÃûÍæ¼ÒÁбí, ¿ÉÌôÕ½µÄ½ÏµÍÅÅÃûÍæ¼ÒÁбí
    @note: 
            Ãû´ÎÔ½¸ßʵÁ¦Ô½²î, µÚÒ»ÃûµÄÃû´ÎΪ0
    '''
    HightLadderCanFightDict = ReadChConfig.GetEvalChConfig("HighLadderCanFight")
    #»ñÈ¡¿ÉÌôÕ½·¶Î§
    orderRange = GameWorld.GetDictValueByRangeKey(HightLadderCanFightDict, myOrder, [-10, 10])
    highOrder = max(0, min(myOrder - orderRange[0], GetHighLadderCfg(Def_MinOrder)))
    lowOrder = max(0, myOrder - orderRange[1])
    
    highOrderList = range(myOrder + 1, highOrder + 1)
    lowOrderList = range(lowOrder, myOrder)
    
    GameWorld.DebugLog("¿ÉÌôÕ½Áбí: myOrder=%s, highOrderList=%s, lowOrderList=%s" 
                       % (myOrder, highOrderList, lowOrderList))
    return highOrderList, lowOrderList

##//03 02 ÌìÌݾº¼¼³¡Íæ¼Ò·¢ÆðÌôÕ½#tagMGHighLadderChallenge
#  @param routeIndex, mapID, curPackData, tick
#  @return None
def OnMGHighLadderChallenge(routeIndex, mapID, curPackData, tick):
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge in")
    myPlayerID = curPackData.PlayerID
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(myPlayerID)
    myOrder = GetPlayerOrder(myPlayerID)
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge in myOrder %s VSOrder %s"%(myOrder, curPackData.VSOrder))
    highOrderList, lowOrderList = GetCanFightOrder(myOrder)
    canFightOrderList = highOrderList + lowOrderList
    #УÑé Íæ¼ÒÄÜ·ñÌôÕ½¸ÃÅÅλ  ¸ù¾Ý×ÔÉíÅÅλËã³öÀ´µÄ¿ÉÌôÕ½ÁÐ±í            ĬÈÏÅäÖõĿÉÌôÕ½Áбí
    if(curPackData.VSOrder not in canFightOrderList) and (curPackData.VSOrder not in GetHighLadderCfg(Def_CanFightOrderList)):
        #ÄúµÄλÖÃÒѱä¸ü£¬ÇëÖØÐÂÑ¡ÔñÌôÕ½µÄÍæ¼Ò
        Sync_HightLadderCanFightPlayer(curPlayer, myPlayerID)
        PlayerControl.NotifyCode(curPlayer, "Arena_liubo_807125")
        GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge canFightOrderList %s"%canFightOrderList)
        GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge out order err")
        return
    #Õ½¶·ÊôÐÔ
    curFightPropertyDict = eval(curPackData.FightPropertyData) 
    curFightPropertyDict["FightPower"] = curPackData.FightPower
    curVsFightPropertyDict = GetFightPropertyDictByOrder(curPackData.VSOrder)
    
    hadFightCnt = curFightPropertyDict["HadFightCnt"]
    awardItemList = __GetFightCntAwardItemList(hadFightCnt)
    GameWorld.DebugLog("OnMGHighLadderChallenge hadFightCnt=%s,awardItemList=%s" 
                       % (hadFightCnt, str(awardItemList)))
    historyMaxOrder = curFightPropertyDict["HistoryMaxOrder"]#ÀúÊ·×î¸ßÅÅÃûĬÈÏ1¿ªÊ¼,0´ú±íδ¼Ç¼¹ý
    result = DoFight(curFightPropertyDict, curVsFightPropertyDict) 
    #ÏÈ֪ͨ¶ÔÕ½½á¹û 
    curVsHightLadderPlayer = GameWorld.GetHightLadderMgr().FindPlayerDataByOrder(curPackData.VSOrder)
    curVsPlayerID = 0
    curVsPlayerName = ""
    # ¸½¼ÓÐÅÏ¢
    PlusInfoDict = {}
    PlusInfoDict["Order"] = myOrder
    PlusInfoDict["VSOrder"] = curPackData.VSOrder
    PlusInfoDict["AwardItemList"] = awardItemList  
    myNewOrder = min(myOrder, curPackData.VSOrder) if result else myOrder 
    if historyMaxOrder == 0:
        upOrder = GetHighLadderCfg(Def_StartOrder) - myNewOrder
    else:
        upOrder = max(0, historyMaxOrder - 1 - myNewOrder) # ÌáÉýµÄÅÅÃû
    
    newMaxOrder = (historyMaxOrder - upOrder) if historyMaxOrder else (myNewOrder + 1)
    PlusInfoDict["HistoryMaxOrder"] = newMaxOrder
    PlusInfoDict["upOrder"] = upOrder
    strPlusInfoDict = str(PlusInfoDict)
    
    if curVsHightLadderPlayer:
        curVsPlayerID = curVsHightLadderPlayer.GetPlayerID()
        curVsPlayerName = curVsHightLadderPlayer.GetPlayerName();
    curPlayer.Sync_HightLadderVSPlayerInfo(curVsPlayerID, result, strPlusInfoDict, len(strPlusInfoDict))
    
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge Send tagGMHighLadderChallengeReuslt")
    #·¢°üµ½µØͼ·þÎñÆ÷¸ø½±Àø
    sendPack = ChGameToMapPyPack.tagGMHighLadderChallengeReuslt() 
    sendPack.PlayerID = myPlayerID
    sendPack.Result = result
    sendPack.PlusInfo = strPlusInfoDict
    sendPack.PlusInfoSize = len(strPlusInfoDict)
    NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack) 
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge Send tagGMHighLadderChallengeReuslt OK")   

    #Ìí¼Ó¶ÔÕ½¼Ç¼»º´æ
    GameWorld.GetHightLadderMgr().AddPlayerVsRec(myPlayerID, curVsPlayerID, curVsPlayerName, \
                                                 myOrder, curPackData.VSOrder, 0, result) 
    myRec = GameWorld.GetHightLadderMgr().GetPlayerVsRec(myPlayerID)
    #ɾ³ý¶àÓà³öÀ´µÄÌõÊý   
    DelUselessRec(myRec)
        
    curPlayer.Sync_HighLadderPlayerVsRec()
    
    if curVsPlayerID:#±»ÌôÕ½Íæ¼ÒÒ²Òª¼Ç¼ ½á¹ûÐèÒª·´¹ýÀ´ ÒÔ±»ÌôÕ½Õ߽Ƕȿ´
        GameWorld.GetHightLadderMgr().AddPlayerVsRec(curVsPlayerID, myPlayerID, curPackData.PlayerName, \
                                                     curPackData.VSOrder, myOrder, 1, not result)
        vsRec = GameWorld.GetHightLadderMgr().GetPlayerVsRec(curVsPlayerID)
        DelUselessRec(vsRec)
        
        VsPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curVsPlayerID)
        if VsPlayer:
            VsPlayer.Sync_HighLadderPlayerVsRec()
            
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge AddPlayerVsRec OK")  
    
    #ÔÙͬ²½Êý¾Ý
    if result:    #»ñʤ£¬ÐèÒªÌ滻λÖ㬸üÐÂÊý¾Ý
        newOrder = curPackData.VSOrder
        WinMsgDict = ReadChConfig.GetEvalChConfig("HighLadderWinMsg")
        winMsg = WinMsgDict.get(newOrder, "")
        if myOrder > GetHighLadderCfg(Def_MinOrder): #ÅÅÃûÖ®Íâ½øÈëÅÅÃû
            GameWorld.GetHightLadderMgr().DelPlayerDataByOrder(newOrder)
            GameWorld.GetHightLadderMgr().AddPlayerData(myPlayerID, newOrder)
            if winMsg != "":
                PlayerControl.WorldNotify(0, winMsg, [curPlayer.GetName(), "%s"%(newOrder+1)])
        else:
            if curVsPlayerID: #½»»»Íæ¼ÒλÖÃ
                if newOrder < myOrder:
                    GameWorld.GetHightLadderMgr().ExchangePlayerOrder(myPlayerID, curVsPlayerID)
                    if winMsg != "":
                        PlayerControl.WorldNotify(0, winMsg, [curPlayer.GetName(), "%s"%(newOrder+1)])
            else:    #Õ¼¾ÝNPCλÖÃ
                if newOrder < myOrder:
                    GameWorld.GetHightLadderMgr().AddPlayerData(myPlayerID, newOrder)
                    if winMsg != "":
                        PlayerControl.WorldNotify(0, winMsg, [curPlayer.GetName(), "%s"%(newOrder+1)])
        #¸üÐÂÍæ¼ÒÊý¾Ý
        UpdataHightLadderPlayer(myPlayerID, curPackData)
    else:
        #ʧ°Ü£¬¸üÐÂ×ÔÉíÕ½¶·ÊôÐÔ£¬ÆäÓ಻±ä
        if myOrder > GetHighLadderCfg(Def_MinOrder): #ÅÅÃûÖ®Íâδ»ñʤ²»ÄܽøÈë½øÈëÅÅÃû
            GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge out Result 0")
            return
        #¸üÐÂÍæ¼ÒÊý¾Ý
        UpdataHightLadderPlayer(myPlayerID, curPackData)
    GameWorld.DebugLog("HighLadder### OnMGHighLadderChallenge out Result %s"%result)

    return


## ɾ³ý¶àÓàÌõÊý
#  @param 
#  @return None
def DelUselessRec(myRec):
    if not myRec:
        return
    
    delcnt = max(myRec.RecCount() - GetHighLadderCfg(Def_Rec_Count), 0)
    for i in range(delcnt):
        myRec.DelRec(0)

    return


##¸ù¾ÝÌôÕ½´ÎÊý»ñÈ¡½±ÀøÎïÆ·
#  @param playerFightCnt Íæ¼ÒÒÑÌôÕ½´ÎÊý
#  @return None
def __GetFightCntAwardItemList(playerFightCnt):
    fightCntAwardDict = ReadChConfig.GetEvalChConfig("HighLadderFightCntAward")
    fightCntList = fightCntAwardDict.keys()
    fightCntList.sort()
    
    for fCnt in fightCntList:
        
        if playerFightCnt <= fCnt:
            happenRate, awardItemList = fightCntAwardDict[fCnt]
            if GameWorld.CanHappen(happenRate):
                return awardItemList
            
            return []
        
    return []

##¸üÐÂÍæ¼ÒÊý¾Ý
#  @param curPlayerID, infoPack
#  @return None
def UpdataHightLadderPlayer(curPlayerID, infoPack):
    curHightLadderPlayer = GameWorld.GetHightLadderMgr().FindPlayerData(curPlayerID)
    #¸üÐÂÍæ¼ÒÊý¾Ý
    curHightLadderPlayer.SetPlayerName(infoPack.PlayerName) 
    curHightLadderPlayer.SetPlayerLV(infoPack.PlayerLV)       
    curHightLadderPlayer.SetFightPower(infoPack.FightPower) 
    curHightLadderPlayer.SetFightPropertyData(infoPack.FightPropertyData, infoPack.FightPropertyDataLen)
    
    #¸üÐÂÍæ¼Ò×°±¸Êý¾Ý
    curHightLadderPlayer.ClearPlayerEquipt() 
    GameWorld.DebugLog("HighLadder### UpdataHightLadderPlayer EquipCount %s"%infoPack.EquipCount)
    for i in xrange(infoPack.EquipCount):
        curEquipInfo = infoPack.EquipList[i]
        curEquipData = IPY_GameServer.IpyHighLadderPlayerItem()
        curEquipData.ItemID = curEquipInfo.ItemTypeID
        curEquipData.ItemPlaceType = curEquipInfo.ItemPlaceType
        curEquipData.ItemPlaceIndex = curEquipInfo.ItemPlaceIndex
        curEquipData.Count = curEquipInfo.Count
        curEquipData.ItemStarLV = curEquipInfo.ItemStarLV
        curEquipData.IdentifyPar = curEquipInfo.IdentifyPar
        curEquipData.CurDurg = curEquipInfo.CurDurg
        curEquipData.MaxDurg = curEquipInfo.MaxDurg
        curEquipData.CanPlaceStoneCount = curEquipInfo.CanPlaceStoneCount
        curEquipData.ItemProperty = curEquipInfo.ItemProperty
        curEquipData.SoulProperty = curEquipInfo.SoulProperty
        curEquipData.Maker = curEquipInfo.Maker
        curEquipData.MakerName = curEquipInfo.MakerName
        curEquipData.Stone1 = curEquipInfo.Stone1
        curEquipData.Stone2 = curEquipInfo.Stone2
        curEquipData.Stone3 = curEquipInfo.Stone3
        curEquipData.Stone4 = curEquipInfo.Stone4
        curEquipData.Stone5 = curEquipInfo.Stone5
        curEquipData.Stone6 = curEquipInfo.Stone6
        curEquipData.Stone7 = curEquipInfo.Stone7
        curEquipData.Stone8 = curEquipInfo.Stone8
        curEquipData.Stone9 = curEquipInfo.Stone9
#        curEquipData.IsRenZhu = curEquipInfo.IsRenZhu
        curEquipData.EquipDefenseValue = curEquipInfo.EquipDefenseValue
        curEquipData.EquipMinAtkValue = curEquipInfo.EquipMinAtkValue
        curEquipData.EquipMaxAtkValue = curEquipInfo.EquipMaxAtkValue
        curEquipData.UserData = curEquipInfo.UserData
        curEquipData.FitLV = curEquipInfo.FitLV
        curEquipData.Proficiency = curEquipInfo.Proficiency
        curEquipData.IsSuite = curEquipInfo.IsSuite
        curEquipData.BaseHP = curEquipInfo.BaseHP
        curEquipData.BaseMagicDef = curEquipInfo.BaseMagicDef
        curEquipData.MaxAddSkillCnt = curEquipInfo.MaxAddSkillCnt
#        curEquipData.PetID = curEquipInfo.PetID
        curEquipData.EquipMagicDefValue = curEquipInfo.EquipMagicDefValue
        curEquipData.EquipMinMagicAtkValue = curEquipInfo.EquipMinMagicAtkValue
        curEquipData.EquipMaxMagicAtkValue = curEquipInfo.EquipMaxMagicAtkValue
        curHightLadderPlayer.AddEquipIpyData(curEquipData)

    #curHightLadderPlayer.DumpEquipData()
        
    return

##»ñÈ¡Ö¸¶¨Íæ¼ÒµÄÕ½¶·ÊôÐÔ
#  @param orderIndex
#  @return None
def GetFightPropertyDictByOrder(orderIndex):
    curVsFightPropertyDict = {}
    curVsPlayer = GameWorld.GetHightLadderMgr().FindPlayerDataByOrder(orderIndex)
    if not curVsPlayer:
        curVsFightPropertyDict = GetNPCFightPropertyByOrder(orderIndex)
    else:
        curVsFightPropertyDict = eval(curVsPlayer.GetFightPropertyData())
        curVsFightPropertyDict["FightPower"] = curVsPlayer.GetFightPower()
    return curVsFightPropertyDict

##»ñÈ¡Ö¸¶¨ÅÅλNPCµÄÕ½¶·ÊôÐÔ
#  @param order
#  @return None
def GetNPCFightPropertyByOrder(order):
    HighLadderNPCPropertyDict = ReadChConfig.GetEvalChConfig("HighLadderNPCProperty")
    curPropertyDict = {}
    curPropertyDict["Atk"] = eval(HighLadderNPCPropertyDict["Atk"])
    curPropertyDict["Def"] = eval(HighLadderNPCPropertyDict["Def"])
    curPropertyDict["MaxHP"] = eval(HighLadderNPCPropertyDict["MaxHP"])
    curPropertyDict["Hit"] = eval(HighLadderNPCPropertyDict["Hit"])
    curPropertyDict["Miss"] = eval(HighLadderNPCPropertyDict["Miss"])
    curPropertyDict["AtkSpeed"] = eval(HighLadderNPCPropertyDict["AtkSpeed"])
    curPropertyDict["GreatHitRate"] = eval(HighLadderNPCPropertyDict["GreatHitRate"])
    curPropertyDict["GreatHit"] = eval(HighLadderNPCPropertyDict["GreatHitRate"])
    curPropertyDict["LuckyHitRate"] = eval(HighLadderNPCPropertyDict["LuckyHitRate"])
    curPropertyDict["LuckyHit"] = eval(HighLadderNPCPropertyDict["LuckyHit"])
    curPropertyDict["SuperHitRate"] = eval(HighLadderNPCPropertyDict["SuperHitRate"])
    curPropertyDict["SuperHit"] = eval(HighLadderNPCPropertyDict["SuperHit"])
    curPropertyDict["IgnoreDefRate"] = eval(HighLadderNPCPropertyDict["IgnoreDefRate"])
    curPropertyDict["DamageReduceRate"] = eval(HighLadderNPCPropertyDict["DamageReduceRate"])
    curPropertyDict["FightPower"] = eval(HighLadderNPCPropertyDict["FightPower"])
    return curPropertyDict

##Ö´ÐжÔÕ½ »ñÈ¡½á¹û
#  @param curFightPropertyDict, curVsFightPropertyDict
#  @return None
def DoFight(curFightPropertyDict, curVsFightPropertyDict):
    #Õ½¶·¹«Ê½¼ÆËã
    HighLadderFightFormula = ReadChConfig.GetChConfig("HighLadderFightFormula")

    Atk = curFightPropertyDict["Atk"]
    Def = curFightPropertyDict["Def"]
    MaxHP = curFightPropertyDict["MaxHP"]
    Hit = curFightPropertyDict["Hit"]
    Miss = curFightPropertyDict["Miss"]
    AtkSpeed = curFightPropertyDict["AtkSpeed"]
    GreatHitRate = curFightPropertyDict["GreatHitRate"]
    GreatHit = curFightPropertyDict["GreatHit"]
    LuckyHitRate = curFightPropertyDict["LuckyHitRate"]
    LuckyHit = curFightPropertyDict["LuckyHit"]
    SuperHitRate = curFightPropertyDict["SuperHitRate"]
    SuperHit = curFightPropertyDict["SuperHit"]
    IgnoreDefRate = curFightPropertyDict["IgnoreDefRate"]
    DamageReduceRate = curFightPropertyDict["DamageReduceRate"]
    FightPower = curFightPropertyDict["FightPower"]
    RandomRate = random.randint(0, 10000)
    
    VS_Atk = curVsFightPropertyDict["Atk"]
    VS_Def = curVsFightPropertyDict["Def"]
    VS_MaxHP = curVsFightPropertyDict["MaxHP"]
    VS_Hit = curVsFightPropertyDict["Hit"]
    VS_Miss = curVsFightPropertyDict["Miss"]
    VS_AtkSpeed = curVsFightPropertyDict["AtkSpeed"]
    VS_GreatHitRate = curVsFightPropertyDict["GreatHitRate"]
    VS_GreatHit = curVsFightPropertyDict["GreatHit"]
    VS_LuckyHitRate = curVsFightPropertyDict["LuckyHitRate"]
    VS_LuckyHit = curVsFightPropertyDict["LuckyHit"]
    VS_SuperHitRate = curVsFightPropertyDict["SuperHitRate"]
    VS_SuperHit = curVsFightPropertyDict["SuperHit"]
    VS_IgnoreDefRate = curVsFightPropertyDict["IgnoreDefRate"]
    VS_DamageReduceRate = curVsFightPropertyDict["DamageReduceRate"]
    VS_FightPower = curVsFightPropertyDict["FightPower"]
    VS_RandomRate = random.randint(0, 10000)
    return bool(eval(HighLadderFightFormula))

###FightPropertyData¸½´øÊôÐÔ
#  Íæ¼ÒÖ°Òµ
#  ¹¥»÷
#  ·ÀÓù
#  ÉúÃü
#  ÃüÖÐ
#  ÉÁ±Ü
#  ¹¥ËÙ
#  ׿Խһ»÷ ±¶ÂÊ
#  ÐÒÔËÒ»»÷ ±¶ÂÊ
#  ±©»÷     ±¶ÂÊ
#  ÎÞÊÓ·ÀÓù 
###

## ¹ýÌì´¦Àí
#  @param None
#  @return None
def OnDay():
    #¸üÐÂÅÅÐаñ
    RefreshBillboard()
#    #¸üоº¼¼³¡×òÈÕÅÅÐаñ
#    PlayerBillboard.CopyBillboard(ShareDefine.Def_BT_HighLadder_Yester, ShareDefine.Def_BT_HighLadder)
    return

## ÿСʱ´¦Àí
#  @param None
#  @return None
def OnHour():
    #¸üÐÂÅÅÐаñ
    RefreshBillboard()
    return

## Ë¢ÐÂÅÅÐаñ
#  @param None
#  @return None
def RefreshBillboard():
    billboardType = ShareDefine.Def_BT_HighLadder
    PlayerBillboard.ClearBillboardByIndex(billboardType)
    billboardMgr = GameWorld.GetBillboard()
    billBoard = billboardMgr.FindBillboard(billboardType)
    highLadderMgr = GameWorld.GetHightLadderMgr()
    minOrder = GetHighLadderCfg(Def_MinOrder)
    for Order in xrange(minOrder):
        playerData = highLadderMgr.FindPlayerDataByOrder(Order)
        if not playerData:
            #playerID = Order + 1   #Íæ¼ÒIDÊÇ´Ó10000£¬¿ªÊ¼Ð¡ÓÚ10000µÄ¶¼²»ÊÇÍæ¼Ò£¬Ö»ÊÇռλNPC
            continue
        playerID = playerData.GetPlayerID()
        billBoardData = billBoard.AddToBillboard(playerID)
        billBoardData.SetType(billboardType)
        #¸½ÊôÀàÐÍ
        billBoardData.SetID(playerID)
        billBoardData.SetID2(playerID)
        billBoardData.SetName1(playerData.GetPlayerName())
        curFightPropertyDict = eval(playerData.GetFightPropertyData())
        billBoardData.SetName2(str(curFightPropertyDict.get("OperateInfo", 0)))
        #SetValue1´æ´¢¿Õ¼äΪWord
        billBoardData.SetValue1(Order + 1)  #ÓÃÓÚÏÔʾµÄÅÅÃû ÐèÒª+1
        #SetValue2´æ´¢¿Õ¼äΪDWord
        billBoardData.SetValue2(playerData.GetFightPower())
        #±È½ÏÓõÄÖµ
        billBoardData.SetCmpValue(max(0, minOrder - Order + 1))        
    billBoard.Sort()   
    return


## µØͼ²éѯ½±Àø
#  @param curPlayer, msgList
#  @return None
def MapServer_HighLadderReward(curPlayer, msgList):  
    PlayerID = msgList[0]  
    queryType = msgList[1]  #0 ²éѯ  1 ÁìÈ¡
    hadGot = msgList[2]    #ÊÇ·ñÒѾ­ÁìÈ¡
    billboardMgr = GameWorld.GetBillboard()
    billBoardYester = billboardMgr.FindBillboard(ShareDefine.Def_BT_HighLadder_Yester)
    highLadderMgr = GameWorld.GetHightLadderMgr()
    
    order = GetPlayerOrder(PlayerID) #Íæ¼Òµ±Ç°ÅÅÃû
    
    if billBoardYester:#Èç¹ûÓÐ×òÈÕÅÅÐУ¬ÔòÈ¡×òÈÕÅÅÐÐ
        billBoardData = billBoardYester.FindByID(PlayerID)
        if billBoardData:
            order = billBoardData.GetValue1() - 1#ÓÃÓÚÅÅÐò£¬°ÑÏÔʾÓõÄÅÅÃûÖµ -1
        else:
            order = GetHighLadderCfg(Def_StartOrder)
        
    if queryType == 0:#²éѯ Ö±½Ó֪ͨÍæ¼Ò
        
        sendPack = ChPyNetSendPack.tagGCHighLadderRewardInfo()
        sendPack.hadGot = hadGot
        sendPack.Order = order
        if curPlayer:
            NetPackCommon.SendFakePack(curPlayer, sendPack)
        return False, "%s"%[PlayerID, hadGot, order]
    else:            #Áì½± ÐèҪ֪ͨµ½µØͼ
        return  True, "%s"%[PlayerID, hadGot, order]