#!/usr/bin/python
# -*- coding: GBK -*-
#
#
##@package HighLadderTube.py
#
# @todo:ÌìÌݾº¼¼³¡MapServer
#
# @author xmnathan
# @date 2010-01-01 10:00
# @version 3.2
# @note:
# @change: "2014-08-05 18:00" xmnathan ÌìÌݾº¼¼³¡
# @change: "2014-08-07 11:30" xmnathan ÿÈÕ½±ÀøÖ§³ÖÁìÈ¡ »ý·Ö ¾­Ñé ħ»ê ½ð±Ò;Ôö¼Ó¹ºÂò´ÎÊýÉÏÏÞ
# @change: "2014-08-07 16:30" xmnathan ÐÞ¸ÄÀäȴʱ¼ä¼ÆË㣺ÿ´ÎÌôÕ½Ôö¼ÓÀäȴʱ¼ä£¬Ê±¼ä´ïµ½Ò»¶¨ÖµÊ±ÐèÒªÀäȴʱ¼äΪ0²ÅÄÜÌôÕ½ 
# @change: "2014-08-08 10:00" hxp Ôö¼Ó²Î¼Ó¾º¼¼³¡ÈÎÎñʼþ´¥·¢
# @change: "2014-08-08 17:30" xmnathan Ôö¼Óħ»êÔÊÐíÒç³ö
# @change: "2014-08-12 10:50" xmnathan Ôö¼ÓÁ¬Ê¤¹ã²¥
# @change: "2014-10-30 21:51" Alee ·þÎñÆ÷µÄtickÊÇ¿ª»úºó´Ó0ËãÆðµÄ£¬ÒªÓÃÏÖʵʱ¼ä´Á
# @change: "2014-11-12 16:30" hxp Ôö¼ÓʤÀû³É¾Í
# @change: "2014-11-13 16:30" xmnathan ¹ýÌìÔö¼ÓÒ»´Î½±Àø²éѯ ÒÔ֪ͨ¿Í»§¶ËË¢ÐÂ
# @change: "2014-12-08 17:00" hxp Ôö¼Ó×êʯÏû·ÑÁ÷Ïò
# @change: "2015-01-14 20:30" hxp Ôö¼Ó¸ù¾ÝÌôÕ½´ÎÊýÒ»¶¨¼¸ÂʸøÎïÆ·
# @change: "2015-01-29 21:52" xmnathan ¾º¼¼³¡±£´æÊý¾ÝÔö¼ÓÍæ¼ÒתÉúµÈ¼¶¡¢´ÎÊý
# @change: "2015-02-10 22:30" hxp Ôö¼Ó×êʯÏûºÄÀàÐÍʼþ»ã±¨
# @change: "2015-02-26 11:40" xmnathan ¾º¼¼³¡±£´æÊý¾ÝÔö¼ÓÍæ¼Ò´óʦµÈ¼¶
# @change: "2015-03-19 16:50" ljd ¹ó×å¼Ó³É
# @change: "2015-04-16 17:50" ljd µ¼ÈëmathÓÃÓÚ¿ªÅäÖÃ
# @change: "2015-07-10 15:40" xdh ¾º¼¼³¡±£´æÊý¾ÝÔö¼ÓÍæ¼ÒÔËÓªÉÌÐÅÏ¢
# @change: "2015-07-28 11:10" ljd ¹ó×å¼Ó³É »¹Ô­
# @change: "2015-07-29 11:30" ljd Ïû·ÑVIPÔö¼Ó´ÎÊý
# @change: "2015-08-24 11:00" xdh Ôö¼ÓJJCÁ¬Ðø»÷ɱ³É¾Í
# @change: "2016-01-26 15:00" hxp PY±íÖ§³ÖÖضÁ
# @change: "2016-12-13 21:00" xdh Ôö¼ÓJJCÒ»´ÎÐÔÅÅÃû½±Àø
#---------------------------------------------------------------------
"""Version = 2016-12-13 21:00""" 
#---------------------------------------------------------------------

