#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package Player.PlayerActGarbageSorting
|
#
|
# @todo:À¬»ø·ÖÀà»î¶¯
|
# @author hxp
|
# @date 2021-05-13
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: À¬»ø·ÖÀà»î¶¯
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2021-05-13 19:30"""
|
#-------------------------------------------------------------------------------
|
|
import PyGameData
|
import ShareDefine
|
import PlayerControl
|
import IpyGameDataPY
|
import ItemControler
|
import ChPyNetSendPack
|
import NetPackCommon
|
import GameWorld
|
import ChConfig
|
import ItemCommon
|
import PlayerBillboard
|
import QuestCommon
|
|
Def_SuperLibType = 9 # ´ó½±¿âÀàÐ͹̶¨Îª9
|
|
def OnPlayerLogin(curPlayer):
|
|
for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
|
actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
|
isReset = __CheckPlayerGarbageSortingAction(curPlayer, actNum)
|
if not isReset:
|
# »î¶¯ÖÐͬ²½»î¶¯ÐÅÏ¢
|
if actInfo.get(ShareDefine.ActKey_State):
|
Sync_GarbageSortingActionInfo(curPlayer, actNum)
|
Sync_GarbageSortingPlayerInfo(curPlayer, actNum)
|
Sync_GarbageTaskInfo(curPlayer, actNum)
|
return
|
|
def RefreshGarbageSortingActionInfo(actNum):
|
## ÊÕµ½GameServerͬ²½µÄ»î¶¯ÐÅÏ¢£¬Ë¢Ð»ÐÅÏ¢
|
playerManager = GameWorld.GetPlayerManager()
|
for index in xrange(playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(index)
|
if curPlayer.GetID() == 0:
|
continue
|
__CheckPlayerGarbageSortingAction(curPlayer, actNum)
|
return
|
|
def __CheckPlayerGarbageSortingAction(curPlayer, actNum):
|
## ¼ì²éÍæ¼Ò»î¶¯Êý¾ÝÐÅÏ¢
|
|
playerID = curPlayer.GetPlayerID()
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
actID = actInfo.get(ShareDefine.ActKey_ID, 0)
|
state = actInfo.get(ShareDefine.ActKey_State, 0)
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
|
|
playerActID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageSortingID % actNum) # Íæ¼ÒÉíÉϵĻID
|
|
# »î¶¯ID ÏàͬµÄ»°²»´¦Àí
|
if actID == playerActID:
|
GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ID²»±ä£¬²»´¦Àí£¡actNum=%s,actID=%s" % (actNum, actID), playerID)
|
return
|
|
actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
|
|
GameWorld.DebugLog("À¬»ø·ÖÀàÖØÖÃ! actNum=%s,actID=%s,playerActID=%s,state=%s,cfgID=%s"
|
% (actNum, actID, playerActID, state, cfgID), playerID)
|
|
guideTaskID = IpyGameDataPY.GetFuncCfg("GarbageSorting", 1)
|
if guideTaskID:
|
if state:
|
curMission = QuestCommon.AddNewMission(curPlayer, guideTaskID)
|
if curMission:
|
QuestCommon.SetPlayerMissionState(curPlayer, curMission, 1)
|
else:
|
QuestCommon.DeleteMission(curPlayer, guideTaskID)
|
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageSortingID % actNum, actID)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageSortingWorldLV % actNum, actWorldLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageGuideState % actNum, 0)
|
for taskID in ChConfig.GarbageTaskList:
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID), 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID), 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValue % actNum, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValueHis % actNum, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum, 0)
|
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID) if cfgID else None
|
templateID = ipyData.GetTemplateID() if ipyData else 0
|
awardIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActGarbageAward", templateID) if templateID else []
|
if awardIpyDataList:
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
libItemCount = awardIpyData.GetAwardItemCount()
|
for num in xrange(libItemCount):
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num), 0)
|
|
itemAwardTimesTotalInfo = awardIpyData.GetItemAwardTimesTotalInfo()
|
for itemID in itemAwardTimesTotalInfo.keys():
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, itemID), 0)
|
|
# »î¶¯ÖУ¬Éú³Éн±³Ø
|
if state:
|
__RefreshGarbageAwardPool(curPlayer, actInfo, awardIpyDataList)
|
|
Sync_GarbageSortingActionInfo(curPlayer, actNum)
|
Sync_GarbageSortingPlayerInfo(curPlayer, actNum)
|
Sync_GarbageTaskInfo(curPlayer, actNum)
|
return True
|
|
def OnFinishTask(curPlayer, taskID):
|
guideTaskID = IpyGameDataPY.GetFuncCfg("GarbageSorting", 1)
|
if not guideTaskID:
|
return
|
|
if taskID != guideTaskID:
|
return
|
|
for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
|
if not actInfo.get(ShareDefine.ActKey_State):
|
continue
|
actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageGuideState % actNum, 1)
|
Sync_GarbageSortingPlayerInfo(curPlayer, actNum)
|
|
return
|
|
def AddActGarbageTaskProgress(curPlayer, taskID, addValue=1, valueInfo=None):
|
## Ôö¼ÓÀ¬»øÊÕ¼¯ÈÎÎñ½ø¶È
|
# @param valueInfo: taskID ¶ÔÓ¦µÄ×Ô¶¨ÒåÀ©Õ¹ÐÅÏ¢Öµ
|
if addValue <= 0:
|
return
|
|
for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
|
actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
#GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯Î´¿ªÆô! actNum=%s" % actNum)
|
continue
|
|
if taskID == ChConfig.Def_GarbageTask_CTG:
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
|
if not cfgID:
|
continue
|
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
continue
|
|
coinType = valueInfo
|
ctgTypeEffValue = ipyData.GetCTGTypeEffValue()
|
if not ctgTypeEffValue & pow(2, coinType):
|
#GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯³äÖµÀàÐͶԸûÎÞЧ! actNum=%s,coinType=%s,ctgTypeEffValue=%s"
|
# % (actNum, coinType, ctgTypeEffValue), curPlayer.GetPlayerID())
|
continue
|
|
taskIpyData = IpyGameDataPY.GetIpyGameData("ActGarbageTask", taskID)
|
if not taskIpyData:
|
continue
|
maxFinishCount = taskIpyData.GetFinishTimeMax()
|
maxValue = ChConfig.Def_UpperLimit_DWord
|
if maxFinishCount:
|
maxValue = min(maxValue, taskIpyData.GetFinishNeedValue() * maxFinishCount)
|
|
curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
|
updValue = min(curValue + addValue, maxValue)
|
if curValue >= maxValue:
|
#GameWorld.DebugLog("¸ÃÀ¬»ø·ÖÀà»î¶¯ÈÎÎñÒÑ´ïµ½×î´ó½ø¶ÈÖµ!actNum=%s,taskID=%s,curValue(%s) >= maxValue(%s)"
|
# % (actNum, taskID, curValue, maxValue))
|
continue
|
|
#GameWorld.DebugLog("Ôö¼ÓÀ¬»ø·ÖÀà»î¶¯ÈÎÎñ½ø¶È: actNum=%s,taskID=%s,curValue=%s,addValue=%s,updValue=%s"
|
# % (actNum, taskID, curValue, addValue, updValue))
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID), updValue)
|
|
# Íê³Éʱ×Ô¶¯²úÉúÀ¬»ø
|
if taskIpyData.GetAutoProduce():
|
if __DoCheckFinishGarbageTask(curPlayer, actNum, taskID, taskIpyData):
|
continue
|
|
Sync_GarbageTaskInfo(curPlayer, actNum, taskID)
|
|
return
|
|
def __DoCheckFinishGarbageTask(curPlayer, actNum, taskID, taskIpyData=None):
|
## ¼ì²éÍê³ÉÀ¬»øÊÕ¼¯ÈÎÎñ
|
|
if not taskIpyData:
|
taskIpyData = IpyGameDataPY.GetIpyGameData("ActGarbageTask", taskID)
|
if not taskIpyData:
|
return
|
curFinishCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID))
|
maxFinishCount = taskIpyData.GetFinishTimeMax()
|
if maxFinishCount and curFinishCount >= maxFinishCount:
|
GameWorld.DebugLog("¸ÃÀ¬»ø·ÖÀà»î¶¯ÈÎÎñÒÑ´ïµ½×î´óÍê³É´ÎÊý!actNum=%s,taskID=%s,curFinishCount=%s" % (actNum, taskID, curFinishCount))
|
return
|
|
curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
|
updFinishCount = curValue / taskIpyData.GetFinishNeedValue()
|
if maxFinishCount:
|
updFinishCount = min(maxFinishCount, updFinishCount)
|
addFinishCount = updFinishCount - curFinishCount
|
if addFinishCount <= 0:
|
#GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ÈÎÎñδÍê³É£¬ÎÞ·¨ÁìÈ¡!actNum=%s,taskID=%s,curValue=%s,curFinishCount=%s,updFinishCount=%s"
|
# % (actNum, taskID, curValue, curFinishCount, updFinishCount))
|
return
|
|
#GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ÈÎÎñÍê³É£¬¸ø½±Àø! actNum=%s,taskID=%s,curValue=%s,curFinishCount=%s,addFinishCount=%s,updFinishCount=%s"
|
# % (actNum, taskID, curValue, curFinishCount, addFinishCount, updFinishCount))
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID), updFinishCount)
|
|
# ¸øÀ¬»øÊÕ¼¯½±Àø
|
giveItemDict = {}
|
rateList = taskIpyData.GetProduceGarbageRateList()
|
for _ in xrange(addFinishCount):
|
itemInfo = GameWorld.GetResultByRandomList(rateList)
|
if not itemInfo:
|
continue
|
itemID, itemCount, isAuctionItem = itemInfo
|
befItemCount = giveItemDict[itemID][1] if itemID in giveItemDict else 0
|
giveItemDict[itemID] = [itemID, befItemCount + itemCount, isAuctionItem]
|
giveItemList = giveItemDict.values()
|
|
ItemControler.GivePlayerItemOrMail(curPlayer, giveItemList)
|
|
Sync_GarbageTaskInfo(curPlayer, actNum, taskID, giveItemList)
|
return True
|
|
#// AA 14 À¬»ø·ÖÀà»î¶¯·ÖÀàÀ¬»ø #tagCMActGarbageSorting
|
#
|
#struct tagCMActGarbageSorting
|
#{
|
# tagHead Head;
|
# BYTE ActNum; //»î¶¯±àºÅ
|
# BYTE GarbageSortingType; //À¬»ø·ÖÀàÀàÐÍ£¬¼´ÊôÓÚÄÄÖÖÀ¬»ø
|
# BYTE ItemIndexCount; //À¬»ø±³°üÖеÄÎïÆ·Ë÷ÒýÊý
|
# BYTE ItemIndexList[ItemIndexCount]; //À¬»ø±³°üÖеÄÎïÆ·Ë÷ÒýÁбí
|
#};
|
def OnActGarbageSorting(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
actNum = clientData.ActNum
|
sortingType = clientData.GarbageSortingType
|
itemIndexList = clientData.ItemIndexList
|
|
playerID = curPlayer.GetPlayerID()
|
|
GameWorld.DebugLog("À¬»ø·ÖÀàͶ·Å: sortingType=%s,itemIndexList=%s" % (sortingType, itemIndexList), playerID)
|
|
environmentValueInfo = IpyGameDataPY.GetFuncEvalCfg("GarbageSorting", 2)
|
addEnvValueTotal = 0
|
garbagePack = curPlayer.GetItemManager().GetPack(ShareDefine.rptGarbage)
|
for index in itemIndexList:
|
if index >= garbagePack.GetCount():
|
continue
|
curItem = garbagePack.GetAt(index)
|
if not ItemCommon.CheckItemCanUse(curItem):
|
continue
|
itemID = curItem.GetItemTypeID()
|
itemSortingType = curItem.GetEffectByIndex(0).GetEffectValue(0)
|
if sortingType == itemSortingType:
|
delCount = curItem.GetCount()
|
addEnvValue = environmentValueInfo[0] * delCount
|
PlayerControl.NotifyCode(curPlayer, "GarbageSortingRight", [addEnvValue])
|
else:
|
delCount = 1 # ´íÎóÖ»¿Û³ý1Ò»¸ö
|
addEnvValue = environmentValueInfo[1] * delCount
|
PlayerControl.NotifyCode(curPlayer, "GarbageSortingWrong", [addEnvValue])
|
|
ItemControler.SetItemCount(curItem, max(0, curItem.GetCount() - delCount))
|
addEnvValueTotal += addEnvValue
|
GameWorld.DebugLog(" index=%s,itemID=%s,itemSortingType=%s,delCount=%s,addEnvValue=%s"
|
% (index, itemID, itemSortingType, delCount, addEnvValue), playerID)
|
|
if not addEnvValueTotal:
|
return
|
|
curEnvValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValue % actNum) + addEnvValueTotal
|
hisEnvValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValueHis % actNum) + addEnvValueTotal
|
|
GameWorld.DebugLog(" addEnvValueTotal=%s,curEnvValue=%s,hisEnvValue=%s" % (addEnvValueTotal, curEnvValue, hisEnvValue), playerID)
|
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValue % actNum, curEnvValue)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValueHis % actNum, hisEnvValue)
|
|
PlayerBillboard.UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_Environment, hisEnvValue)
|
|
Sync_GarbageSortingPlayerInfo(curPlayer, actNum)
|
return
|
|
|
#// AA 15 À¬»ø·ÖÀà»î¶¯ÊÕ¼¯ÒÑÍê³ÉµÄÈÎÎñÀ¬»ø #tagCMActGarbageGetTaskAward
|
#
|
#struct tagCMActGarbageGetTaskAward
|
#{
|
# tagHead Head;
|
# BYTE ActNum; //»î¶¯±àºÅ
|
# BYTE GarbageTaskID; //À¬»øÈÎÎñID
|
#};
|
def OnActGarbageGetTaskAward(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
actNum = clientData.ActNum
|
taskID = clientData.GarbageTaskID
|
__DoCheckFinishGarbageTask(curPlayer, actNum, taskID)
|
return
|
|
|
#// AA 16 À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½± #tagCMActGarbageChooseSuperItem
|
#
|
#struct tagCMActGarbageChooseSuperItem
|
#{
|
# tagHead Head;
|
# BYTE ActNum; //»î¶¯±àºÅ
|
# BYTE SuperItemCount; //Ñ¡ÔñÎïÆ·ÊýÁ¿
|
# DWORD SuperItemIDList[SuperItemCount]; //Ñ¡ÔñµÄ´ó½±¿âÎïÆ·IDÁÐ±í£¬Ã¿´ÎÖØÐÂÑ¡ÔñÐèÒª·¢ËÍÈ«²¿ÒÑÑ¡ÔñµÄ´ó½±ÎïÆ·ID£¬²»ÄÜÖ»·¢µ¥¸öÎïÆ·ID;
|
#};
|
def OnActGarbageChooseSuperItem(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
actNum = clientData.ActNum
|
superItemIDList = clientData.SuperItemIDList
|
|
GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±: actNum=%s,superItemIDList=%s" % (actNum, superItemIDList))
|
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
return
|
|
templateID = ipyData.GetTemplateID()
|
if not templateID:
|
return
|
|
actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
|
awardIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActGarbageAward", templateID)
|
if not awardIpyDataList:
|
return
|
|
superAwardIpyData = None
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
if libType == Def_SuperLibType:
|
superAwardIpyData = awardIpyData
|
break
|
|
if not superAwardIpyData:
|
GameWorld.ErrLog("ûÓÐÅäÖÃÀ¬»ø·ÖÀà»î¶¯´ó½±¿â! cfgID=%s,actNum=%s,templateID=%s" % (cfgID, actNum, templateID))
|
return
|
|
superLibItemCount = superAwardIpyData.GetAwardItemCount()
|
if len(superItemIDList) != superLibItemCount:
|
GameWorld.ErrLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±¸öÊý´íÎó! cfgID=%s,actNum=%s,templateID=%s,superLibItemCount=%s,reqSuperItemIDList=%s"
|
% (cfgID, actNum, templateID, superLibItemCount, superItemIDList))
|
return
|
|
posNumItemIDList = [] # ÒѳéÖеĴó½±ÎïÆ·ID
|
libType = superAwardIpyData.GetAwardLibType()
|
for num in xrange(superLibItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
if not itemInfoValue:
|
break
|
itemID, posNum = itemInfoValue / 100, itemInfoValue % 100
|
if posNum and itemID not in superItemIDList:
|
GameWorld.ErrLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±ID´íÎó! ÒѳéÖеĴó½±IDΪ±ØÑ¡ID£¡ posNum=%s, itemID=%s not in superItemIDList=%s"
|
% (posNum, itemID, superItemIDList))
|
return
|
|
if posNum:
|
posNumItemIDList.append(itemID)
|
|
GameWorld.DebugLog(" ÒѳéÖеĴó½±ID! %s" % posNumItemIDList)
|
|
layerInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum)
|
layerNum = layerInfoValue % 100
|
|
libItemDict = __GetGarbageAwardLibItem(superAwardIpyData.GetLibItemInfo(), actWorldLV)
|
layerLimitInfo = superAwardIpyData.GetItemLayerLimitInfo()
|
awardTimesTotalInfo = superAwardIpyData.GetItemAwardTimesTotalInfo()
|
|
replaceSuperItemIDList = [] # ÐèÒªÌæ»»µÄ´ó½±IDÁбí
|
|
for selectItemID in superItemIDList:
|
if selectItemID in posNumItemIDList:
|
GameWorld.DebugLog(" ÒѳéÖеĴó½±ID£¬²»ÑéÖ¤£¡selectItemID=%s" % (selectItemID))
|
continue
|
|
if selectItemID not in libItemDict:
|
GameWorld.ErrLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±ID´íÎó! ´ó½±ID²»´æÔڴ󽱿âÖУ¡ selectItemID=%s not in libItemDict=%s"
|
% (selectItemID, libItemDict))
|
return
|
|
layerLimit = layerLimitInfo.get(selectItemID, 0)
|
if layerLimit > layerNum:
|
GameWorld.ErrLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±ID´íÎó! ´ó½±ID¸Ã²ã²»ÄÜÑ¡Ôñ£¡ selectItemID=%s layerLimit(%s) > layerNum(%s)"
|
% (selectItemID, layerLimit, layerNum))
|
return
|
|
totalTimesLimit = awardTimesTotalInfo.get(selectItemID, 0)
|
if totalTimesLimit:
|
totalTimesNow = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, selectItemID))
|
if totalTimesNow >= totalTimesLimit:
|
GameWorld.ErrLog("À¬»ø·ÖÀà»î¶¯Ñ¡Ôñ´ó½±ID´íÎó! ´ó½±IDÒÑ´ïµ½×î´ó½±Àø´ÎÊý£¬²»ÄÜÑ¡Ôñ£¡ selectItemID=%s totalTimesNow(%s) >= totalTimesLimit(%s)"
|
% (selectItemID, totalTimesNow, totalTimesLimit))
|
return
|
|
replaceSuperItemIDList.append(selectItemID)
|
|
GameWorld.DebugLog(" Ñé֤ͨ¹ý£¬¿ÉÌæ»»´ó½±ID! replaceSuperItemIDList=%s" % replaceSuperItemIDList)
|
if not replaceSuperItemIDList:
|
return
|
|
for num in xrange(superLibItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
itemID, posNum = itemInfoValue / 100, itemInfoValue % 100
|
if itemID in posNumItemIDList:
|
GameWorld.DebugLog(" ÒѳéÖеĴó½±ID£¬²»Ìæ»»£¡itemID=%s" % (itemID))
|
continue
|
replaceSuperItemID = replaceSuperItemIDList.pop(0)
|
updItemInfoValue = replaceSuperItemID * 100 + posNum
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num), updItemInfoValue)
|
GameWorld.DebugLog(" Ìæ»»´ó½±IDÑ¡Ôñ£¡num=%s,itemID=%s,posNum=%s,replaceSuperItemID=%s,updItemInfoValue=%s"
|
% (num, itemID, posNum, replaceSuperItemID, updItemInfoValue))
|
|
if not replaceSuperItemIDList:
|
break
|
|
Sync_GarbageSortingActionInfo(curPlayer, actNum)
|
return
|
|
#// AA 18 À¬»ø·ÖÀà»î¶¯½±³ØˢР#tagCMGarbageAwardPoolRefresh
|
#
|
#struct tagCMGarbageAwardPoolRefresh
|
#{
|
# tagHead Head;
|
# BYTE ActNum; //»î¶¯±àºÅ
|
#};
|
def OnActGarbageAwardPoolRefresh(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
actNum = clientData.ActNum
|
|
GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯½±³ØË¢ÐÂ: actNum=%s" % (actNum))
|
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
return
|
|
templateID = ipyData.GetTemplateID()
|
if not templateID:
|
return
|
|
awardIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActGarbageAward", templateID)
|
if not awardIpyDataList:
|
return
|
|
if not __RefreshGarbageAwardPool(curPlayer, actInfo, awardIpyDataList):
|
return
|
|
Sync_GarbageSortingActionInfo(curPlayer, actNum)
|
return
|
|
def __RefreshGarbageAwardPool(curPlayer, actInfo, awardIpyDataList):
|
## Ë¢ÐÂÀ¬»øÊÕ¼¯»·±£½±³ØÎïÆ·
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
|
actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
|
|
layerInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum)
|
layerNum = layerInfoValue % 100
|
|
GameWorld.DebugLog("Ë¢ÐÂÀ¬»øÊÕ¼¯»·±£½±³ØÎïÆ·: cfgID=%s,actNum=%s,actWorldLV=%s,layerNum=%s" % (cfgID, actNum, actWorldLV, layerNum))
|
|
if layerNum:
|
# ·Ç0²ã£¬ÑéÖ¤´ó½±ÊÇ·ñÒѳéÍ꣬³éÍê²Å¿ÉÒÔˢн±³Ø²ã
|
superLib = False
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
if libType != Def_SuperLibType:
|
continue
|
superLib = True
|
libItemCount = awardIpyData.GetAwardItemCount()
|
for num in xrange(libItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
itemID, posNum = itemInfoValue / 100, itemInfoValue % 100
|
if itemID and not posNum:
|
GameWorld.ErrLog("Óдó½±Î´³éÖУ¡ÎÞ·¨Ë¢Ð»·±£½±³Ø! cfgID=%s,actNum=%s,layerNum=%s,num=%s,itemID=%s,posNum=%s"
|
% (cfgID, actNum, layerNum, num, itemID, posNum))
|
return
|
break
|
if not superLib:
|
GameWorld.ErrLog("½±³ØÅäÖÃûÓд󽱿⣡ÎÞ·¨Ë¢Ð»·±£½±³Ø! cfgID=%s,actNum=%s,layerNum=%s,superLib=%s" % (cfgID, actNum, layerNum, superLib))
|
return
|
|
layerNum += 1 # ¿Éˢн±³Ø£¬Ä¬ÈÏ+1²ã
|
GameWorld.DebugLog(" ¿Éˢн±³Ø£¡ÏÂÒ»²ã: layerNum=%s" % (layerNum))
|
|
refreshLibDict = {}
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
libItemCount = awardIpyData.GetAwardItemCount()
|
libItemDict = __GetGarbageAwardLibItem(awardIpyData.GetLibItemInfo(), actWorldLV)
|
layerLimitInfo = awardIpyData.GetItemLayerLimitInfo()
|
awardTimesTotalInfo = awardIpyData.GetItemAwardTimesTotalInfo()
|
|
canRandItemDict = {}
|
for itemID, libItemInfo in libItemDict.items():
|
_, weight = libItemInfo
|
|
layerLimit = layerLimitInfo.get(itemID, 0)
|
if layerLimit > layerNum:
|
GameWorld.DebugLog(" ¸Ã²ã²»ÄÜÑ¡Ôñ¸Ã½±Æ·£¡ itemID=%s layerLimit(%s) > layerNum(%s)"
|
% (itemID, layerLimit, layerNum))
|
continue
|
|
totalTimesLimit = awardTimesTotalInfo.get(itemID, 0)
|
if totalTimesLimit:
|
totalTimesNow = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, itemID))
|
if totalTimesNow >= totalTimesLimit:
|
GameWorld.DebugLog(" ½±Æ·IDÒÑ´ïµ½×î´ó½±Àø´ÎÊý£¬²»ÄÜÑ¡Ôñ£¡ itemID=%s totalTimesNow(%s) >= totalTimesLimit(%s)"
|
% (itemID, totalTimesNow, totalTimesLimit))
|
continue
|
|
canRandItemDict[itemID] = [weight, itemID]
|
|
if libItemCount > len(canRandItemDict):
|
GameWorld.ErrLog("½±Æ·¿âÅäÖÿÉÑ¡Ôñ½±Æ·¸öÊý²»¹»£¡ÎÞ·¨Ë¢Ð»·±£½±³Ø! cfgID=%s,actNum=%s,libType=%s,layerNum=%s,libItemCount=%s > %s canRandItemDict(%s)"
|
% (cfgID, actNum, libType, layerNum, libItemCount, len(canRandItemDict), canRandItemDict))
|
return
|
|
refreshLibDict[libType] = [libItemCount, canRandItemDict]
|
|
for libType, refreshInfo in refreshLibDict.items():
|
libItemCount, canRandItemDict = refreshInfo
|
GameWorld.DebugLog(" Ëæ»ú½±³ØÎïÆ·: libType=%s,libItemCount=%s,canRandItemDict=%s, %s" % (libType, libItemCount, len(canRandItemDict), canRandItemDict))
|
|
if libType == Def_SuperLibType:
|
# ´ó½±Ö±½ÓÖØÖã¬ÏµÍ³²»Éú³É£¬ÓÉÍæ¼ÒÊÖ¶¯Ñ¡Ôñ
|
for num in xrange(libItemCount):
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num), 0)
|
continue
|
|
for num in xrange(libItemCount):
|
weightList = canRandItemDict.values()
|
randItemID = GameWorld.GetResultByWeightList(weightList)
|
canRandItemDict.pop(randItemID, None)
|
|
posNum = 0
|
itemInfoValue = randItemID * 100 + posNum
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num), itemInfoValue)
|
GameWorld.DebugLog(" Ëæ»úÉú³É½±Æ·! libType=%s,num=%s,randItemID=%s" % (libType, num, randItemID))
|
|
playCount = 0 # ÿ²ãÖØÖó齱´ÎÊý
|
layerInfoValue = playCount * 100 + layerNum
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum, layerInfoValue)
|
GameWorld.DebugLog(" Ë¢ÐÂÍê³É! playCount=%s,layerNum=%s,layerInfoValue=%s" % (playCount, layerNum, layerInfoValue))
|
return True
|
|
#// AA 17 À¬»ø·ÖÀà»î¶¯³é½± #tagCMActGarbageLottery
|
#
|
#struct tagCMActGarbageLottery
|
#{
|
# tagHead Head;
|
# BYTE ActNum; //»î¶¯±àºÅ
|
# BYTE PosNum; //Íæ¼Òµã»÷µÄ½±ÀøλÖñàºÅ£¬´Ó1¿ªÊ¼
|
#};
|
def OnActGarbageLottery(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
actNum = clientData.ActNum
|
reqPosNum = clientData.PosNum
|
|
GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯³é½±: actNum=%s,reqPosNum=%s" % (actNum, reqPosNum))
|
|
if reqPosNum <= 0:
|
return
|
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
return
|
|
templateID = ipyData.GetTemplateID()
|
if not templateID:
|
return
|
|
actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
|
awardIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActGarbageAward", templateID)
|
if not awardIpyDataList:
|
return
|
|
costEnvValue = IpyGameDataPY.GetFuncCfg("GarbageSorting", 3)
|
curEnvValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValue % actNum)
|
if curEnvValue < costEnvValue:
|
GameWorld.DebugLog(" »·±£Öµ²»×㣬ÎÞ·¨³é½±! curEnvValue(%s) < costEnvValue(%s)" % (curEnvValue, costEnvValue))
|
return
|
|
layerInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum)
|
playCount, layerNum = layerInfoValue / 100, layerInfoValue % 100
|
|
posNumMax = 0
|
randLibItemDict = {}
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
libItemCount = awardIpyData.GetAwardItemCount()
|
unlockLimitTimes = awardIpyData.GetUnlockAwardLimitTimes()
|
libWeight = awardIpyData.GetAwardLibWeight()
|
posNumMax += libItemCount
|
|
if libType == Def_SuperLibType:
|
for num in xrange(libItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
if not itemInfoValue:
|
GameWorld.DebugLog(" δѡÔñ´ó½±£¡ÎÞ·¨³é½±! libType=%s,num=%s,itemInfoValue=%s" % (libType, num, itemInfoValue))
|
return
|
|
if unlockLimitTimes and playCount < unlockLimitTimes:
|
GameWorld.DebugLog(" ¸Ã¿âµ±Ç°³é½±´ÎÊýÎÞ·¨½âËø! libType=%s,playCount(%s) < unlockLimitTimes(%s)" % (libType, playCount, unlockLimitTimes))
|
continue
|
|
awardTimesTotalInfo = awardIpyData.GetItemAwardTimesTotalInfo()
|
libItemDict = __GetGarbageAwardLibItem(awardIpyData.GetLibItemInfo(), actWorldLV)
|
canRandItemList = []
|
for num in xrange(libItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
if not itemInfoValue:
|
return
|
|
itemID, posNum = itemInfoValue / 100, itemInfoValue % 100
|
if itemID not in libItemDict:
|
continue
|
|
if posNum:
|
GameWorld.DebugLog(" ¸Ã½±Æ·Òѱ»³éÖÐ! libType=%s,itemID=%s,posNum=%s" % (libType, itemID, posNum))
|
if posNum == reqPosNum:
|
GameWorld.ErrLog(" ¸ÃλÖÃÒѾÓг齱½á¹û£¬ÎÞ·¨Öظ´Ñ¡Ôñ³é½±! libType=%s,num=%s,itemInfoValue=%s,posNum=%s"
|
% (libType, num, itemInfoValue, posNum))
|
return
|
continue
|
|
itemCount, weight = libItemDict[itemID]
|
isAddTimes = (itemID in awardTimesTotalInfo)
|
canRandItemList.append([weight, itemID, itemCount, num, isAddTimes])
|
|
if canRandItemList:
|
randLibItemDict[libType] = [libWeight, libType, canRandItemList]
|
GameWorld.DebugLog(" ¸Ã¿âÓлú»á³éµ½ÎïÆ·: libType=%s,libWeight=%s,canRandItemList=%s" % (libType, libWeight, canRandItemList))
|
else:
|
GameWorld.DebugLog(" ¸Ã¿âÎïÆ·ÒÑÈ«±»³éÍê: libType=%s,libWeight=%s,canRandItemList=%s" % (libType, libWeight, canRandItemList))
|
|
if reqPosNum > posNumMax:
|
GameWorld.DebugLog(" ÇëÇóλÖÃÒì³££¬ÎÞ·¨³é½±! reqPosNum(%s) > posNumMax(%s)" % (reqPosNum, posNumMax))
|
return
|
|
if not randLibItemDict:
|
GameWorld.DebugLog(" ûÓпɳ齱µÄ½±Æ·ÁË£¬ÎÞ·¨³é½±!")
|
return
|
|
randLibInfo = GameWorld.GetResultByWeightList(randLibItemDict.values())
|
if not randLibInfo:
|
return
|
libType, canRandItemList = randLibInfo
|
randItemInfo = GameWorld.GetResultByWeightList(canRandItemList)
|
if not randItemInfo:
|
return
|
itemID, itemCount, num, isAddTimes = randItemInfo
|
|
# ¿Û³ý³é½±ÏûºÄ»·±£Öµ
|
updEnvValue = curEnvValue - costEnvValue
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValue % actNum, updEnvValue)
|
|
# ¸üÐÂÒѳéÖÐÖµ
|
updItemInfoValue = itemID * 100 + reqPosNum
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num), updItemInfoValue)
|
|
totalTimesNow = 0
|
if isAddTimes:
|
totalTimesNow = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, itemID)) + 1
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, itemID), totalTimesNow)
|
|
playCount += 1
|
layerInfoValue = playCount * 100 + layerNum
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum, layerInfoValue)
|
|
GameWorld.DebugLog(" ³éÖÐÎïÆ·: layerNum=%s,libType=%s,itemID=%s,itemCount=%s,num=%s,reqPosNum=%s,updItemInfoValue=%s,totalTimesNow=%s,updEnvValue=%s,playCount=%s(%s)"
|
% (layerNum, libType, itemID, itemCount, num, reqPosNum, updItemInfoValue, totalTimesNow, updEnvValue, playCount, layerInfoValue))
|
|
# ¸øÎïÆ·
|
isAuctionItem = 0
|
itemList = [[itemID, itemCount, isAuctionItem]]
|
ItemControler.GivePlayerItemOrMail(curPlayer, itemList, event=["ActGarbageLottery", False, {}])
|
|
# ¹ã²¥
|
if libType == Def_SuperLibType:
|
PlayerControl.WorldNotify(0, "GarbageSorting%s" % actNum, [curPlayer.GetPlayerName(), itemID, itemCount])
|
|
# ֪ͨ
|
awardItemInfo = [libType, itemID, itemCount, reqPosNum, totalTimesNow]
|
Sync_GarbageSortingPlayerInfo(curPlayer, actNum, awardItemInfo)
|
return
|
|
def Sync_GarbageTaskInfo(curPlayer, actNum, taskID=0, awardItemList=None):
|
## ֪ͨÀ¬»øÊÕ¼¯ÈÎÎñÐÅÏ¢
|
syncTaskIDList = [taskID] if taskID else ChConfig.GarbageTaskList
|
clientPack = ChPyNetSendPack.tagMCActGarbageTaskInfo()
|
clientPack.ActNum = actNum
|
clientPack.GarbageTaskList = []
|
for taskID in syncTaskIDList:
|
task = ChPyNetSendPack.tagMCActGarbageTask()
|
task.GarbageTaskID = taskID
|
task.GarbageTaskValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
|
task.GarbageTaskFinishCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID))
|
clientPack.GarbageTaskList.append(task)
|
clientPack.GarbageTaskCount = len(clientPack.GarbageTaskList)
|
|
if awardItemList:
|
for itemID, itemCount, _ in awardItemList:
|
item = ChPyNetSendPack.tagMCActGarbageTaskItem()
|
item.ItemID = itemID
|
item.ItemCount = itemCount
|
clientPack.GarbageTaskItemList.append(item)
|
clientPack.TaskItemCount = len(clientPack.GarbageTaskItemList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def Sync_GarbageSortingPlayerInfo(curPlayer, actNum, awardItemInfo=None):
|
## ֪ͨÍæ¼ÒÊý¾ÝÐÅÏ¢
|
# @param awardItemInfo: ³é½±ÎïÆ·ÐÅÏ¢ [libType, itemID, itemCount, posNum, totalTimesNow]
|
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
return
|
|
guideTaskID = IpyGameDataPY.GetFuncCfg("GarbageSorting", 1)
|
|
clientPack = ChPyNetSendPack.tagMCActGarbagePlayerInfo()
|
clientPack.ActNum = actNum
|
clientPack.GuideTaskFinish = 1 if not guideTaskID else curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageGuideState % actNum)
|
clientPack.EnvironmentValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValue % actNum)
|
clientPack.EnvironmentValueHis = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValueHis % actNum)
|
|
if awardItemInfo:
|
libType, itemID, itemCount, posNum, totalTimesNow = awardItemInfo
|
awardItem = ChPyNetSendPack.tagMCActGarbageAwardItemResult()
|
awardItem.ItemLibType = libType
|
awardItem.ItemID = itemID
|
awardItem.ItemCount = itemCount
|
awardItem.PosNum = posNum
|
awardItem.TotalTimesNow = totalTimesNow
|
clientPack.AwardItemResult = awardItem
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def Sync_GarbageSortingActionInfo(curPlayer, actNum):
|
## ֪ͨ»î¶¯ÐÅÏ¢
|
|
actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
|
if not actInfo.get(ShareDefine.ActKey_State):
|
return
|
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
|
ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
|
if not ipyData:
|
return
|
|
templateID = ipyData.GetTemplateID()
|
if not templateID:
|
return
|
|
actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
|
openServerDay = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_ServerDay) + 1
|
|
layerInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardLayerInfo % actNum)
|
layerNum = layerInfoValue % 100
|
|
clientPack = ChPyNetSendPack.tagMCActGarbageSortingInfo()
|
clientPack.ActNum = actNum
|
clientPack.StartDate = GameWorld.GetOperationActionDateStr(ipyData.GetStartDate(), openServerDay)
|
clientPack.EndtDate = GameWorld.GetOperationActionDateStr(ipyData.GetEndDate(), openServerDay)
|
clientPack.LimitLV = ipyData.GetLVLimit()
|
clientPack.LayerNum = layerNum
|
clientPack.AwardItemList = [] # ½±³ØÎïÆ·Áбí
|
awardIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActGarbageAward", templateID)
|
if awardIpyDataList:
|
for awardIpyData in awardIpyDataList:
|
libType = awardIpyData.GetAwardLibType()
|
libItemCount = awardIpyData.GetAwardItemCount()
|
libItemDict = __GetGarbageAwardLibItem(awardIpyData.GetLibItemInfo(), actWorldLV)
|
layerLimitInfo = awardIpyData.GetItemLayerLimitInfo()
|
awardTimesTotalInfo = awardIpyData.GetItemAwardTimesTotalInfo()
|
|
# ½±³ØÎïÆ·ÁÐ±í£¬ÒÑÉú³ÉµÄ£¬°üº¬ÒÑÑ¡ÔñµÄ´ó½±ÎïÆ·
|
for num in xrange(libItemCount):
|
itemInfoValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemInfo % (actNum, libType, num))
|
if not itemInfoValue:
|
break
|
itemID, posNum = itemInfoValue / 100, itemInfoValue % 100
|
if itemID not in libItemDict:
|
continue
|
libItemInfo = libItemDict[itemID]
|
|
awardItem = ChPyNetSendPack.tagMCActGarbageAwardItem()
|
awardItem.ItemLibType = libType
|
awardItem.ItemID = itemID
|
awardItem.ItemCount = libItemInfo[0]
|
awardItem.PosNum = posNum
|
awardItem.TotalTimesMax = awardTimesTotalInfo.get(itemID, 0)
|
awardItem.TotalTimesNow = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageAwardItemTimes % (actNum, libType, itemID))
|
awardItem.LayerLimit = layerLimitInfo.get(itemID, 0)
|
clientPack.AwardItemList.append(awardItem)
|
|
# ´ó½±ÎïÆ·´ýÑ¡Ôñ¿â£¬È«²¿Í¬²½
|
if libType == Def_SuperLibType:
|
for itemID, libItemInfo in libItemDict.items():
|
awardItem = ChPyNetSendPack.tagMCActGarbageAwardItem()
|
awardItem.ItemLibType = libType
|
awardItem.ItemID = itemID
|
awardItem.ItemCount = libItemInfo[0]
|
awardItem.TotalTimesMax = awardTimesTotalInfo.get(itemID, 0)
|
awardItem.LayerLimit = layerLimitInfo.get(itemID, 0)
|
clientPack.SuperItemList.append(awardItem)
|
clientPack.SuperItemCount = len(clientPack.SuperItemList)
|
clientPack.SuperItemCanChooseCount = libItemCount
|
|
clientPack.AwardItemCount = len(clientPack.AwardItemList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def __GetGarbageAwardLibItem(libItemInfo, actWorldLV):
|
## »ñÈ¡½±Àø¿âÎïÆ·ÐÅÏ¢×ֵ䣬֧³Ö°´ÊÀ½çµÈ¼¶·¶Î§ÅäÖõĸñʽ
|
keyList = libItemInfo.keys()
|
if not keyList:
|
return {}
|
if isinstance(keyList[0], tuple) and len(keyList[0]) == 2:
|
return GameWorld.GetDictValueByRangeKey(libItemInfo, actWorldLV, {})
|
return libItemInfo
|
|
