#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
#
|
##@package Player.PlayerSuccess
|
#
|
# @todo:³É¾Íϵͳ
|
# @author xdh
|
# @date 2018-04-23
|
# @version 1.0
|
#
|
#
|
# ÏêϸÃèÊö: ³É¾Íϵͳ
|
#
|
#---------------------------------------------------------------------
|
#"""Version = 2018-04-23 11:00"""
|
#---------------------------------------------------------------------
|
|
import ShareDefine
|
import ChConfig
|
import GameWorld
|
import ChPyNetSendPack
|
import NetPackCommon
|
import ItemCommon
|
import IPY_GameWorld
|
import PlayerControl
|
import ItemControler
|
import PlayerMagicWeapon
|
import PlayerFamilyRedPacket
|
import PlayerGatherSoul
|
import IpyGameDataPY
|
import PyGameData
|
import EventReport
|
|
import datetime
|
import time
|
import math
|
import ChEquip
|
import PlayerRune
|
import Operate_EquipStone
|
import Operate_EquipWash
|
import PlayerFeastRedPacket
|
import PlayerDogz
|
import DataRecordPack
|
|
|
## »ñÈ¡³É¾Í×ÖµäÐÅÏ¢Öµ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def GetPDictValue(curPlayer, key, defaultValue=0):
|
return curPlayer.NomalDictGetProperty(key, defaultValue, ChConfig.Def_PDictType_Success)
|
|
|
## ÉèÖóɾÍ×ÖµäÐÅÏ¢Öµ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def SetPDictValue(curPlayer, key, value):
|
PlayerControl.NomalDictSetProperty(curPlayer, key, value, ChConfig.Def_PDictType_Success)
|
return
|
|
def GetSuccIsFinish(curPlayer, succID):
|
#»ñÈ¡³É¾ÍÊÇ·ñÒÑÍê³É
|
return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_FinishTime, succID)
|
|
def SetSuccFinish(curPlayer, succID, finish=True):
|
#ÉèÖóɾÍÊÇ·ñÍê³É
|
return GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_FinishTime, succID, finish)
|
|
def GetSuccHasGot(curPlayer, succID):
|
#»ñÈ¡³É¾Í½±ÀøÊÇ·ñÒÑÁìÈ¡
|
return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_AwardRecord, succID)
|
|
def SetSuccHasGot(curPlayer, succID, hasGot=True):
|
#ÉèÖóɾͽ±ÀøÁìȡ״̬
|
if GetSuccHasGot(curPlayer, succID) == hasGot:
|
return
|
GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_AwardRecord, succID, hasGot)
|
|
if hasGot:
|
#ÒÑÁìÈ¡µÄ¿ÉÉèÖÃÊÇ·ñÒÑÍê³ÉΪ0
|
SetSuccFinish(curPlayer, succID, 0)
|
|
Sync_SuccTypeIndexAwardRecord(curPlayer, [succID], True) #ÉèÖóÉδÁìÈ¡µÄÔÚÍâ²ãͬ²½
|
|
return
|
|
def GetSuccPassportAwardHasGot(curPlayer, succID):
|
#»ñÈ¡³É¾ÍͨÐÐÖ¤½±ÀøÊÇ·ñÒÑÁìÈ¡
|
return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_PassportAward, succID)
|
def SetSuccPassportAwardHasGot(curPlayer, succID, hasGot=True):
|
#ÉèÖóɾÍͨÐÐÖ¤½±ÀøÁìȡ״̬
|
GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_Success_PassportAward, succID, hasGot)
|
if hasGot:
|
Sync_SuccTypeIndexAwardRecord(curPlayer, [succID])
|
return
|
|
def SetSuccFinishValue(curPlayer, succType, condition, value):
|
#ÉèÖóɾÍÍê³É¶È
|
key = ChConfig.Def_PDict_Success_CntValue % (succType, condition)
|
SetPDictValue(curPlayer, key, value)
|
return
|
|
def GetSuccFinishValue(curPlayer, succType, condition):
|
#»ñÈ¡Íê³É¶È
|
key = ChConfig.Def_PDict_Success_CntValue % (succType, condition)
|
return GetPDictValue(curPlayer, key)
|
|
|
|
## ³É¾ÍÅä±íÊý¾ÝÀà
|
class SuccessData():
|
|
def __init__(self):
|
self.succID = 0 #³É¾ÍID
|
self.succType = 0 # ³É¾ÍÀàÐÍ
|
self.needCnt = 0 # ËùÒÔ¼ÆÊýÊýÁ¿
|
self.preSuccIDList = [] # Ç°ÖóɾÍID
|
self.condition = [] # ¸¨ÖúÌõ¼þ(¸ù¾ÝÀàÐÍ×Ô¶¨ÒåÅäÖÃ)
|
self.awardItemDict = {} # Íê³É³É¾Í¿ÉÁìÈ¡µÄ½±ÀøÎïÆ·{itemid:itemcnt}
|
self.awardItemDict2 = {} # Íê³É³É¾Í¿ÉÁìÈ¡µÄ½±ÀøÎïÆ·£¬Í¨ÐÐÖ¤½±Àø{itemid:itemcnt}
|
self.moneyDict = {} # Íê³É³É¾Í»ñµÃµÄ½ðÇ® {moneyType:money}
|
self.exp = 0 # Íê³É³É¾Í»ñµÃµÄ¾Ñé
|
self.attrDict = {} # Íê³É³É¾Í»ñµÃµÄÊôÐÔ {attrid:attrvalue}
|
self.hasAward = True #ÊÇ·ñÓн±Àø
|
self.redPacketID = 0 # ºì°üID
|
self.magicWeaponExp = {} # ·¨±¦Éý¼¶¾Ñé{id:exp}
|
return
|
|
|
## ³É¾ÍÊý¾Ý¹ÜÀíÀà
|
class SuccessDataMng():
|
|
## ¹¹Ô캯Êý
|
# @param None
|
# @return
|
def __init__(self):
|
self.succTypeConditionDict = {} #{succType:[condition,..]}
|
self.successDataDict = {} # {succType:{index:SuccessData(),...}, ...}
|
return
|
|
## ¼ÓÔسɾÍÊý¾Ý
|
# @param succType: ³É¾ÍÀàÐÍ
|
# @return
|
def __LoadSuccessData(self, succType):
|
if succType in self.successDataDict:
|
return
|
successDataList = IpyGameDataPY.GetIpyGameDataByCondition('Success', {'Type':succType}, True, False)
|
|
if not successDataList:
|
return
|
|
successDataObjDict = {}
|
conditionDict = {}
|
for successIpyData in successDataList:
|
succData = SuccessData()
|
succData.succID = successIpyData.GetID()
|
succData.succType = succType
|
succData.needCnt = successIpyData.GetNeedCnt()
|
succData.preSuccIDList = list(successIpyData.GetPreSuccess())
|
succData.condition = list(successIpyData.GetCondition())
|
succData.awardItemDict = successIpyData.GetAwardItem()
|
succData.awardItemDict2 = successIpyData.GetAwardItem2()
|
succData.moneyDict = successIpyData.GetMoney()
|
succData.exp = successIpyData.GetExp()
|
succData.attrDict = successIpyData.GetAwardAttr()
|
succData.redPacketID = successIpyData.GetRedPacketID()
|
magicWeaponID = successIpyData.GetMagicWeaponID()
|
magicWeaponExp = successIpyData.GetMagicWeaponExp()
|
if magicWeaponID and magicWeaponExp:
|
succData.magicWeaponExp[magicWeaponID] = magicWeaponExp
|
succData.hasAward = bool(succData.awardItemDict or succData.moneyDict or succData.exp or succData.attrDict or succData.redPacketID or succData.magicWeaponExp \
|
or succData.awardItemDict2)
|
successDataObjDict[succData.succID]=succData
|
if tuple(succData.condition) not in conditionDict:
|
conditionDict[tuple(succData.condition)] = [succData.succID]
|
else:
|
conditionDict[tuple(succData.condition)].append(succData.succID)
|
|
self.successDataDict[succType] = successDataObjDict
|
#self.succTypeConditionDict[succType] = conditionDict
|
return
|
|
## ¸ù¾Ý³É¾ÍÀàÐÍ»ñÈ¡¸ÃÀàÐÍËùÓгɾÍ
|
# @param succType: ³É¾ÍÀàÐÍ
|
# @return: {index:SuccessData(), ...}
|
def GetSuccDataByType(self, succType):
|
if succType not in self.successDataDict:
|
self.__LoadSuccessData(succType)
|
return self.successDataDict.get(succType, {}).values()
|
|
## ¸ù¾Ý³É¾ÍÀàÐÍ»ñÈ¡¸ÃÀàÐÍËùÓÐÌõ¼þ
|
# @param succType: ³É¾ÍÀàÐÍ
|
# @return: {index:SuccessData(), ...}
|
# def GetConditionDictByType(self, succType):
|
# if succType not in self.succTypeConditionDict:
|
# self.__LoadSuccessData(succType)
|
# return self.succTypeConditionDict.get(succType, {})
|
|
## ¸ù¾Ý³É¾ÍÀàÐÍË÷Òý»ñȡij¸ö³É¾ÍÊý¾Ý
|
# @param succType: ³É¾ÍÀàÐÍ
|
# @param index: ³É¾ÍË÷Òý
|
# @return: SuccessData() or None
|
def GetSuccessData(self, succID):
|
succIpyData = IpyGameDataPY.GetIpyGameDataNotLog('Success', succID)
|
if not succIpyData:
|
return
|
succType = succIpyData.GetType()
|
if succType not in self.successDataDict:
|
self.__LoadSuccessData(succType)
|
return self.successDataDict.get(succType, {}).get(succID)
|
|
|
|
|
g_succDataMng = SuccessDataMng()
|
|
|
## »ñÈ¡³É¾ÍÊý¾Ý¹ÜÀíÆ÷
|
# @param None
|
# @return
|
def GetSuccDataMng():
|
return g_succDataMng
|
|
## ³É¾ÍOnLogin
|
# @param curPlayer
|
# @return
|
def SuccOnLogin(curPlayer):
|
# ͬ²½³É¾ÍÐÅÏ¢
|
Sync_SuccessInfo(curPlayer)
|
# ͬ²½³É¾ÍÁì½±¼Ç¼
|
Sync_SuccTypeIndexAwardRecord(curPlayer)
|
|
|
# ¼ì²éÀÏÍæ¼Ò
|
__CheckOldPlayerSuccess(curPlayer)
|
|
# ¼ì²é´ï³ÉÓë·ñ(ÓÐЩ¿ÉÄܸĹýÉÏÏÞ£¬È»ºóÍæ¼Ò¿ÉÒÔÍê³É£¬ÉÏÏßͳһ×öÒ»´Î¼ì²é)
|
for succType in ShareDefine.SuccessTypeList:
|
succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
|
if not succInfoList:
|
continue
|
__DoCheckSuccessFinish(curPlayer, succType, succInfoList)
|
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_ScoreAward):
|
Sync_SuccessScoreAward(curPlayer)
|
return
|
|
## ¼ì²éÀÏÍæ¼Ò³É¾Í¼¤»îÇé¿ö
|
# @param None
|
# @return
|
def __CheckOldPlayerSuccess(curPlayer):
|
''' ³É¾Í°æ±¾¸üÐÂÀÏÍæ¼Ò¼ì²é ÿ´ÎÆô¶¯·þÎñºó Íæ¼ÒµÚÒ»´ÎÉÏÏß¼ì²é³É¾ÍÍê³ÉÇé¿ö
|
'''
|
initGameWorldTime = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_InitGameWorldTime)
|
# ÉÏÏßÐèÒª¼ì²éÀÏÍæ¼Ò³É¾ÍÍê³ÉÇé¿öÀàÐÍ
|
NeedCheckSuccTypeList = [
|
]
|
|
curCheckVersion = GetPDictValue(curPlayer, ChConfig.Def_PDict_Success_CheckVersion)
|
if curCheckVersion == initGameWorldTime:
|
GameWorld.DebugLog(' ±¾´Î¿ªÆô·þÎñÆ÷´¦Àí¹ý³É¾Í¼ì²é,²»ÔÙ´¦Àí ', curPlayer.GetID())
|
return
|
GameWorld.DebugLog("¸üÐÂÀÏÍæ¼ÒÉÏÏß¼ì²é³É¾ÍcurCheckVersion=%s" % (curCheckVersion))
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for succType in NeedCheckSuccTypeList:
|
pass
|
|
DataRecordPack.DR_CheckOldPlayerSuccess(curPlayer)
|
SetPDictValue(curPlayer, ChConfig.Def_PDict_Success_CheckVersion, initGameWorldTime)
|
GameWorld.DebugLog("¸üÐÂÀÏÍæ¼ÒÉÏÏß¼ì²é³É¾ÍupdCheckVersions=%s" % (initGameWorldTime), curPlayer.GetID())
|
return
|
|
## ³É¾ÍOnWeek
|
# @param curPlayer
|
# @return
|
def OnWeek(curPlayer):
|
resetList = []
|
weekResetSuccTypeList = IpyGameDataPY.GetFuncEvalCfg('WeekResetSuccType')
|
for succType in weekResetSuccTypeList:
|
succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
|
if not succInfoList:
|
continue
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
condition = succDataObj.condition
|
if not GetSuccFinishValue(curPlayer, succType, condition):
|
continue
|
SetSuccFinishValue(curPlayer, succType, condition, 0)
|
SetSuccFinish(curPlayer, succID, False)
|
SetSuccHasGot(curPlayer, succID, False)
|
resetList.append(succID)
|
GameWorld.DebugLog(" OnWeek ÖØÖóɾÍÀàÐÍ: succID=%s" % (succID))
|
if resetList:
|
Sync_SuccTypeIndexAwardRecord(curPlayer, resetList, True)
|
Sync_SuccessInfo(curPlayer, resetList, True)
|
return
|
|
def DoResetSuccessIDList(curPlayer, resetSuccIDList):
|
## ÖØÖóɾÍÏà¹ØÊý¾Ý
|
if not resetSuccIDList:
|
return
|
resetList = []
|
for succID in resetSuccIDList:
|
succData = GetSuccDataMng().GetSuccessData(succID)
|
if not succData:
|
continue
|
succType = succData.succType
|
condition = succData.condition
|
#if not GetSuccFinishValue(curPlayer, succType, condition):
|
# continue
|
SetSuccFinishValue(curPlayer, succType, condition, 0)
|
SetSuccFinish(curPlayer, succID, False)
|
SetSuccHasGot(curPlayer, succID, False)
|
resetList.append(succID)
|
GameWorld.DebugLog(" ÖØÖóɾÍÀàÐÍ: succType=%s,succID=%s" % (succType, succID))
|
if resetList:
|
Sync_SuccTypeIndexAwardRecord(curPlayer, resetList, True)
|
Sync_SuccessInfo(curPlayer, resetList, True)
|
return
|
|
## ³É¾ÍOnDay
|
# @param curPlayer
|
# @return
|
def SuccOnDay(curPlayer):
|
resetList = []
|
# ÖØÖÃÁ¬ÐøÀàÐͶϵôµÄÊý¾Ý
|
serverDay = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_ServerDay)
|
GameWorld.DebugLog("Á¬ÐøÀàÐͳɾ͹ýÌì...serverDay=%s" % serverDay)
|
for succType in ShareDefine.ContinueSuccessTypeList:
|
|
succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
|
|
if not succInfoList:
|
continue
|
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
condition = succDataObj.condition
|
#GameWorld.DebugLog(" succID=%s" % (succID))
|
|
finishTime = GetSuccIsFinish(curPlayer, succID)
|
|
# ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
|
if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
|
GameWorld.DebugLog(" ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é")
|
continue
|
|
if __DoCheckResetContinue(curPlayer, serverDay, succID):
|
SetSuccFinishValue(curPlayer, succType, condition, 0)
|
resetList.append(succID)
|
|
if resetList:
|
Sync_SuccessInfo(curPlayer, resetList, True)
|
return
|
|
## ¼ì²é³É¾ÍÁ¬ÐøÌìÇé¿ö
|
# @param curPlayer
|
# @return True-Á¬ÐøÒÑÖжÏ
|
def __DoCheckResetContinue(curPlayer, serverDay, succID):
|
lastDayKey = ChConfig.Def_PDict_Success_LastDay % (succID)
|
lastDay = GetPDictValue(curPlayer, lastDayKey)
|
|
# ¼Ç¼ʱ¼ä´Ó¿ª·þÌìÊý¸Ä³É time.time()
|
if lastDay <= 1000:
|
#GameWorld.DebugLog(" lastDay <= 0")
|
return
|
|
tick = int(time.time())
|
serverDay = GameWorld.ChangeTimeNumToDatetime(tick, ChConfig.TYPE_Time_Format_Day)
|
lastDay = GameWorld.ChangeTimeNumToDatetime(lastDay, ChConfig.TYPE_Time_Format_Day)
|
# ×òÌìÓиüеIJ»´¦Àí£¬Ö¤Ã÷»¹ÊÇÁ¬Ðø״̬
|
if lastDay == serverDay - datetime.timedelta(1):
|
GameWorld.DebugLog(" ×òÌìÓиüеIJ»´¦Àí£¬Ö¤Ã÷»¹ÊÇÁ¬Ðø״̬")
|
return
|
|
|
SetPDictValue(curPlayer, lastDayKey, 0)
|
GameWorld.DebugLog(" ÖØÖóɾÍÁ¬ÐøÀàÐÍ: succID=%s" % (succID))
|
return True
|
|
def ResetSuccessByType(curPlayer, succType):
|
#ÖØÖÃijÀàÐͳɾͽø¶È£¨ÒÑÍê³ÉµÄ²»ÖØÖã©
|
succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
|
if not succInfoList:
|
return
|
#ÏÈÖØÖôÎÊýÔÙÖØмÆÊý
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
condition = succDataObj.condition
|
#GameWorld.DebugLog(" succID=%s" % (succID))
|
finishTime = GetSuccIsFinish(curPlayer, succID)
|
# ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
|
if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
|
continue
|
SetSuccFinishValue(curPlayer, succType, condition, 0)
|
return
|
|
def DoEquipSuccessLogic(curPlayer, classLV):
|
#Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
|
|
ipyDataList = IpyGameDataPY.GetIpyGameDataByCondition('EquipPlaceIndexMap', {'ClassLV':classLV}, True)
|
if not ipyDataList:
|
return
|
|
placeCountDict, colorCountDict, suitCountDict = {}, {}, {}
|
playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
|
for ipyData in ipyDataList:
|
equipIndex = ipyData.GetGridIndex()
|
curEquip = playerEquip.GetAt(equipIndex)
|
if curEquip.IsEmpty():
|
continue
|
itemPlace = curEquip.GetEquipPlace()
|
|
# Ì××°¡¢ÑÕÉ« ³É¾Í ͳ¼Æ»ù´¡²¿Î»
|
if itemPlace in ChConfig.EquipPlace_Base:
|
itemColor = curEquip.GetItemColor()
|
colorConditionKey = (classLV, itemColor)
|
colorCountDict[colorConditionKey] = colorCountDict.get(colorConditionKey, 0) + 1
|
|
# ͳ¼ÆÌ××°Êý
|
if curEquip.GetSuiteID():
|
suitConditionKey = (classLV, )
|
suitCountDict[suitConditionKey] = suitCountDict.get(suitConditionKey, 0) + 1
|
|
# ²¿Î» ³É¾Í ͳ¼ÆÌØÊⲿλ
|
elif itemPlace in ChConfig.EquipPlace_Special:
|
placeConditionKey = (classLV, itemPlace)
|
placeCountDict[placeConditionKey] = placeCountDict.get(placeConditionKey, 0) + 1
|
|
# ¸üгɾÍ
|
#GameWorld.DebugLog("×°±¸½×²¿Î»³É¾ÍÊý¾Ý: classLV=%s,placeCountDict=%s" % (classLV, placeCountDict))
|
UpdateSuccessProgressByConditions(curPlayer, ShareDefine.SuccType_EquipPlace, placeCountDict)
|
|
#GameWorld.DebugLog("×°±¸½×ÑÕÉ«³É¾ÍÊý¾Ý: classLV=%s,colorCountDict=%s" % (classLV, colorCountDict))
|
UpdateSuccessProgressByConditions(curPlayer, ShareDefine.SuccType_EquipColorItem, colorCountDict)
|
|
#GameWorld.DebugLog("×°±¸½×Ì××°³É¾ÍÊý¾Ý: classLV=%s,suitCountDict=%s" % (classLV, suitCountDict))
|
UpdateSuccessProgressByConditions(curPlayer, ShareDefine.SuccType_EquipSuit, suitCountDict)
|
return
|
|
def UpdateSuccessProgressByConditions(curPlayer, successType, conditionCountDict):
|
if successType not in ShareDefine.SuccessTypeList:
|
return
|
succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
|
if not succInfoList:
|
return
|
updIDList = []
|
updsuccDataList = []
|
updConditionDict = {}
|
|
for condition, newCount in conditionCountDict.items():
|
addCondList = [] # ²»Í¬µÄ³É¾ÍIDÌõ¼þ¿ÉÄÜÏàͬ£¬Ö»ÊÇ×î´ó½ø¶È²»Í¬£¬¹Ê´«ÈëµÄÌõ¼þ¼ÆÊýÕë¶ÔÏàͬ³É¾ÍÌõ¼þÖ»ÄÜÀÛ¼ÓÒ»´Î
|
for succDataObj in succInfoList:
|
cond = succDataObj.condition
|
|
tupleCond = tuple(cond) # ×÷Ϊ×ÖµäkeyÓÃ
|
succID = succDataObj.succID
|
needCnt = succDataObj.needCnt
|
|
if tupleCond not in updConditionDict:
|
updConditionDict[tupleCond] = [cond, 0, 0] # [Ìõ¼þ, ¸üÐÂÖµ, ×î´ó½ø¶ÈÖµ]
|
updInfo = updConditionDict[tupleCond]
|
if updInfo[2] < needCnt:
|
updInfo[2] = needCnt
|
|
if not __CheckCanAddSuccess(curPlayer, succDataObj, list(condition)):
|
continue
|
|
if succID not in updIDList:
|
updIDList.append(succID)
|
updsuccDataList.append(succDataObj)
|
|
if tupleCond not in addCondList:
|
addCondList.append(tupleCond)
|
updConditionDict[tupleCond][1] = updConditionDict[tupleCond][1] + newCount # ¸üнø¶ÈÖµ
|
|
# ûÓÐÕÒµ½¸üÐÂÄ¿±ê²»´¦Àí
|
#GameWorld.DebugLog(" updConditionDict=%s" % updConditionDict)
|
#GameWorld.DebugLog(" updIDList=%s" % updIDList)
|
if not updIDList:
|
return
|
|
isUpd = False
|
# ÏȸüгɾͼǼֵºóÔÙÅжÏÍê³ÉÓë·ñ
|
for cond, updCnt, maxCnt in updConditionDict.values():
|
if not updCnt:
|
continue
|
updCnt = min(maxCnt, updCnt)
|
if GetSuccFinishValue(curPlayer, successType, cond) == updCnt:
|
continue
|
isUpd = True
|
SetSuccFinishValue(curPlayer, successType, cond, updCnt)
|
#GameWorld.DebugLog(" successType=%s,cond=%s,updCnt=%s,maxCnt=%s" % (successType, cond, updCnt, maxCnt))
|
|
if not isUpd:
|
return
|
|
# ͬ²½¸üÐÂÐÅÏ¢
|
Sync_SuccessInfo(curPlayer, updIDList, False)
|
|
# ¸üÐÂÖµºó¼ì²é³É¾ÍÍê³ÉÇé¿ö
|
__DoCheckSuccessFinish(curPlayer, successType, updsuccDataList)
|
return
|
|
|
## ¸üгɾÍÍê³É½ø¶ÈÂß¼(Íⲿ¹¦Äܵ÷Óã¬Ö»ÊÊÓÃÓÚ²»ÖØÖõijɾÍÀàÐÍ)
|
# @param curPlayer
|
# @param successType: ³É¾ÍÀàÐÍ
|
# @param newCnt: нø¶ÈÖµ
|
# @return
|
def UptateSuccessProgress(curPlayer, successType, newCnt, condition=[]):
|
if successType not in ShareDefine.SuccessTypeList:
|
return
|
if successType in ShareDefine.FeastRedPackSuccessTypeList:
|
if not PlayerFeastRedPacket.GetFeastRedPacketState():
|
return
|
succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
|
if not succInfoList:
|
GameWorld.DebugLog(" ÕÒ²»µ½³É¾ÍÊý¾ÝsuccessType=%s" % successType)
|
return
|
curCnt = -1
|
for succData in succInfoList:
|
if not __CheckCanAddSuccess(curPlayer, succData, condition):
|
continue
|
curCnt = GetSuccFinishValue(curPlayer, successType, succData.condition)
|
break
|
|
if curCnt == -1:
|
return
|
if newCnt > curCnt: #ÕâÀïÐèÒªÁ¢¼´¸üУ¡£¡
|
DoAddSuccessProgress(curPlayer, successType, newCnt - curCnt, condition, False)
|
return
|
|
def __CheckCanAddSuccess(curPlayer, succDataObj, condition):
|
successType = succDataObj.succType
|
succID = succDataObj.succID
|
cond = succDataObj.condition
|
|
if successType in ShareDefine.FeastRedPackSuccessTypeList:
|
todayFeastSuccIDList = PlayerFeastRedPacket.GetTodayFeastSuccIDList()
|
if not todayFeastSuccIDList or succID not in todayFeastSuccIDList:
|
#GameWorld.DebugLog(" ·Ç½ñÈÕ½ÚÈÕºì°ü³É¾Í£¬²»Ôö¼Ó½ø¶È! succID=%s,todayFeastSuccIDList=%s" % (succID, todayFeastSuccIDList))
|
return
|
isUnDownCheck = successType in ShareDefine.UnDownCheckSuccessTypeList
|
isContain = successType in ShareDefine.ContainSuccessTypeList
|
# ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
|
if GetSuccIsFinish(curPlayer, succID) or GetSuccHasGot(curPlayer, succID):
|
return
|
#Ç°ÖóɾÍÅжÏ
|
preSuccIDList = succDataObj.preSuccIDList
|
for preSuccID in preSuccIDList:
|
if not GetSuccIsFinish(curPlayer, preSuccID) and not GetSuccHasGot(curPlayer, preSuccID):
|
return
|
|
# Óи¨ÖúÌõ¼þµÄ, ÐèÅжÏÊÇ·ñÏòϼì²é
|
if len(cond) > 0:
|
if isContain:
|
if condition[0] not in cond:
|
return
|
elif successType in ShareDefine.MultipleSuccessTypeList:
|
if not (condition[0]/cond[0] and condition[0]%cond[0] == 0):
|
#±ØÐëÊÇÌõ¼þµÄ±¶Êý
|
return
|
else:
|
if len(cond) != len(condition):
|
return
|
# ²»Ïòϼì²éÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµµÈÓÚ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
|
if isUnDownCheck and cond != condition:
|
return
|
# ¿ÉÏòÏÂÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµ <= ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
|
if not isUnDownCheck:
|
isbreak = False
|
undowncheckIndexList = [] # ²»Ïòϼì²éµÄÌõ¼þË÷Òý
|
if successType in ShareDefine.PartUnDownCheckSuccessTypeInfo:
|
undowncheckIndexList = ShareDefine.PartUnDownCheckSuccessTypeInfo[successType]
|
for i, num in enumerate(cond):
|
if i in undowncheckIndexList:
|
if num != condition[i]:
|
isbreak = True
|
break
|
if num > condition[i]:
|
isbreak = True
|
break
|
if isbreak:
|
return
|
return True
|
|
|
# ½«¹¥»÷ÀàµÄ³É¾ÍÒ»´ÎÖ´ÐУ¬¼õÉÙÔËÐÐÁ¿
|
def FinishDelayAddSuccessProgress(curPlayer, tick, isFinish=True):
|
|
if not isFinish:
|
# ¶þ´ÎÑÓ³Ù´¦Àí
|
if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_Success) \
|
< ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_Success]:
|
return
|
|
curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_Success, tick)
|
|
playerID = curPlayer.GetID()
|
if playerID not in PyGameData.g_delaySuccessDict:
|
return
|
|
successDict = PyGameData.g_delaySuccessDict.pop(playerID)
|
for sucessInfo, cnt in successDict.items():
|
|
DoAddSuccessProgress(curPlayer, sucessInfo[0], cnt, list(sucessInfo[1]), False)
|
|
return
|
|
|
## Ôö¼Ó³É¾ÍÍê³É½ø¶ÈÂß¼(Íⲿ¹¦Äܵ÷ÓÃ)
|
# @param curPlayer
|
# @param successType: ³É¾ÍÀàÐÍ
|
# @param addCnt: Ôö¼Ó½ø¶ÈÖµ
|
# @param condition: À©Õ¹Ìõ¼þ
|
# @return
|
def DoAddSuccessProgress(curPlayer, successType, addCnt, condition=[], delayCalc=True):
|
#GameWorld.DebugLog("DoAddSuccessProgress type=%s,addCnt=%s,condition=%s"
|
# % (successType, addCnt, condition), curPlayer.GetPlayerID())
|
if GameWorld.IsCrossServer():
|
return
|
|
if successType in ShareDefine.FeastRedPackSuccessTypeList:
|
if not PlayerFeastRedPacket.GetFeastRedPacketState():
|
#GameWorld.DebugLog("·Ç½ÚÈÕºì°ü»î¶¯Ê±¼ä£¬²»Ôö¼Ó³É¾Í£¡successType=%s" % successType)
|
return
|
|
playerID = curPlayer.GetID()
|
if delayCalc and successType not in ShareDefine.NeedResetSuccessTypeList:
|
if playerID not in PyGameData.g_delaySuccessDict:
|
PyGameData.g_delaySuccessDict[playerID] = {}
|
|
# ×îÖÕ´¦Àí¼õÉÙ¼ÆËãÁ¿
|
successTuple = (successType, tuple(condition))
|
if successTuple not in PyGameData.g_delaySuccessDict[playerID]:
|
PyGameData.g_delaySuccessDict[playerID][successTuple] = addCnt
|
else:
|
PyGameData.g_delaySuccessDict[playerID][successTuple] = PyGameData.g_delaySuccessDict[playerID][successTuple] + addCnt
|
|
return
|
|
|
if condition and type(condition) != type([]):
|
GameWorld.ErrLog('DoAddSuccessProgress type=%s, condition=%s ´íÎó£¡'%(type, condition))
|
return
|
if successType not in ShareDefine.SuccessTypeList:
|
return
|
|
succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
|
if not succInfoList:
|
GameWorld.DebugLog(" ÕÒ²»µ½³É¾ÍÊý¾ÝsuccessType=%s" % successType)
|
return
|
|
maxCnt = 0 # ±¾´Î¿ÉÒÔ¸üе½µÄ×î´óÖµ
|
updConditionList = [] # Ðè¸üнø¶ÈÖµµÄkey±àºÅÁбí
|
updIDList = []
|
updsuccDataList = []
|
tick = int(time.time())
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
needCnt = succDataObj.needCnt
|
|
if not __CheckCanAddSuccess(curPlayer, succDataObj, condition):
|
continue
|
updIDList.append(succID)
|
updsuccDataList.append(succDataObj)
|
curCondition = succDataObj.condition
|
if curCondition not in updConditionList:
|
updConditionList.append(curCondition)
|
|
if maxCnt < needCnt:
|
maxCnt = needCnt
|
|
# Á¬ÐøÀàÐ͵Ä, ¸üÐÂÁ¬ÐøʱµÄ¿ª·þÌìÊý
|
if successType in ShareDefine.ContinueSuccessTypeList:
|
lastDayKey = ChConfig.Def_PDict_Success_LastDay % (succID)
|
SetPDictValue(curPlayer, lastDayKey, tick)
|
|
|
|
#GameWorld.DebugLog(" updConditionList=%s,maxCnt=%s" % (str(updConditionList), maxCnt))
|
|
# ûÓÐÕÒµ½¸üÐÂÄ¿±ê²»´¦Àí
|
if not updConditionList or maxCnt <= 0:
|
return
|
|
# ÏȸüгɾͼǼֵºóÔÙÅжÏÍê³ÉÓë·ñ
|
for condition in updConditionList:
|
curCnt = GetSuccFinishValue(curPlayer, successType, condition)
|
updCnt = min(maxCnt, curCnt + addCnt)
|
SetSuccFinishValue(curPlayer, successType, condition, updCnt)
|
# GameWorld.DebugLog(" successType=%s,condition=%s,curCnt=%s,addCnt=%s,updCnt=%s"
|
# % (successType,condition, curCnt, addCnt, updCnt))
|
|
|
# ͬ²½¸üÐÂÐÅÏ¢
|
Sync_SuccessInfo(curPlayer, updIDList, False)
|
|
# ¸üÐÂÖµºó¼ì²é³É¾ÍÍê³ÉÇé¿ö
|
__DoCheckSuccessFinish(curPlayer, successType, updsuccDataList)
|
return
|
|
|
## ¼ì²é³É¾ÍÍê³ÉÇé¿ö
|
# @param curPlayer
|
# @param successType: ³É¾ÍÀàÐÍ
|
# @param succInfoDict: ¸ÃÀàÐÍËùÓгɾÍÐÅÏ¢×Öµä
|
# @param isPub: ½ø¶ÈÖµÊÇ·ñ¹«¹²
|
# @param updNumList: Óиüнø¶ÈµÄ±àºÅÁбí
|
# @return
|
def __DoCheckSuccessFinish(curPlayer, successType, succInfoList):
|
|
isNeedSys = successType in [ShareDefine.SuccType_ElderBattlefieldKill, ShareDefine.SuccType_ElderBattlefieldConKill]
|
curTime = GameWorld.ChangeTimeStrToNum(GameWorld.GetCurrentDataTimeStr())
|
playerName = curPlayer.GetName()
|
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
needCnt = succDataObj.needCnt
|
|
finishTime = GetSuccIsFinish(curPlayer, succID)
|
|
# ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
|
if finishTime > 0 or GetSuccHasGot(curPlayer, succID):
|
continue
|
|
curCnt = GetSuccFinishValue(curPlayer, successType, succDataObj.condition)
|
|
# Íê³É³É¾Í
|
if curCnt >= needCnt:
|
# ÉèÖÃÍê³Éʱ¼ä
|
SetSuccFinish(curPlayer, succID)
|
# ûÓн±ÀøµÄÖ±½ÓÉèÖÃÒÑÁìÈ¡
|
if not succDataObj.hasAward:
|
SetSuccHasGot(curPlayer, succID)
|
|
# ֪ͨ¿Í»§¶ËÍê³É³É¾Í
|
Notify_FinishSuccess(curPlayer, succID, curTime)
|
|
if isNeedSys:
|
PlayerControl.WorldNotify(0, 'AncientBattlefield_1', [playerName, succID])
|
|
for mwID in succDataObj.magicWeaponExp.keys():
|
EventReport.WriteEvent_MWSuccess(curPlayer, mwID, succID, ChConfig.CME_Log_Start)
|
GameWorld.DebugLog(" Íê³É³É¾ÍsuccID=%s, type=%s,time=%s"
|
% (succID, successType, curTime))
|
|
|
|
return
|
|
|
## ¼ÆËã³É¾ÍÊôÐÔ
|
# @param curPlayer Íæ¼Ò
|
# @param allAttrList ÊôÐÔÁбí
|
# @return None
|
def CalcSuccessAttr(curPlayer):
|
allAttrList = [{} for _ in range(4)]
|
attrDict = {}
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for i in xrange(ipyDataMgr.GetSuccessCount()):
|
ipyData = ipyDataMgr.GetSuccessByIndex(i)
|
succID = ipyData.GetID()
|
attrAwardDict = ipyData.GetAwardAttr()
|
if not attrAwardDict:
|
continue
|
if not GetSuccHasGot(curPlayer, succID):
|
continue
|
for attrID, attrValue in attrAwardDict.items():
|
attrDict[attrID] = attrDict.get(attrID, 0) + attrValue
|
|
#GameWorld.DebugLog(" ³É¾ÍÔö¼ÓÊôÐÔ attrDict=%s" % (attrDict))
|
for attrID, attrValue in attrDict.items():
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
|
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Success, allAttrList)
|
return
|
|
## ˢгɾÍÊôÐÔ
|
def RefreshSuccessAttr(curPlayer):
|
CalcSuccessAttr(curPlayer)
|
# ²»Á¢¼´Ë¢ÐÂ
|
PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState()
|
return
|
|
## ͬ²½³É¾ÍÐÅÏ¢
|
# @param curPlayer:
|
# @param syncDict: Ö¸¶¨Í¬²½×Öµä
|
# @param isSendZero: ÊÇ·ñͬ²½¿ÕÊý¾Ý(ÈçÁ¬ÐøÀàÐͽø¶ÈÖµ±»Çå¿Õʱ or GMÃüÁî²âÊÔ), Êý¾Ý±È½Ï¶à£¬¿ÕÊý¾ÝĬÈϾͲ»Í¬²½ÁË
|
# @return
|
def Sync_SuccessInfo(curPlayer, succIdList=[], isSendZero=False):
|
succInfoListPack = ChPyNetSendPack.tagMCSuccessInfoList()
|
succInfoListPack.Clear()
|
succInfoListPack.SuccessInfoList = []
|
if succIdList:
|
syncIdList = succIdList
|
else:
|
syncIdList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for i in xrange(ipyDataMgr.GetSuccessCount()):
|
ipyData = ipyDataMgr.GetSuccessByIndex(i)
|
succID = ipyData.GetID()
|
syncIdList.append(succID)
|
|
syncTypeDict = {}
|
for succID in syncIdList:
|
succData = GetSuccDataMng().GetSuccessData(succID)
|
if not succData:
|
continue
|
succType = succData.succType
|
condition = succData.condition
|
|
CntValue = GetSuccFinishValue(curPlayer, succType, condition)
|
isfinish = GetSuccIsFinish(curPlayer, succID)
|
# ²»·¢ËÍΪ0µÄÊý¾Ý
|
if not isSendZero and CntValue <= 0 and not isfinish:
|
continue
|
# ÒÑÁìÈ¡µÄ²»·¢
|
if GetSuccHasGot(curPlayer, succID):
|
continue
|
|
if succType not in syncTypeDict:
|
syncTypeDict[succType] = [[condition, CntValue]]
|
elif [condition, CntValue] not in syncTypeDict[succType]:
|
syncTypeDict[succType].append([condition, CntValue])
|
|
if not syncTypeDict:
|
return
|
|
for sType, conditionList in syncTypeDict.items():
|
for condition, cntValue in conditionList:
|
succInfo = ChPyNetSendPack.tagMCSuccessInfo()
|
succInfo.Clear()
|
succInfo.SuccType = sType
|
succInfo.Condition = str(condition) if condition else '[0]'
|
succInfo.Len = len(succInfo.Condition)
|
succInfo.CntValue = cntValue
|
succInfoListPack.SuccessInfoList.append(succInfo)
|
|
succInfoListPack.count = len(succInfoListPack.SuccessInfoList)
|
NetPackCommon.SendFakePack(curPlayer, succInfoListPack)
|
return
|
|
|
## ֪ͨÍê³É³É¾Í
|
# @param None
|
# @return
|
def Notify_FinishSuccess(curPlayer, succID, finishTime):
|
succFinishPack = ChPyNetSendPack.tagMCSuccessFinish()
|
succFinishPack.Clear()
|
succFinishPack.SuccID = succID
|
#succFinishPack.FinishTime = finishTime
|
NetPackCommon.SendFakePack(curPlayer, succFinishPack)
|
return
|
|
|
def GetCanGetAwardSuccByType(curPlayer, successTypeList):
|
##¸ù¾ÝÀàÐÍ»ñÈ¡¿ÉÁìÈ¡µÄ³É¾Í
|
succList = []
|
for successType in successTypeList:
|
succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
|
for succDataObj in succInfoList:
|
succID = succDataObj.succID
|
if GetSuccIsFinish(curPlayer, succID) and not GetSuccHasGot(curPlayer, succID):
|
succList.append(succID)
|
return succList
|
|
def GiveSuccAward(curPlayer, succIDList, isGiveItem=True):
|
#¸ø³É¾Í½±Àø
|
awardDict = {}
|
for succID in succIDList:
|
awardItemDict = __DoGetSuccTypeIndexAward(curPlayer, succID, isGiveItem)
|
if not awardItemDict:
|
continue
|
for itemID,itemCnt in awardItemDict.items():
|
awardDict[itemID] = awardDict.get(itemID, 0)+itemCnt
|
return awardDict
|
|
def GetSuccessPassportState(curPlayer):
|
## ³É¾ÍͨÐÐ֤״̬
|
return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CTGGoodsBuyCount % ChConfig.Def_CTGID_SuccessPassport) > 0
|
|
#// A5 42 ÁìÈ¡³É¾Í½±Àø #tagMCGetSuccessAward
|
#
|
#struct tagMCGetSuccessAward
|
#{
|
# tagHead Head;
|
# DWORD SuccID; //³É¾ÍID
|
# BYTE IsPassport; //ÊÇ·ñͨÐÐÖ¤½±Àø
|
#};
|
def OnGetSuccessAward(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
succID = clientData.SuccID
|
isPassport = clientData.IsPassport
|
__DoGetSuccTypeIndexAward(curPlayer, succID, isPassport=isPassport)
|
return
|
|
## Áìȡij¸ö³É¾Í½±Àø
|
# @param None
|
# @return
|
def __DoGetSuccTypeIndexAward(curPlayer, succID, isGiveItem=True, isPassport=False):
|
GameWorld.DebugLog("ÁìÈ¡³É¾Í½±ÀøsuccID=%s,isPassport=%s" % (succID, isPassport))
|
|
succData = GetSuccDataMng().GetSuccessData(succID)
|
if not succData:
|
GameWorld.DebugLog(" ³É¾ÍÊý¾Ý²»´æÔÚ£¡succID=%s" % (succID))
|
return
|
|
if not succData.hasAward:
|
GameWorld.DebugLog(" ¸Ã³É¾ÍûÓÐÅäÖý±Àø£¡")
|
return
|
|
finishTime = GetSuccIsFinish(curPlayer, succID)
|
hasGot = GetSuccHasGot(curPlayer, succID) # ÒòΪÆÕͨ½±ÀøÁìÈ¡ºó»áÖØÖÃÊÇ·ñÒÑÍê³É£¬ËùÒÔÈç¹ûÒѾÁìÈ¡ÆÕͨ½±ÀøÒ²´ú±íÒÑÍê³É
|
if finishTime <= 0 and not hasGot:
|
GameWorld.DebugLog(" ¸Ã³É¾ÍδÍê³É£¡")
|
return
|
|
if isPassport:
|
if GetSuccPassportAwardHasGot(curPlayer, succID):
|
GameWorld.DebugLog(" ¸Ã³É¾ÍͨÐÐÖ¤½±ÀøÒѾÁìÈ¡¹ý£¡")
|
return
|
|
if not GetSuccessPassportState(curPlayer):
|
GameWorld.DebugLog(" δ¿ªÍ¨³É¾ÍͨÐÐÖ¤£¬ÎÞ·¨ÁìȡͨÐÐÖ¤½±Àø£¡")
|
return
|
itemDict = succData.awardItemDict2
|
if not itemDict:
|
GameWorld.DebugLog(" ¸Ã³É¾ÍûÓÃͨÐÐÖ¤½±Àø£¡")
|
return
|
else:
|
if hasGot:
|
GameWorld.DebugLog(" ¸Ã³É¾Í½±ÀøÒѾÁìÈ¡¹ý£¡")
|
return
|
itemDict = succData.awardItemDict
|
|
# if awardItemDict and '[' in str(awardItemDict):
|
# #ÐÞÐгɾͽ±Àø¸ù¾Ý¾³½çµÈ¼¶±ä
|
# curRealmLV = curPlayer.GetOfficialRank()
|
# sortLVList=sorted(awardItemDict.keys())
|
# findLV = sortLVList[0]
|
# for realmlv in sortLVList:
|
# if curRealmLV <= int(realmlv):
|
# findLV = realmlv
|
# break
|
# itemDict = dict(awardItemDict[findLV])
|
# else:
|
# itemDict = awardItemDict
|
|
# ¼ì²é±³°ü
|
if isGiveItem:
|
if not ItemCommon.CheckPackEnough(curPlayer, itemDict):
|
return
|
# packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem)
|
# needSpace = len(itemDict)
|
# if needSpace > packSpace:
|
# PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
|
# return
|
|
# ¸üÐÂÁì½±¼Ç¼
|
if isPassport:
|
SetSuccPassportAwardHasGot(curPlayer, succID)
|
else:
|
SetSuccHasGot(curPlayer, succID)
|
|
# ¸øÎïÆ·
|
giveItemList = []
|
if isGiveItem:
|
for itemID, itemCnt in itemDict.items():
|
isPutIn = ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, 0, [IPY_GameWorld.rptItem, IPY_GameWorld.rptAnyWhere])
|
if isPutIn:
|
giveItemList.append([itemID, itemCnt])
|
|
if isPassport:
|
# ͨÐÐÖ¤½±ÀøÖ»¸øÎïÆ·
|
ItemControler.NotifyGiveAwardInfo(curPlayer, giveItemList, "SuccessAward")
|
return itemDict
|
|
#¸øÇ®
|
for moneyType, value in succData.moneyDict.items():
|
PlayerControl.GiveMoney(curPlayer, int(moneyType), value)
|
|
#¸ø¾Ñé
|
if succData.exp:
|
PlayerControl.PlayerControl(curPlayer).AddExp(succData.exp)
|
#ÊôÐÔ
|
if succData.attrDict:
|
RefreshSuccessAttr(curPlayer)
|
#·¢ºì°ü
|
if succData.redPacketID:
|
PlayerFamilyRedPacket.CreatRedPacketByID(curPlayer, succData.redPacketID, PlayerFamilyRedPacket.State_NoGot, succID)
|
#·¨±¦¾Ñé
|
if succData.magicWeaponExp:
|
for mwID, addExp in succData.magicWeaponExp.items():
|
PlayerMagicWeapon.AddMagicWeaponUpExp(curPlayer, mwID, addExp)
|
EventReport.WriteEvent_MWSuccess(curPlayer, mwID, succID, ChConfig.CME_Log_End, 1)
|
GameWorld.DebugLog(" OK! awardItemDict=%s moneyDict=%s" % (itemDict, succData.moneyDict))
|
ItemControler.NotifyGiveAwardInfo(curPlayer, giveItemList, "SuccessAward", exp=succData.exp, moneyInfo=succData.moneyDict)
|
return itemDict
|
|
|
|
## ֪ͨ³É¾Í¶ÔÓ¦½±ÀøÁì½±¼Ç¼
|
# @param None
|
# @return
|
def Sync_SuccTypeIndexAwardRecord(curPlayer, succIDList=[], isSyncZero=False):
|
if succIDList:
|
recordIndexList = []
|
for succID in succIDList:
|
recordIndex = succID / 31
|
if recordIndex not in recordIndexList:
|
recordIndexList.append(recordIndex)
|
else:
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
succCnt = ipyDataMgr.GetSuccessCount()
|
if not succCnt:
|
return
|
maxSuccid = ipyDataMgr.GetSuccessByIndex(succCnt-1).GetID()
|
recordIndexList = xrange(maxSuccid / 31+1)
|
|
succFARPack = ChPyNetSendPack.tagMCSuccessFinishAwardRecordList()
|
succFARPack.Clear()
|
succFARPack.RecordList = []
|
for i in recordIndexList:
|
awardRecord=curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_AwardRecord%i)
|
passportAwardRecord=curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_PassportAward%i)
|
if not isSyncZero and not awardRecord and not passportAwardRecord:
|
continue
|
recordInfo = ChPyNetSendPack.tagMCSuccessFinishAwardRecord()
|
recordInfo.RecordIndex = i
|
recordInfo.Record = awardRecord
|
recordInfo.PassportRecord = passportAwardRecord
|
succFARPack.RecordList.append(recordInfo)
|
|
succFARPack.RecordCnt = len(succFARPack.RecordList)
|
NetPackCommon.SendFakePack(curPlayer, succFARPack)
|
return
|
|
|
def AddEnterFBSuccess(curPlayer, mapID, addCount):
|
#½øÈ븱±¾³É¾ÍÏà¹Ø
|
|
if mapID == ChConfig.Def_FBMapID_BZZD:
|
#ÏɽçÃؾ³
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_BZZD, addCount)
|
elif mapID == ChConfig.Def_FBMapID_IceLode:
|
#±ù¾§¿óÂö
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_IceLode, addCount)
|
return
|
|
def GetSuccessScoreAward(curPlayer, awardIndex):
|
playerID = curPlayer.GetPlayerID()
|
awardDict = IpyGameDataPY.GetFuncEvalCfg("SucceeScore", 1, {})
|
if str(awardIndex) not in awardDict:
|
return
|
awardInfo = awardDict[str(awardIndex)]
|
if len(awardInfo) != 2:
|
return
|
needScore, awardItemList = awardInfo
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_SuccessSocre, needScore):
|
GameWorld.Log("³É¾Í»ý·Ö²»×㣬ÎÞ·¨Áì½±! awardIndex=%s,needScore=%s" % (awardIndex, needScore), playerID)
|
return
|
awardState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_ScoreAward)
|
if awardState & pow(2, awardIndex):
|
GameWorld.DebugLog("ÒÑÁìÈ¡¹ý¸Ã³É¾Í»ý·Ö½±Àø! awardIndex=%s" % awardIndex, playerID)
|
return
|
updAwardState = awardState | pow(2, awardIndex)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Success_ScoreAward, updAwardState)
|
GameWorld.DebugLog("ÁìÈ¡³É¾Í»ý·Ö½±Àø! awardIndex=%s,awardState=%s,updAwardState=%s" % (awardIndex, awardState, updAwardState), playerID)
|
Sync_SuccessScoreAward(curPlayer)
|
ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["SuccessScore", False, {}])
|
return
|
|
def Sync_SuccessScoreAward(curPlayer):
|
clientPack = ChPyNetSendPack.tagMCSuccessScoreInfo()
|
clientPack.Clear()
|
clientPack.ScoreAwardState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_ScoreAward)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
|