import IPY_GameWorld
import GameWorld
import ChConfig
import ReadChConfig
import ShareDefine
import ChPyNetSendPack
import NetPackCommon
import PlayerControl
import ItemCommon
import ItemControler
import DataRecordPack
import ChMapToGamePyPack
import PyMapTable
import PlayerActivity
import PlayerSuccess
import EventShell
import PlayerCostVIP

import time
import math

# ¶¨ÒåÎïÆ·ÀàÐÍ
(
Def_ItemType_CommonItem, # Ò»°ãÎïÆ·
Def_ItemType_AppointItem, # ÌØÊⶨÖÆÎïÆ·
) = range(2)

##//1A 13 ÌìÌݾº¼¼³¡ÌôÕ½Íæ¼Ò#tagCHightLadderChallenge
#struct	tagCHightLadderChallenge
#{
#	tagHead	Head;
#	DWORD	VSOrder;		//ÒªÌôÕ½µÄÅÅλ	
#};
## ÌìÌݾº¼¼³¡ÌôÕ½Íæ¼Ò
#  @param index, tick
#  @return None
def OnHightLadderChallenge(index, tick):
    GameWorld.DebugLog('HightLadder### OnHightLadderChallenge in')
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    if not curPlayer:
        return
    clientPack = IPY_GameWorld.IPY_CHightLadderChallenge()
    
    HighLadderPriceDict = ReadChConfig.GetEvalChConfig("HighLadderPrice")
    needPay = 0
    buyCount = False
    Count = 0
    #УÑé´ÎÊý
    #ÒÑÌôÕ½´ÎÊý
    hadFightCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderFightCnt, 0,
                                              ChConfig.Def_PDictType_Default)
    #¹ºÂò´ÎÊý
    AddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderAddCnt, 0,
                                              ChConfig.Def_PDictType_Default)
    #ÿÈÕĬÈÏ´ÎÊý
    vipAddNum = PlayerCostVIP.GetArenaNum(curPlayer)
    HighLadderFightCntDict = ReadChConfig.GetEvalChConfig("HighLadderFightCnt")
    FightCntPerDay = HighLadderFightCntDict["FightCnt"] + vipAddNum
    CanAddCntPerDay = HighLadderFightCntDict["CanAddCnt"]
    if hadFightCnt >= (FightCntPerDay + AddCnt): #ÿÈÕĬÈÏ´ÎÊý + ÒѹºÂò´ÎÊý
        Count = AddCnt + 1
        if Count > CanAddCntPerDay:
            GameWorld.DebugLog('HightLadder### OnHightLadderChallenge AddCnt %s max %s' % (AddCnt, CanAddCntPerDay))
            return
        AddCountPrice = eval(HighLadderPriceDict["AddCount"])
        GameWorld.DebugLog('HightLadder### OnHightLadderChallenge hadFightCnt %s max %s' % (hadFightCnt, FightCntPerDay))
        needPay += AddCountPrice
        buyCount = True
    
    #УÑéÌôÕ½CD
    CDTime = GetCDTime(curPlayer)
    isRelCDTime = IsRelCDTime(curPlayer, tick)
    if isRelCDTime:
        ClearCDPrice = eval(HighLadderPriceDict["ClearCD"])
        needPay += ClearCDPrice
        
    #×êʯ¹ºÂò¼Û¸ñ
    if needPay:
        infoDict = {"CDTime":CDTime, "IsRelCDTime":isRelCDTime, "IsBuyCount":buyCount, "Count":Count,
                    ChConfig.Def_Cost_Reason_SonKey:"CDAndCount"}
        if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, needPay,
                                      ChConfig.Def_Cost_HighLadder, infoDict):
            return
        #ÇåCD
        if isRelCDTime:
            ClearCDTime(curPlayer);
        #¹ºÂò´ÎÊý
        if buyCount:
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadderAddCnt, AddCnt + 1,
                                              ChConfig.Def_PDictType_Default)
        
        SendHighLadderState(curPlayer, tick)
        
    #·¢ËÍÏà¹ØÊý¾Ý
    sendPack = ChMapToGamePyPack.tagMGHighLadderChallenge()
    sendPack.PlayerID = curPlayer.GetPlayerID()
    sendPack.PlayerName = curPlayer.GetPlayerName()
    sendPack.PlayerLV = curPlayer.GetLV()
    sendPack.FightPower = curPlayer.GetFightPower()
    sendPack.VSOrder = clientPack.GetVSOrder()
    GameWorld.DebugLog('HightLadder### OnHightLadderChallenge VSOrder %s' % sendPack.VSOrder)
    #¸½´øÊý¾Ý
    curFightPropertyDict = {}
    curFightPropertyDict["Job"] = curPlayer.GetJob()
    curFightPropertyDict["LVEx"] = curPlayer.GetLVEx()
    curFightPropertyDict["LV2"] = curPlayer.GetLV2()
    curFightPropertyDict["ReincarnationLv"] = curPlayer.GetReincarnationLv()
    curFightPropertyDict["OperateInfo"] = curPlayer.GetOperateInfo()
    #Õ½¶·ÊôÐÔ
    curFightPropertyDict["Atk"] = curPlayer.GetMaxAtk()
    curFightPropertyDict["Def"] = curPlayer.GetDef()
    curFightPropertyDict["MaxHP"] = curPlayer.GetMaxHP()
    curFightPropertyDict["Hit"] = curPlayer.GetHit()
    curFightPropertyDict["Miss"] = curPlayer.GetMiss()
    curFightPropertyDict["AtkSpeed"] = curPlayer.GetBattleValEx1()
    curFightPropertyDict["GreatHitRate"] = curPlayer.GetGreatHitRate()
    curFightPropertyDict["GreatHit"] = curPlayer.GetGreatHitVal()
    curFightPropertyDict["LuckyHitRate"] = curPlayer.GetLuckyHitRate()
    curFightPropertyDict["LuckyHit"] = curPlayer.GetLuckyHitVal()
    curFightPropertyDict["SuperHitRate"] = curPlayer.GetSuperHitRate()
    curFightPropertyDict["SuperHit"] = curPlayer.GetSuperHit()
    curFightPropertyDict["IgnoreDefRate"] = curPlayer.GetIgnoreDefRate()
    curFightPropertyDict["DamageReduceRate"] = curPlayer.GetDamageReduceRate()
    hadFightCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderFightCnt, 0,
                                                 ChConfig.Def_PDictType_Default)
    curFightPropertyDict["HadFightCnt"] = hadFightCnt
    historyMaxOrder = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_HistoryMaxOrder, 0,
                    ChConfig.Def_PDictType_Default)
    curFightPropertyDict["HistoryMaxOrder"] = historyMaxOrder
    sendPack.FightPropertyData = str(curFightPropertyDict)
    sendPack.FightPropertyDataLen = len(sendPack.FightPropertyData)
    #×°±¸Êý¾Ý
    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
    for index in xrange(ShareDefine.retMax):
        curEquip = equipPack.GetAt(index)
        if curEquip.IsEmpty():
            continue
        curEquipData = ChMapToGamePyPack.tagHightLadderItemInfo()
        curEquipData.ItemTypeID = curEquip.GetItemTypeID()
        curEquipData.ItemPlaceType = curEquip.GetItemPlaceType()
        curEquipData.ItemPlaceIndex = curEquip.GetItemPlaceIndex()
        curEquipData.Count = curEquip.GetCount()
        curEquipData.Maker = curEquip.GetGearScore()
        curEquipData.UserData = curEquip.GetUserData()
        curEquipData.UserDataLen = len(curEquipData.UserData)

        curEquipData.IsSuite = curEquip.GetIsSuite()

        sendPack.EquipList.append(curEquipData)
    sendPack.EquipCount = len(sendPack.EquipList)
    GameWorld.DebugLog('HightLadder### OnHightLadderChallenge out')    
    NetPackCommon.SendPyPackToGameServer(sendPack)
    return 

