#!/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]
|
|
|
|
