#!/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 EventShell
|
import PyGameData
|
import EventReport
|
|
import datetime
|
import time
|
import math
|
import ChEquip
|
import PlayerRune
|
import Operate_EquipStone
|
import Operate_EquipWash
|
import Operate_EquipSuitCompose
|
import PlayerDogz
|
import QuestCommon
|
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) #ÉèÖóÉδÁìÈ¡µÄÔÚÍâ²ãͬ²½
|
PlayerMagicWeapon.ActiveMagicWeapon(curPlayer, succID)
|
EventShell.EventRespons_SuccessFinish(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.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.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)
|
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)
|
return
|
|
## ¼ì²éÀÏÍæ¼Ò³É¾Í¼¤»îÇé¿ö
|
# @param None
|
# @return
|
def __CheckOldPlayerSuccess(curPlayer):
|
''' ³É¾Í°æ±¾¸üÐÂÀÏÍæ¼Ò¼ì²é ÿ´ÎÆô¶¯·þÎñºó Íæ¼ÒµÚÒ»´ÎÉÏÏß¼ì²é³É¾ÍÍê³ÉÇé¿ö
|
'''
|
#Versions = 2 #°æ±¾ºÅ,ÍùÉÏÔö¼Ó
|
initGameWorldTime = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_InitGameWorldTime)
|
# ÉÏÏßÐèÒª¼ì²éÀÏÍæ¼Ò³É¾ÍÍê³ÉÇé¿öÀàÐÍ{³É¾ÍÀàÐÍ:ά»¤°æ±¾ºÅ, ...}
|
NeedCheckSuccTypeList = [
|
ShareDefine.SuccType_GetMagicWeapon,
|
ShareDefine.SuccType_PassRuneTower,
|
ShareDefine.SuccType_GodWeapon,
|
ShareDefine.SuccType_HorseAllLV,
|
#ShareDefine.SuccType_EquipPlusLV,
|
ShareDefine.SuccType_EquipColorItem,
|
ShareDefine.SuccType_EquipArmor,
|
ShareDefine.SuccType_EquipWeapon,
|
ShareDefine.SuccType_InlayRune,
|
ShareDefine.SuccType_RuneLvUp,
|
ShareDefine.SuccType_RealmlvUp,
|
ShareDefine.SuccType_PetClassLV,
|
ShareDefine.SuccType_InlayStone1,
|
ShareDefine.SuccType_InlayStone2,
|
ShareDefine.SuccType_XJMJGetExp,
|
ShareDefine.SuccType_EquipWashLV1,
|
ShareDefine.SuccType_EquipWashLV2,
|
ShareDefine.SuccType_EquipWashLV3,
|
ShareDefine.SuccType_EquipWing,
|
ShareDefine.SuccType_MWSkillUp,
|
ShareDefine.SuccType_EquipSuit,
|
ShareDefine.SuccType_FamilyTechLV,
|
ShareDefine.SuccType_AlchemyLV,
|
ShareDefine.SuccType_VIPLV,
|
ShareDefine.SuccType_StoneTotalLV,
|
ShareDefine.SuccType_XBXZ,
|
ShareDefine.SuccType_DogzBattle,
|
ShareDefine.SuccType_DogzEquipPlus,
|
ShareDefine.SuccType_MainTaskNode,
|
ShareDefine.SuccType_InlayGatherSoul,
|
ShareDefine.SuccType_GatherSoulLvUp,
|
]
|
|
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:
|
if succType == ShareDefine.SuccType_GetMagicWeapon:
|
|
for i in xrange(ipyDataMgr.GetTreasureCount()):
|
treasureIpyData = ipyDataMgr.GetTreasureByIndex(i)
|
magicWeaponID = treasureIpyData.GetID()
|
isActive = PlayerMagicWeapon.GetIsActiveMagicWeapon(curPlayer, magicWeaponID)
|
if not isActive:
|
continue
|
curMWLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MagicWeaponLV % magicWeaponID)
|
for lv in xrange(curMWLV+1):
|
DoAddSuccessProgress(curPlayer, succType, 1, [magicWeaponID, lv])
|
elif succType == ShareDefine.SuccType_PassRuneTower:
|
passlv = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_TrialTower_PassLV)
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_PassRuneTower, 1, [passlv])
|
elif succType == ShareDefine.SuccType_GodWeapon:
|
maxType = ipyDataMgr.GetGodWeaponByIndex(ipyDataMgr.GetGodWeaponCount()-1).GetType()
|
for i in xrange(1, maxType + 1):
|
weaponLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GodWeaponLV % i)
|
UptateSuccessProgress(curPlayer, succType, weaponLV, [i])
|
elif succType == ShareDefine.SuccType_HorseAllLV:
|
ResetSuccessByType(curPlayer, succType)
|
for i in xrange(ipyDataMgr.GetHorseCount()):
|
ipyData = ipyDataMgr.GetHorseByIndex(i)
|
index = ipyData.GetHorseID()
|
lv = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Horser_LV % index, 0, ChConfig.Def_PDictType_Horse)
|
if not lv:
|
continue
|
for rlv in xrange(1, lv+1):
|
DoAddSuccessProgress(curPlayer, succType, 1, [index, rlv])
|
elif succType == ShareDefine.SuccType_EquipPlusLV:
|
ResetSuccessByType(curPlayer, succType)
|
for pType, indexList in ChConfig.Pack_EquipPart_CanPlusStar.items():
|
for i in indexList:
|
equipPartStarLV = ChEquip.GetEquipPartStarLV(curPlayer, pType, i)
|
for pluslv in xrange(1, equipPartStarLV+1):
|
DoAddSuccessProgress(curPlayer, succType, 1, [pluslv])
|
|
elif succType in [ShareDefine.SuccType_EquipColorItem, ShareDefine.SuccType_EquipArmor, ShareDefine.SuccType_EquipWeapon, ShareDefine.SuccType_EquipWing]:
|
DoEquipSuccessLogic(curPlayer)
|
elif succType in [ShareDefine.SuccType_InlayRune, ShareDefine.SuccType_RuneLvUp]:
|
PlayerRune.DoRuneSuccessLogic(curPlayer)
|
elif succType in [ShareDefine.SuccType_InlayGatherSoul, ShareDefine.SuccType_GatherSoulLvUp]:
|
PlayerGatherSoul.DoGatherSoulSuccessLogic(curPlayer)
|
elif succType == ShareDefine.SuccType_RealmlvUp:
|
UptateSuccessProgress(curPlayer, succType, curPlayer.GetOfficialRank())
|
elif succType == ShareDefine.SuccType_PetClassLV:
|
ResetSuccessByType(curPlayer, succType)
|
petDataPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptPet)
|
for petDataIndex in range(petDataPack.GetCount()):
|
petItem = petDataPack.GetAt(petDataIndex)
|
if petItem.IsEmpty():
|
continue
|
petNPCID = petItem.GetUserAttr(ShareDefine.Def_IudetPet_NPCID)
|
classLV = petItem.GetUserAttr(ShareDefine.Def_IudetPet_ClassLV)
|
for lv in xrange(classLV+1):
|
DoAddSuccessProgress(curPlayer, succType, 1, [petNPCID, lv+1])
|
|
elif succType in [ShareDefine.SuccType_InlayStone1, ShareDefine.SuccType_InlayStone2, ShareDefine.SuccType_StoneTotalLV]:
|
Operate_EquipStone.DoStoneSuccess(curPlayer)
|
elif succType == ShareDefine.SuccType_XJMJGetExp:
|
expPointRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_BZZD_TotalFightExpPoint)
|
DoAddSuccessProgress(curPlayer, succType, 1, [expPointRecord])
|
elif succType in [ShareDefine.SuccType_EquipWashLV1,ShareDefine.SuccType_EquipWashLV2,ShareDefine.SuccType_EquipWashLV3]:
|
Operate_EquipWash.EquipWashSuccess(curPlayer)
|
elif succType == ShareDefine.SuccType_MWSkillUp:
|
skillManager = curPlayer.GetSkillManager()
|
for i in range(0, skillManager.GetSkillCount()):
|
curSkill = skillManager.GetSkillByIndex(i)
|
if curSkill.GetFuncType() in [ChConfig.Def_SkillFuncType_FbSkill,ChConfig.Def_SkillFuncType_FbSPSkill]:
|
curSkillLV = curSkill.GetSkillLV()
|
UptateSuccessProgress(curPlayer, succType, curSkillLV, [curSkill.GetSkillTypeID()])
|
|
elif succType == ShareDefine.SuccType_EquipSuit:
|
Operate_EquipSuitCompose.DoSuiteSuccess(curPlayer)
|
elif succType == ShareDefine.SuccType_FamilyTechLV:
|
techNeedLVDict = IpyGameDataPY.GetFuncEvalCfg('FamilyTechNeedLV', 1, {})
|
techIDList = techNeedLVDict.keys()
|
for techID in techIDList:
|
techLV = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyTechLV % techID)
|
UptateSuccessProgress(curPlayer, succType, techLV, [techID])
|
elif succType == ShareDefine.SuccType_AlchemyLV:
|
alchemyLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_AlchemyLV)
|
UptateSuccessProgress(curPlayer, succType, alchemyLV)
|
elif succType == ShareDefine.SuccType_VIPLV:
|
DoAddSuccessProgress(curPlayer, succType, 1, [curPlayer.GetVIPLv()])
|
elif succType == ShareDefine.SuccType_XBXZ:
|
ResetSuccessByType(curPlayer, succType)
|
for i in xrange(ipyDataMgr.GetXBXZCount()):
|
ipyData = ipyDataMgr.GetXBXZByIndex(i)
|
if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_XBXZAwardRecord, ipyData.GetID()):
|
DoAddSuccessProgress(curPlayer, succType, 1, [ipyData.GetMWID()])
|
|
elif succType == ShareDefine.SuccType_DogzBattle:
|
for i in xrange(ipyDataMgr.GetDogzCount()):
|
ipyData = ipyDataMgr.GetDogzByIndex(i)
|
if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_DogzFightState, i):
|
DoAddSuccessProgress(curPlayer, succType, 1, [ipyData.GetDogzID()])
|
|
elif succType == ShareDefine.SuccType_DogzEquipPlus:
|
ResetSuccessByType(curPlayer, succType)
|
DoAddSuccessProgress(curPlayer, succType, PlayerDogz.GetFightDogzTotalPlusLv(curPlayer))
|
elif succType == ShareDefine.SuccType_MainTaskNode: #Ö»ÄÜ´¦ÀíÖ÷ÏßÈÎÎñ
|
succInfoList = GetSuccDataMng().GetSuccDataByType(succType)
|
for succData in succInfoList:
|
missionID = succData.condition[0]
|
if QuestCommon.GetHadFinishMainMission(curPlayer, missionID):
|
DoAddSuccessProgress(curPlayer, succType, 1, [missionID])
|
|
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
|
|
## ³É¾Í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):
|
#Íæ¼Òµ±Ç°¿É×°±¸µÄ×°±¸ÀàÐÍ
|
ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipColorItem)
|
ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipArmor)
|
ResetSuccessByType(curPlayer, ShareDefine.SuccType_EquipWeapon)
|
|
packType = IPY_GameWorld.rptEquip
|
|
playerEquip = curPlayer.GetItemManager().GetPack(packType)
|
for equipIndex in xrange(playerEquip.GetCount()):
|
if equipIndex not in ShareDefine.RoleEquipType :
|
continue
|
|
curEquip = playerEquip.GetAt(equipIndex)
|
if curEquip.IsEmpty():
|
continue
|
itemColor = curEquip.GetUserAttr(ShareDefine.Def_IudetItemColor)
|
if not itemColor:
|
itemColor = curEquip.GetItemColor()
|
|
itemQuality = curEquip.GetItemQuality()
|
classLV = ItemCommon.GetItemClassLV(curEquip)
|
if equipIndex not in [ShareDefine.retWing,ShareDefine.retGuard,ShareDefine.retHorse]:
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipColorItem, 1, [classLV, itemColor])
|
if equipIndex in ChConfig.BaseEquipPlace_Weapon:
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipWeapon, 1, [itemColor, itemQuality, classLV])
|
elif equipIndex in ChConfig.BaseEquipPlace_Armor:
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipArmor, 1, [itemColor, itemQuality, classLV])
|
|
elif equipIndex == ShareDefine.retWing:
|
DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_EquipWing, 1, [classLV, itemColor])
|
return
|
|
|
## ¸üгɾÍÍê³É½ø¶ÈÂß¼(Íⲿ¹¦Äܵ÷Óã¬Ö»ÊÊÓÃÓÚ²»ÖØÖõijɾÍÀàÐÍ)
|
# @param curPlayer
|
# @param successType: ³É¾ÍÀàÐÍ
|
# @param newCnt: нø¶ÈÖµ
|
# @return
|
def UptateSuccessProgress(curPlayer, successType, newCnt, condition=[]):
|
if successType not in ShareDefine.SuccessTypeList:
|
return
|
succInfoList = GetSuccDataMng().GetSuccDataByType(successType)
|
if not succInfoList:
|
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
|
|
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
|
for i, num in enumerate(cond):
|
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())
|
|
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
|
|
#// A5 42 ÁìÈ¡³É¾Í½±Àø #tagMCGetSuccessAward
|
#
|
#struct tagMCGetSuccessAward
|
#{
|
# tagHead Head;
|
# DWORD SuccID; //³É¾ÍID
|
#};
|
## ÁìÈ¡³É¾Í½±Àø
|
# @param None
|
# @return
|
def OnGetSuccessAward(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
succID = clientData.SuccID
|
__DoGetSuccTypeIndexAward(curPlayer, succID)
|
return
|
|
## Áìȡij¸ö³É¾Í½±Àø
|
# @param None
|
# @return
|
def __DoGetSuccTypeIndexAward(curPlayer, succID, isGiveItem=True):
|
GameWorld.DebugLog("ÁìÈ¡³É¾Í½±ÀøsuccID=%s" % (succID))
|
|
succData = GetSuccDataMng().GetSuccessData(succID)
|
if not succData:
|
GameWorld.DebugLog(" ³É¾ÍÊý¾Ý²»´æÔÚ£¡succID=%s" % (succID))
|
return
|
|
finishTime = GetSuccIsFinish(curPlayer, succID)
|
if finishTime <= 0:
|
GameWorld.DebugLog(" ¸Ã³É¾ÍδÍê³É£¡")
|
return
|
|
if GetSuccHasGot(curPlayer, succID):
|
GameWorld.DebugLog(" ¸Ã³É¾Í½±ÀøÒѾÁìÈ¡¹ý£¡")
|
return
|
|
if not succData.hasAward:
|
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:
|
packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem)
|
needSpace = len(itemDict)
|
if needSpace > packSpace:
|
PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")
|
return
|
|
# ¸üÐÂÁì½±¼Ç¼
|
SetSuccHasGot(curPlayer, succID)
|
|
# ¸øÎïÆ·
|
if isGiveItem:
|
for itemID, itemCnt in itemDict.items():
|
isPutIn = ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, 1,
|
[IPY_GameWorld.rptItem, IPY_GameWorld.rptAnyWhere], True)
|
|
#¸øÇ®
|
for moneyType, value in succData.moneyDict.items():
|
PlayerControl.GiveMoney(curPlayer, 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))
|
return itemDict
|
|
|
|
## ֪ͨ³É¾Í¶ÔÓ¦½±ÀøÁì½±¼Ç¼
|
# @param None
|
# @return
|
def Sync_SuccTypeIndexAwardRecord(curPlayer, succIDList=[], isSyncZero=False):
|
if succIDList:
|
recordIndexList = []
|
for succID in succIDList:
|
recordIndexList.append(succID / 31)
|
else:
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
succCnt = ipyDataMgr.GetSuccessCount()
|
if not succCnt:
|
return
|
maxSuccid = ipyDataMgr.GetSuccessByIndex(succCnt-1).GetID()
|
recordIndexList = range(maxSuccid / 31+1)
|
|
succFARPack = ChPyNetSendPack.tagMCSuccessFinishAwardRecordList()
|
succFARPack.Clear()
|
succFARPack.RecordList = []
|
for i in recordIndexList:
|
awardRecord=curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Success_AwardRecord%i)
|
if not isSyncZero and not awardRecord:
|
continue
|
recordInfo = ChPyNetSendPack.tagMCSuccessFinishAwardRecord()
|
recordInfo.RecordIndex = i
|
recordInfo.Record = awardRecord
|
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
|