##//03 01 ÌìÌݾº¼¼³¡Íæ¼ÒÌôÕ½½á¹ûͬ²½#tagGMHighLadderChallengeReuslt
#  @param curPackData, tick
#  @return None
def OnGMHighLadderChallengeReuslt(curPackData, tick):
    GameWorld.DebugLog('HightLadder### OnGMHighLadderChallengeReuslt in') 
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
    if not curPlayer:
        return
    # »îÔ¾¶È
    #PlayerActivity.AddActivityFinishCnt(curPlayer, ShareDefine.ActivityNum_HighLadderArena)
    
    #¼Ç¼Àäȴʱ¼ä
    AddCDTimePer(curPlayer, tick)
    
    #¼Ç¼ÌôÕ½´ÎÊý
    hadFightCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderFightCnt, 0,
                    ChConfig.Def_PDictType_Default)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadderFightCnt, hadFightCnt + 1,
                                              ChConfig.Def_PDictType_Default)
    #¼Ç¼Á¬Ê¤´ÎÊý
    if curPackData.Result > 0:
        EventShell.EventRespons_ArenaEvent(curPlayer, "on_win")
        
        WinningStreakCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_WinningStreak, 0,
                    ChConfig.Def_PDictType_Default)
        WinningStreakCnt += 1
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_WinningStreak, WinningStreakCnt,
                                              ChConfig.Def_PDictType_Default)
        
        WinningStreakMsgDict = ReadChConfig.GetEvalChConfig("HighLadderWinningStreakMsg")
        winMsg = WinningStreakMsgDict.get(WinningStreakCnt, "")
        if winMsg:
            PlayerControl.WorldNotify(0, winMsg, [curPlayer.GetPlayerName(), "%s" % WinningStreakCnt])
        
        # ʤÀû³É¾Í
        #PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_HighLadderWin, 1)
        # Á¬ÐøʤÀû³É¾Í
        #successType = ShareDefine.SuccType_JJCWin
        #PlayerSuccess.UptateSuccessProgress(curPlayer, successType, WinningStreakCnt)
        
    else:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_WinningStreak, 0,
                                              ChConfig.Def_PDictType_Default)
        
    
    
    #¼ÆËã½±Àø ²ÎÊý
    PlusInfoDict = eval(curPackData.PlusInfo)
    upOrder = PlusInfoDict["upOrder"]
    order = PlusInfoDict["Order"]
    vsorder = PlusInfoDict["VSOrder"]
    awardItemList = PlusInfoDict["AwardItemList"]
    newMaxOrder = PlusInfoDict["HistoryMaxOrder"]
    GameWorld.DebugLog("OnGMHighLadderChallengeReuslt awardItemList=%s" % str(awardItemList))
    reLV = curPlayer.GetLV()
    reExp = 0
    reMoney = 0
    result = curPackData.Result
    
    historyMaxOrder = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_HistoryMaxOrder, 0,
                    ChConfig.Def_PDictType_Default)

    GameWorld.DebugLog('        JJCÀúÊ·×î¸ßÅÅÃû¸üРoldhistoryMaxOrder=%s,newMaxOrder=%s,upOrder=%s' % (historyMaxOrder, newMaxOrder, upOrder))
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_HistoryMaxOrder, newMaxOrder,
                                                  ChConfig.Def_PDictType_Default)
    
    # ´¥·¢ÈÎÎñʼþ
    EventShell.EventRespons_ArenaEvent(curPlayer, "on_join")
    
    #¼ÆËã½±Àø
    HighLadderRewardDict = ReadChConfig.GetEvalChConfig("HighLadderReward")
    curHighLadderPoint = eval(HighLadderRewardDict["HighLadderPoint"])
    curExp = eval(HighLadderRewardDict["Exp"])
    curMoney = eval(HighLadderRewardDict["Money"])
    curGoldPaper = eval(HighLadderRewardDict["GoldPaper"])
    #»ý·Ö
    PlayerControl.AddHighLadderCurrency(curPlayer, curHighLadderPoint, False, False)
    
    #¾­Ñé
    playerControl = PlayerControl.PlayerControl(curPlayer)
    playerControl.AddExp(curExp, isSysHint=False)
    #½ð±Ò
    addDataDict = {ChConfig.Def_Give_Reason_SonKey:"Challenge"}
    PlayerControl.GiveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Silver_Money, curMoney,
                            ChConfig.Def_GiveMoney_HighLadder, addDataDict, False)
    #°ó¶¨×êʯ
    PlayerControl.GiveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Paper, curGoldPaper,
                            ChConfig.Def_GiveMoney_HighLadder, addDataDict, False)
    GameWorld.DebugLog('HightLadder### OnGMHighLadderChallengeReuslt out') 
    if awardItemList:
        for itemID, itemCnt, isBind in awardItemList:
            ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, isBind,
                                         [IPY_GameWorld.rptItem, IPY_GameWorld.rptAnyWhere])
    
    SendHighLadderState(curPlayer, tick)
    return 



##»ñÈ¡¾º¼¼³¡ÌôÕ½Àäȴʱ¼ä
#  @param curPlayer
#  @return None
def GetCDTime(curPlayer):
#    HighLadderCDTimeDict = ReadChConfig.GetEvalChConfig("HighLadderCDTime")
#    CDTime = HighLadderCDTimeDict["CDTime"]
#    AddCDPer = HighLadderCDTimeDict["AddCDPer"]
    #·þÎñÆ÷µÄtickÊÇ¿ª»úºó´Ó0ËãÆðµÄ£¬ÒªÓÃÏÖʵʱ¼ä´Á£¬½ÚÊ¡×ÖµäµÄ×ö·¨ÎªÉÏÏßµÄʱºò¼õÈ¥CDʱ¼ä
    tick = int(time.time())
    
    totalCD = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_CDTime, 0,
                                              ChConfig.Def_PDictType_Default)
    lastTick = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_CDBeginTime, 0,
                                              ChConfig.Def_PDictType_Default)
    
    totalCD = max(0, totalCD - max((tick - lastTick), 0) * 1000)
    
    #¸üÐÂCDʱ¼ä ¸üÐÂCDÆðʼʱ¼ä
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDTime, totalCD,
                                              ChConfig.Def_PDictType_Default)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDBeginTime, tick,
                                              ChConfig.Def_PDictType_Default)  
    if totalCD == 0:
        #ÖØÖÃCDʱ¼ä
        ClearCDTime(curPlayer) 
    return totalCD

## ¹Ì¶¨Ôö¼ÓÒ»´ÎCDʱ¼ä
#  @param curPlayer, tick
#  @return None
def AddCDTimePer(curPlayer, tick):
    HighLadderCDTimeDict = ReadChConfig.GetEvalChConfig("HighLadderCDTime")
    CDTime = HighLadderCDTimeDict["CDTime"]
    AddCDPer = HighLadderCDTimeDict["AddCDPer"]
    
    totalCD = GetCDTime(curPlayer)
    totalCD = totalCD + AddCDPer

    #·þÎñÆ÷µÄtickÊÇ¿ª»úºó´Ó0ËãÆðµÄ£¬ÒªÓÃÏÖʵʱ¼ä´Á£¬½ÚÊ¡×ÖµäµÄ×ö·¨ÎªÉÏÏßµÄʱºò¼õÈ¥CDʱ¼ä
    tick = int(time.time())
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDBeginTime, tick,
                                              ChConfig.Def_PDictType_Default)  
    #¸üÐÂCDʱ¼ä
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDTime, totalCD,
                                              ChConfig.Def_PDictType_Default)
    if totalCD > CDTime:#³¬¹ý¿ÉÀÛ¼ÆCD£¬½øÈëÕæÕýÀäȴ״̬
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_IsRelCD, 1,
                                              ChConfig.Def_PDictType_Default) 
    return

## Çå³ýCDʱ¼ä
#  @param curPlayer, tick
#  @return None
def ClearCDTime(curPlayer):
    #¸üÐÂCDʱ¼ä
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDTime, 0,
                                              ChConfig.Def_PDictType_Default)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_CDBeginTime, 0,
                                              ChConfig.Def_PDictType_Default)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_IsRelCD, 0,
                                              ChConfig.Def_PDictType_Default) 
## ÊÇ·ñÔÚÕæʵÀäȴ״̬
#  @param curPlayer, tick
#  @return None 
def IsRelCDTime(curPlayer, tick):
    GetCDTime(curPlayer)
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_IsRelCD, 0,
                                              ChConfig.Def_PDictType_Default)
    
##//A5 36 ÌìÌÝÇå³ýÌôÕ½CD#tagCMHighLadderClearCD
#  @param index, clientPack, tick
#  @return None
def OnHighLadderClearCD(index, clientPack, tick):    
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    HighLadderPriceDict = ReadChConfig.GetEvalChConfig("HighLadderPrice")
    #УÑéÌôÕ½CD
    CDTime = GetCDTime(curPlayer)
    if CDTime > 0:
        ClearCDPrice = eval(HighLadderPriceDict["ClearCD"])
        if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, ClearCDPrice,
                                      ChConfig.Def_Cost_HighLadder, {"CDTime":CDTime, ChConfig.Def_Cost_Reason_SonKey:"CD"}):
            return
    
        ClearCDTime(curPlayer)
        SendHighLadderState(curPlayer, tick)
    return

##//A5 37 ÌìÌÝÔö¼ÓÌôÕ½´ÎÊý#tagCMHighLadderAddCount
#  @param index, clientPack, tick
#  @return None
def OnHighLadderAddCount(index, clientPack, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    HighLadderFightCntDict = ReadChConfig.GetEvalChConfig("HighLadderFightCnt")
    FightCntPerDay = HighLadderFightCntDict["FightCnt"]
    CanAddCntPerDay = HighLadderFightCntDict["CanAddCnt"]
    #¹ºÂò´ÎÊý
    AddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderAddCnt, 0,
                                              ChConfig.Def_PDictType_Default)
    Count = AddCnt + 1
    if Count > CanAddCntPerDay:
        GameWorld.DebugLog('HightLadder### OnHighLadderAddCount AddCnt %s max %s' % (AddCnt, CanAddCntPerDay))
        return
    HighLadderPriceDict = ReadChConfig.GetEvalChConfig("HighLadderPrice")
    AddCountPrice = eval(HighLadderPriceDict["AddCount"])
    if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, AddCountPrice,
                                  ChConfig.Def_Cost_HighLadder, {"Count":Count, ChConfig.Def_Cost_Reason_SonKey:"Count"}):
        return
        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadderAddCnt, AddCnt + 1,
                                              ChConfig.Def_PDictType_Default)    
    SendHighLadderState(curPlayer, tick)
    return




##//A5 34 ²éѯÌìÌݾº¼¼³¡×´Ì¬#tagCMQueryHighLadderState
#  @param index, clientPack, tick
#  @return None
def OnQueryHighLadderState(index, clientPack, tick):
    
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    
    SendHighLadderState(curPlayer, tick)
    
## Ë¢ÐÂÌìÌݾº¼¼³¡×´Ì¬
#  @param curPlayer
#  @return None    
def SendHighLadderState(curPlayer, tick):
    hadFightCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderFightCnt, 0,
                                              ChConfig.Def_PDictType_Default)
    AddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadderAddCnt, 0,
                                              ChConfig.Def_PDictType_Default)
    vipAddNum = PlayerCostVIP.GetArenaNum(curPlayer)
    HighLadderFightCntDict = ReadChConfig.GetEvalChConfig("HighLadderFightCnt")
    FightCntPerDay = HighLadderFightCntDict["FightCnt"] + vipAddNum
    curCurrency = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_Currency, 0,
                                                 ChConfig.Def_PDictType_Default)
    
    sendPack = ChPyNetSendPack.tagMCHighLadderState()
    sendPack.Count = hadFightCnt
    sendPack.MaxCount = FightCntPerDay + AddCnt
    sendPack.CDTime = GetCDTime(curPlayer)
    sendPack.IsRelCD = IsRelCDTime(curPlayer, tick)
    sendPack.Currency = curCurrency
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return


## ÌìÌÝÿÈÕÂß¼­
#  @param curPlayer
#  @return None
def OnDay(curPlayer):
    #Çå³ýÿÈÕÌôÕ½ÌìÌÝ´ÎÊý¼Ç¼
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadderFightCnt, 0, ChConfig.Def_PDictType_Default)
    #Çå³ý×òÈÕÒѹºÂò´ÎÊý
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadderAddCnt, 0, ChConfig.Def_PDictType_Default)
    #Çå³ý×òÈÕÁì½±¼Ç¼
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_DayRewardGot, 0, ChConfig.Def_PDictType_Default)
    #Çå³ýCD
    ClearCDTime(curPlayer)
    tick = GameWorld.GetGameWorld().GetTick()
    #Ë¢ÐÂÌìÌݾº¼¼³¡×´Ì¬
    SendHighLadderState(curPlayer, tick)
    #֪ͨGameServer²éѯһ´Î½±ÀøÇé¿ö   
    sendMsg = '%s' % ([curPlayer.GetID(), 0, 0]) 
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, 'HighLadderReward',
                                                                  sendMsg, len(sendMsg))
    return

## //A5 35 ²éѯÌìÌݾº¼¼³¡½±Àø#tagCMQueryHighLadderReward
#  @param index, clientPack, tick
#  @return None
def OnQueryHighLadderReward(index, clientPack, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    hadGot = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_DayRewardGot, 0, ChConfig.Def_PDictType_Default)
    if clientPack.Type == 1 and hadGot:
        #Áì½±£¬ÒÑÁìÈ¡µÄÖ±½Ó·µ»Ø¿Í»§¶Ë
        return
    
    #֪ͨGameServer²éѯ»òÁìÈ¡½±Àø          
    sendMsg = '%s' % ([curPlayer.GetID(), clientPack.Type, hadGot]) 
    GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(curPlayer.GetID(), 0, 0, 'HighLadderReward',
                                                                  sendMsg, len(sendMsg))
## GameServer²éѯÌìÌݾº¼¼³¡½±ÀøÁìÈ¡½á¹û
#  @param curPlayer,order
#  @return None
def GameServer_GetHighLadderRewardResult(curPlayer, order):
    hadGot = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_DayRewardGot, 0, ChConfig.Def_PDictType_Default)
    if hadGot:
        return
    #¸ù¾Ý½±ÀøÀàÐ͸øÓè½±Àø
    result = GiveHighLadderReward(curPlayer, order)
    if result:
        #¼Ç¼ÒÑÁìÈ¡
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HighLadder_DayRewardGot, 1, ChConfig.Def_PDictType_Default)
    hadGot = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HighLadder_DayRewardGot, 0, ChConfig.Def_PDictType_Default)
    #֪ͨ¿Í»§¶Ë¸üн±ÀøÁìȡ״̬
    sendPack = ChPyNetSendPack.tagGCHighLadderRewardInfo()
    sendPack.hadGot = hadGot
    sendPack.Order = order
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

## ¸ù¾Ý½±ÀøÀàÐ͸øÓè½±Àø
#  @param curPlayer,order
#  @return None
def GiveHighLadderReward(curPlayer, order):
    HighLadderDayRewardDict = ReadChConfig.GetEvalChConfig("HighLadderDayReward")
    playerJob = curPlayer.GetJob()
    curJobReward = None
    for key in HighLadderDayRewardDict.keys():
        minOrder, maxOrder = key
        if order >= minOrder and order <= maxOrder:
            curRewardDict = HighLadderDayRewardDict.get(key, {})
            if curRewardDict == {}:
                GameWorld.DebugLog('HightLadder### GiveHighLadderReward order=%s no Reward' % order) 
                return False
            curJobReward = curRewardDict.get(playerJob, None)
            if curJobReward == None:
                GameWorld.DebugLog('HightLadder### GiveHighLadderReward order=%s  job = %s no Reward' % (\
                                                              order, playerJob))
                return False
            break
    if curJobReward == None:
        return False
    #»ý·Ö,½ð±Ò,¾­Ñé,ħ»ê,½±ÀøÕ¼±³°ü¸ñ×ÓÊý,[[ÊÇ·ñ¶¨ÖƱí,ID, ÊýÁ¿, ÊÇ·ñ°ó¶¨],[ÏÂÒ»¸ö½±Àø,...,...,...],...]
    rewardCurrency, rewardMoney, rewardExp, rewardMohun, needSpace, rewardList = curJobReward
    packSpaceCnt = max((ItemControler.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem)), \
                   ItemControler.GetItemPackSpace(curPlayer, IPY_GameWorld.rptAnyWhere))
    
    if needSpace > packSpaceCnt:
        #±³°ü¿Õ¼äÒÑÂú
        PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
        return False
    #»ý·Ö    
    PlayerControl.AddHighLadderCurrency(curPlayer, rewardCurrency)
    #¾­Ñé
    playerControl = PlayerControl.PlayerControl(curPlayer)
    playerControl.AddExp(rewardExp, isSysHint=True)
    #½ð±Ò
    addDataDict = {ChConfig.Def_Give_Reason_SonKey:"Reward"}
    PlayerControl.GiveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Silver_Money, rewardMoney, ChConfig.Def_GiveMoney_HighLadder, addDataDict)
    #ħ»ê
    PlayerControl.PlayerAddZhenQi(curPlayer, rewardMohun, True, True, "HighLadder")
    
    for index in xrange(len(rewardList)):
        itemType, itemID, itemCount, isBind = rewardList[index]
        #¸øÓèÎïÆ·        
        # Ò»°ãÎïÆ·
        if itemType == Def_ItemType_CommonItem:
            if not ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isBind, \
                                                 [IPY_GameWorld.rptItem, IPY_GameWorld.rptAnyWhere], True):
                continue
            #PlayerControl.NotifyCode(curPlayer, "ObtainRes01", [itemID, itemCount])
        # ÌØÊⶨÖÆÎïÆ·
        elif itemType == Def_ItemType_AppointItem:
            itemData = PyMapTable.GetPyMapTable("AppointItemList").GetRecord("ItemIndex", str(itemID))
            if not itemData:
                GameWorld.ErrLog("GiveHighLadderReward()itemType=%s,ItemIndex=%s not data" % (itemType, itemID))
                continue
            if len(itemData) != 1:
                GameWorld.ErrLog("GiveHighLadderReward()itemType=%s,ItemIndex=%s,recordCount=%s !=1 error" % \
                                                        (itemType, itemID, len(itemData)))
                continue
            
            itemDictData = itemData[0]
            itemDictData['IsBind'] = str(isBind)
            ItemControler.GivePlayerEquip(curPlayer, itemDictData, True)
            #PlayerControl.NotifyCode(curPlayer, "ObtainRes01", [int(itemDictData['ItemID']), itemCount])
    return True

## Íæ¼ÒµÇ¼֪ͨ
#  @param curPlayer
#  @return None
def OnLogin(curPlayer):
    tick = GameWorld.GetGameWorld().GetTick()
    SendHighLadderState(curPlayer, tick)
    return