SnxxServerCode.git

			@@ -24,7 +24,7 @@
			import SkillShell
			import BuffSkill
			import BaseAttack
			import PlayerTruck
			import ChNetSendPack
			import SkillCommon
			import AttackCommon
			import ItemControler
			@@ -47,13 +47,17 @@
			import BossHurtMng
			import PlayerSuperMarket
			import GameLogic_FamilyInvade
			#import GameLogic_MunekadoTrial
			import GameLogic_GatherSoul
			import FormulaControl
			import PlayerMagicWeapon
			import PlayerBossReborn
			import PlayerFairyCeremony
			import PlayerNewFairyCeremony
			import PlayerWeekParty
			import PlayerActLogin
			import FamilyRobBoss
			import IpyGameDataPY
			import PlayerState
			import PyGameData
			import PlayerTeam
			import PlayerVip
			@@ -159,6 +163,11 @@
			# 根据平均等级
			elif lvStrengthenType == 1:
			strengthenLV = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenAverageLV)
			# 根据按成长等级的上下限随机
			elif lvStrengthenType == 4:
			randMinLV = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenMinLV)
			randMaxLV = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenMaxLV)
			strengthenLV = random.randint(randMinLV, randMaxLV)

			if strengthenIpyData.GetCmpNPCBaseLV():
			strengthenLV = max(strengthenLV, curNPC.GetLV())
			@@ -209,6 +218,62 @@
			curNPC.Notify_HPEx()
			curNPC.Notify_MaxHPEx()
			#GameWorld.DebugLog(" aftHP=%s,aftMaxHP=%s" % (aftHP, aftMaxHP))

			# 机器人复活初始化给技能
			if isReborn and curNPC.GetType() == ChConfig.ntRobot:
			__OnFBRobotReborn(curNPC, strengthenLV)

			return

			def __OnFBRobotReborn(curNPC, npcLV):
			tick = GameWorld.GetGameWorld().GetTick()
			lineID = GameWorld.GetGameWorld().GetLineID()
			objID = curNPC.GetID()
			jobSkillDict = IpyGameDataPY.GetFuncEvalCfg("FBRobotCfg", 1)
			robotJob = random.choice(jobSkillDict.keys())
			lineRobotJobDict = PyGameData.g_fbRobotJobDict.get(lineID, {})
			lineRobotJobDict[objID] = robotJob
			PyGameData.g_fbRobotJobDict[lineID] = lineRobotJobDict
			skillInfoDict = jobSkillDict[robotJob]
			skillIDList = []
			for skillInfo, needLV in skillInfoDict.items():
			if npcLV < needLV:
			continue
			if isinstance(skillInfo, int):
			skillIDList.append(skillInfo)
			else:
			skillIDList += list(skillInfo)
			GameWorld.DebugLog("给机器人NPC技能: objID=%s,robotJob=%s,npcLV=%s, %s" % (objID, robotJob, npcLV, skillIDList))
			skillManager = curNPC.GetSkillManager()
			for skillID in skillIDList:
			skillManager.LearnSkillByID(skillID)
			playerManager = GameWorld.GetMapCopyPlayerManager()
			for index in xrange(playerManager.GetPlayerCount()):
			curPlayer = playerManager.GetPlayerByIndex(index)
			if not curPlayer:
			continue
			FBLogic.DoFBHelp(curPlayer, tick)
			return


			def __DoGiveVSPlayerNPCSkill(curNPC, job, npcLV):
			skillManager = curNPC.GetSkillManager()
			jobSkillDict = IpyGameDataPY.GetFuncEvalCfg("XMZZRobotSkill", 1)
			if job not in jobSkillDict:
			return
			skillInfoDict = jobSkillDict[job]
			#{1:{(100, 101, 102, 103):1, 50000:100, 50100:200, 50400:300}, 2:{(200, 201, 202, 203):1, 55000:100, 55100:200, 55200:300}}
			skillIDList = []
			for skillInfo, needLV in skillInfoDict.items():
			if npcLV < needLV:
			continue
			if isinstance(skillInfo, int):
			skillIDList.append(skillInfo)
			else:
			skillIDList += list(skillInfo)
			GameWorld.DebugLog("给NPC技能: job=%s,npcLV=%s, %s" % (job, npcLV, skillIDList))
			for skillID in skillIDList:
			skillManager.LearnSkillByID(skillID)
			return

			def GetNPCStrengthenAttrDict(npcID, strengthenLV=0, strengthenPlayerCnt=0, strengthenIpyData=None):
			@@ -224,7 +289,7 @@

			attrDict = {}
			paramDict = attrStrengthenInfo[NPCAttr_ParamDict] # 过程参数公式字典
			attrStrengthenList = attrStrengthenInfo[NPCAttr_AttrStrengthenList] # 属性成长公式字典
			attrStrengthenDict = attrStrengthenInfo[NPCAttr_AttrStrengthenList] # 属性成长公式字典
			playerCntCoefficient = attrStrengthenInfo[NPCAttr_PlayerCntCoefficient] # 人数系数
			npcIDPlayerCntCoefficient = attrStrengthenInfo[NPCAttr_NPCPlayerCntCoefficient] # 特殊NPC人数系数
			baseMaxHP = npcData.GetHPEx() * ShareDefine.Def_PerPointValue + npcData.GetHP()
			@@ -287,9 +352,10 @@
			paramDict["AtkReplyCoefficient"])) # 怪物攻击回复调整值
			MonterHurt = eval(FormulaControl.GetCompileFormula("NPCParam_MonterHurt", paramDict["MonterHurt"])) # 怪物固定伤害
			LostHPPerSecond = eval(FormulaControl.GetCompileFormula("NPCParam_LostHPPerSecond", paramDict["LostHPPerSecond"])) # 玩家每秒掉血量

			LVStrengthenMark = strengthenIpyData.GetLVStrengthenMark()
			attrStrengthenList = attrStrengthenDict.get(LVStrengthenMark, [])
			for attrKey, strengthenFormat in attrStrengthenList:
			strengthenValue = int(eval(FormulaControl.GetCompileFormula("NPCStrengthen_%s" % attrKey, strengthenFormat)))
			strengthenValue = int(eval(FormulaControl.GetCompileFormula("NPCStrengthen_%s_%s" % (attrKey,LVStrengthenMark), strengthenFormat)))
			#GameWorld.DebugLog(" %s=%s" % (attrKey, strengthenValue))
			locals()[attrKey] = strengthenValue # 创建该属性局部变量作为参数提供给后面属性计算时用
			attrDict[attrKey] = strengthenValue
			@@ -335,14 +401,14 @@
			return attrDict

			def GiveKillNPCDropPrize(curPlayer, mapID, npcCountDict, exp_rate=None, mailTypeKey=None, isMail=False,
			extraItemList=[], prizeMultiple=1, dropItemMapInfo=[]):
			extraItemList=[], prizeMultiple=1, dropItemMapInfo=[], curGrade=0):
			'''给玩家击杀NPC掉落奖励
			@param mapID: 击杀的NPC所在地图ID，注意次地图并不一定是玩家当前地图
			@param npcCountDict: 执行单次时所击杀的npc数量字典 {npcID:count, ...}
			@param exp_rate: 击杀怪物享受的经验比例
			@param mailTypeKey: 获取物品背包空间不足时发送的邮件模板key
			@param isMail: 是否强制发送邮件，若是则不考虑背包空间，否的话只在背包空间不足时才发送邮件
			@param extraItemList: 固定附加物品列表，如果需执行多次，则此固定产出列表需在外层处理好，内层不做多次执行处理。[[itemID, itemCount, isBind], ...]
			@param extraItemList: 固定附加物品列表，如果需执行多次，则此固定产出列表需在外层处理好，内层不做多次执行处理。[[itemID, itemCount, isAuctionItem], ...]
			@param prizeMultiple: 奖励倍值, 对所有奖励有效，等于击杀多次NPC，多倍附加物品
			'''
			if not exp_rate:
			@@ -352,7 +418,7 @@
			totalExp = 0
			totalMoney = 0
			itemCountDict = {}
			itemBindDict = {}
			auctionItemIDList = []

			if prizeMultiple > 1:
			hadDropItemKeyList, hadDropItemPlaceList = [], [] # 已经掉落过的物品集合key列表，已经掉落过的装备部位列表
			@@ -374,11 +440,11 @@

			# 掉落有概率因素，需多次执行
			for dCount in xrange(1, totalCount + 1):
			isKillCountDropEquipEx = dCount == 1 # 同一只NPC一次处理中多次击杀的情况，只算一次附加装备处理
			dropInfo = GetNPCDropInfo(curPlayer, mapID, npcID, isKillCountDropEquipEx=isKillCountDropEquipEx)
			isKillCountDrop = dCount == 1 # 同一只NPC一次处理中多次击杀的情况，只算一次附加装备处理
			dropInfo = GetNPCDropInfo(curPlayer, mapID, npcID, isKillCountDrop=isKillCountDrop, curGrade=curGrade)
			if not dropInfo:
			continue
			dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue = dropInfo
			dropIDList, auctionIDList, dropMoneyCnt, moneyValue = dropInfo
			totalMoney += (dropMoneyCnt * moneyValue)

			for itemID in dropIDList:
			@@ -410,12 +476,14 @@
			hadDropItemKeyList.append(itemKey)

			itemCountDict[itemID] = itemCountDict.get(itemID, 0) + 1
			itemBindDict[itemID] = dropIDBindDict.get(itemID, 1)
			if itemID in auctionIDList and itemID not in auctionItemIDList:
			auctionItemIDList.append(itemID)

			# 固定附加物品
			for itemID, itemCount, isBind in extraItemList:
			for itemID, itemCount, isAuctionItem in extraItemList:
			itemCountDict[itemID] = itemCountDict.get(itemID, 0) + itemCount * prizeMultiple
			itemBindDict[itemID] = isBind
			if isAuctionItem and itemID not in auctionItemIDList:
			auctionItemIDList.append(itemID)

			needSpace = 0
			prizeItemList = []
			@@ -425,26 +493,38 @@
			if not itemData:
			continue

			isBind = itemBindDict.get(itemID, 1)
			isAuctionItem = itemID in auctionItemIDList

			if ItemCommon.GetIsEquip(itemData):
			for _ in xrange(itemCount):
			curItem = ItemControler.GetOutPutItemObj(itemID, isBind=isBind)
			curItem = ItemControler.GetOutPutItemObj(itemID)
			if curItem:
			needSpace += 1
			prizeItemList.append(curItem)
			jsonItemList.append(ItemCommon.GetJsonItem(curItem))
			else:
			needSpace += int(math.ceil(itemCount / float(itemData.GetPackCount())))
			prizeItemList.append([itemID, itemCount, isBind])
			jsonItemList.append(ItemCommon.GetJsonItem([itemID, itemCount, isBind]))
			needSpace += ItemControler.GetItemNeedPackCount(IPY_GameWorld.rptItem, itemData, itemCount, isAuctionItem)
			prizeItemList.append([itemID, itemCount, isAuctionItem])
			jsonItemList.append(ItemCommon.GetJsonItem([itemID, itemCount, isAuctionItem]))
			#成就
			if not dropItemMapInfo:
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_PickUpItem, itemCount, [itemID])

			## 直接掉地板上
			if dropItemMapInfo:
			dropPosX, dropPosY, isOnlySelfSee = dropItemMapInfo
			dropPosX, dropPosY, isOnlySelfSee = dropItemMapInfo[:3]
			isDropDisperse = dropItemMapInfo[3] if len(dropItemMapInfo) > 3 else False # 堆叠的物品是否散开掉落
			if isDropDisperse:
			dropItemList = []
			for itemInfo in prizeItemList:
			if isinstance(itemInfo, list):
			itemID, itemCount, isAuctionItem = itemInfo
			for _ in xrange(itemCount):
			dropItemList.append([itemID, 1, isAuctionItem])
			else:
			dropItemList.append(itemInfo)
			else:
			dropItemList = prizeItemList
			index = 0
			playerID = curPlayer.GetPlayerID()
			gameMap = GameWorld.GetMap()
			@@ -456,14 +536,14 @@
			#玩家不可移动这个点
			continue

			if index > len(prizeItemList) - 1:
			if index > len(dropItemList) - 1:
			break

			curItem = prizeItemList[index]
			curItem = dropItemList[index]
			index += 1
			if isinstance(curItem, list):
			itemID, itemCount, isBind = curItem
			curItem = ItemControler.GetOutPutItemObj(itemID, itemCount, isBind)
			itemID, itemCount, isAuctionItem = curItem
			curItem = ItemControler.GetOutPutItemObj(itemID, itemCount, isAuctionItem)

			if not curItem:
			continue
			@@ -490,8 +570,8 @@
			event = [ChConfig.ItemGive_NPCDrop, False, {"NPCID":npcID}]
			for prizeItem in prizeItemList:
			if isinstance(prizeItem, list):
			itemID, itemCount, isBind = prizeItem
			ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isBind, [IPY_GameWorld.rptItem],
			itemID, itemCount, isAuctionItem = prizeItem
			ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem],
			event=event)
			else:
			ItemControler.DoLogic_PutItemInPack(curPlayer, prizeItem, event=event)
			@@ -573,13 +653,13 @@
			GameWorld.DebugLog("脱机挂杀怪掉落: npcID=%s,killCount=%s,itemJobList=%s,dropRatePlusValue=%s,equipDropRatePlus=%s,equipDropDoCountPlus=%s"
			% (npcID, killCount, itemJobList, dropRatePlusValue, equipDropRatePlus, equipDropDoCountPlus), playerID)

			dropEquipInfoList = [] # [(阶,颜色,部位集合key, 件数), ...]
			dropEquipInfoList = [] # [(阶,颜色, 件数), ...]
			# 1.装备只算饼图概率
			pieRateDoCnt = ipyDrop.GetPieRateDoCnt()
			if pieRateDoCnt and ipyDrop.GetPieRateDrop():
			pieRateDoCnt = __GetNPCDropDoCountChange(pieRateDoCnt, doCountRate + equipDropDoCountPlus, doCountAdd)
			pieRateDoCnt *= killCount
			pieRateDropList = ipyDrop.GetPieRateDrop() # [(概率,0),(概率,(阶,颜色,部位集合key)),...]
			pieRateDropList = ipyDrop.GetPieRateDrop() # [(概率,0),(概率,(阶,颜色)),...]
			if equipDropRatePlus:
			dropRateList = GameWorld.GetPlusPieList(pieRateDropList, equipDropRatePlus)
			GameWorld.DebugLog(" 装备配置饼图: %s,equipDropRatePlus=%s" % (pieRateDropList, equipDropRatePlus), playerID)
			@@ -596,50 +676,52 @@
			preRate = rate
			if not equipInfo:
			continue
			classLV, color, placeKey = equipInfo
			classLV, color = equipInfo
			totalRate = curRate * pieRateDoCnt # 总概率
			dropCount = totalRate / maxRate # 可掉落件数
			rateEx = totalRate % maxRate # 剩余概率
			if GameWorld.CanHappen(rateEx, maxRate):
			dropCount += 1
			GameWorld.DebugLog(" 装备掉率: curRate=%s,totalRate=%s,rateEx=%s,dropCount=%s,classLV=%s,color=%s,placeKey=%s"
			% (curRate, totalRate, rateEx, dropCount, classLV, color, placeKey), playerID)
			GameWorld.DebugLog(" 装备掉率: curRate=%s,totalRate=%s,rateEx=%s,dropCount=%s,classLV=%s,color=%s"
			% (curRate, totalRate, rateEx, dropCount, classLV, color), playerID)
			if not dropCount:
			continue
			dropEquipInfoList.append([classLV, color, placeKey, dropCount])
			GameWorld.DebugLog(" 装备掉落结果: killCount=%s,[阶,颜色,部位集合,件数]=%s" % (killCount, dropEquipInfoList), playerID)
			dropEquipInfoList.append([classLV, color, dropCount])
			GameWorld.DebugLog(" 装备掉落结果: killCount=%s,[阶,颜色,件数]=%s" % (killCount, dropEquipInfoList), playerID)

			placeDict = IpyGameDataPY.GetFuncCfg("EquipDropPartSets", 1)

			# 颜色对应星级概率
			placeKeyListDict = IpyGameDataPY.GetFuncCfg("EquipDropPartSets", 1)
			colorSuitRateDict = ipyDrop.GetEquipColorSuitInfo() # 装备颜色对应套装概率 {颜色:套装概率, ...}
			colorSuitPlaceKeyInfoDict = ipyDrop.GetEquipPartKeyRateInfo() # 装备部位集合信息 {(颜色,是否套装):部位集合key, ...}
			dropEquipIDDict = {}
			colorStarRateDict = ipyDrop.GetEquipStarInfo() # {颜色:[(概率, 星级),...], ...}, 没有配置的默认最低星紫-0，橙红-1
			for classLV, color, placeKey, dropCount in dropEquipInfoList:
			if placeKey not in placeDict:
			GameWorld.ErrLog("部位集合key不存在!npcID=%s,placeKey=%s" % (npcID, placeKey))
			continue
			starCountDict = {} # {星级:件数, ...}
			placeList = placeDict[placeKey]
			if color in colorStarRateDict:
			colorStarRateList = colorStarRateDict[color]
			for classLV, color, dropCount in dropEquipInfoList:
			suitCountDict = {} # {套装:件数, ...}
			if color in colorSuitRateDict:
			suitRate = colorSuitRateDict[color]
			for _ in xrange(dropCount):
			star = GameWorld.GetResultByRandomList(colorStarRateList, 0) # 默认0星
			starCountDict[star] = starCountDict.get(star, 0) + 1
			elif color >= ChConfig.Def_Quality_Orange: # 橙色及以上的默认1星
			starCountDict[1] = dropCount
			isSuit = GameWorld.CanHappen(suitRate, maxRate=Def_NPCMaxDropRate)
			suitCountDict[isSuit] = suitCountDict.get(isSuit, 0) + 1
			else:
			starCountDict[0] = dropCount
			suitCountDict[0] = dropCount

			for star, curStarDropCount in starCountDict.items():
			randEquipIDList = __GetEquipIDList(npcID, classLV, color, placeList, star, itemJobList)
			for isSuit, curDropCount in suitCountDict.items():
			colorSuitKey = (color, isSuit)
			if colorSuitKey not in colorSuitPlaceKeyInfoDict:
			GameWorld.ErrLog("未配置颜色是否套装对应部位集合key! npcID=%s,color=%s,isSuit=%s" % (npcID, color, isSuit))
			continue
			placeKey = colorSuitPlaceKeyInfoDict[colorSuitKey]
			if placeKey not in placeKeyListDict:
			GameWorld.ErrLog("部位集合key不存在!npcID=%s,placeKey=%s" % (npcID, placeKey))
			continue
			placeList = placeKeyListDict[placeKey]
			randEquipIDList = __GetEquipIDList(npcID, classLV, color, isSuit, placeList, itemJobList)
			if not randEquipIDList:
			continue
			for _ in xrange(curStarDropCount):
			for _ in xrange(curDropCount):
			randItemID = random.choice(randEquipIDList)
			dropIDList.append(randItemID)
			dropEquipIDDict[randItemID] = [color, placeKey]
			GameWorld.DebugLog(" 掉落装备: npcID=%s,itemID=%s,classLV=%s,color=%s,star=%s,placeKey=%s,itemJobList=%s,randEquipIDList=%s"
			% (npcID, randItemID, classLV, color, star, placeKey, itemJobList, randEquipIDList), playerID)
			GameWorld.DebugLog(" 掉落装备: npcID=%s,itemID=%s,classLV=%s,color=%s,isSuit=%s,placeKey=%s,itemJobList=%s,randEquipIDList=%s"
			% (npcID, randItemID, classLV, color, isSuit, placeKey, itemJobList, randEquipIDList), playerID)

			# 2. 指定物品ID库
			itemIDDropRateDict = ipyDrop.GetItemIDDropRate() # {物品ID:概率, ...}
			@@ -665,10 +747,6 @@
			# 检查掉落互斥ID组
			dropIDList = __RemoveMutexDropID(dropIDList, IpyGameDataPY.GetFuncCfg("MutexDrop", 1))

			# 获取掉落物品绑定信息
			isGameBoss = ChConfig.IsGameBoss(npcData)
			dropIDBindDict = __GetNPCDropItemBindInfo(mapID, isGameBoss, dropIDList, dropEquipIDDict)

			# 掉落金币
			dropMoneyDoCnt = ipyDrop.GetDropMoneyDoCnt()
			dropMoneyRate = ipyDrop.GetDropMoneyRate()
			@@ -685,12 +763,18 @@
			for dropID in dropIDList:
			dropIDCountDict[dropID] = dropIDCountDict.get(dropID, 0) + 1

			auctionIDList = []
			if ipyDrop.GetAucionItemCanSell():
			for dropID in dropIDCountDict.keys():
			if IpyGameDataPY.GetIpyGameDataNotLog("AuctionItem", dropID):
			auctionIDList.append(dropID)

			if dropIDCountDict:
			GameWorld.DebugLog(" 最终掉落: npcID=%s,killCount=%s,dropIDCountDict=%s,dropIDBindDict=%s,dropMoney=%s"
			% (npcID, killCount, dropIDCountDict, dropIDBindDict, dropMoney), playerID)
			return dropIDCountDict, dropIDBindDict, dropMoney
			GameWorld.DebugLog(" 最终掉落: npcID=%s,killCount=%s,dropIDCountDict=%s,auctionIDList=%s,dropMoney=%s"
			% (npcID, killCount, dropIDCountDict, auctionIDList, dropMoney), playerID)
			return dropIDCountDict, auctionIDList, dropMoney

			def GetNPCDropInfo(dropPlayer, mapID, npcID, ownerPlayerList=[], ipyDrop=None, isSingle=True, isKillCountDropEquipEx=True):
			def GetNPCDropInfo(dropPlayer, mapID, npcID, ownerPlayerList=[], ipyDrop=None, isSingle=True, isKillCountDrop=True, curGrade=0):
			'''获取NPC掉落信息, 击杀及扫荡通用，调用该函数获得掉落信息，然后再看掉落地板上还是直接放入背包
			@param dropPlayer: 用于判断调用相关用的玩家示例，该玩家并不一定是击杀者，只是按一定规则设定的掉落判断依据的玩家
			如队伍，取等级最大的玩家，该玩家并不一定是击杀者
			@@ -698,11 +782,11 @@
			@param npcID: 掉落物品的NPCID
			@param ownerPlayerList: 有归属的玩家列表
			@param isSingle: 是否只处理单独玩家掉落逻辑，一般都默认True，目前只有场景杀怪掉落需要考虑摸怪的情况下才为False（外层特殊处理）
			@return: dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue
			@return: dropIDList, auctionIDList, dropMoneyCnt, moneyValue
			None-没有掉落
			---------------
			dropIDList - 掉落的物品ID列表, 同个itemID可能在列表中有多个 [itemID, itemID, ...]
			dropIDBindDict - 掉落的物品ID绑定信息 {itemID:是否绑定, ...}
			auctionIDList - 掉落的拍品物品ID列表, [itemID, itemID, ...]
			dropMoneyCnt - 掉落金币位置数
			moneyValue - 每个位置的金币数量
			'''
			@@ -727,21 +811,8 @@
			return

			dropIDList = [] # 掉落的ID列表
			dropIDBindDict = {}
			auctionIDList = []
			dropMoneyCnt, moneyValue = 0, 0

			# 1. 击杀次数掉落
			killCountDropIDList = []
			killCountDropInfo = ipyDrop.GetKillCountDrop()
			if isSingle and killCountDropInfo:
			needKillCount, isDropInItemPack, isBind, killDropItemList = killCountDropInfo
			killCountDropIDList = GetKillCountDropItemList(dropPlayer, npcID, needKillCount, killDropItemList)
			for kDropItemID in killCountDropIDList:
			dropIDList.append(kDropItemID) # 单独玩家掉落处理的，直接加到掉落列表里，不考虑是否放入背包或掉落的情况，由使用的功能自行处理
			dropIDBindDict[kDropItemID] = isBind
			#GameWorld.DebugLog("击杀次数掉落: kDropItemID=%s,needKillCount=%s,isDropInItemPack=%s,isBind=%s"
			# % (kDropItemID, needKillCount, isDropInItemPack, isBind))

			itemJobList = [dropPlayer.GetJob()] if ipyDrop.GetIsDropJobSelf() else IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1) # 掉落装备职业列表

			# 通用掉率相关
			@@ -752,12 +823,23 @@
			doCountRate = ChConfig.Def_MaxRateValue

			# 归属者相关信息
			dropEquipExKillCount = 0 # 装备附加掉落综合击杀次数，取次数最少的那个，至少第一次
			tagJob = 0
			dropEquipKillCountPub = 0 # 装备附加掉落综合击杀次数，取次数最大的那个，至少第一次
			dropItemIDKillCountPub = 0 # 物品ID附加掉落综合击杀次数，取次数最大的那个，至少第一次
			equipDropRatePlus = 0 # 装备掉落概率提升
			equipDropDoCountPlus = 0 # 装备掉落执行次数提升
			for ownerPlayer in ownerPlayerList:
			ownerKillCount = ownerPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCount % npcID) + 1
			dropEquipExKillCount = ownerKillCount if not dropEquipExKillCount else min(dropEquipExKillCount, ownerKillCount)
			killCountValue = ownerPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCount % npcID)
			equipPubKillCount = killCountValue % 100 + 1
			itemIDPubKillCount = killCountValue % 10000 / 100 + 1

			if dropEquipKillCountPub < equipPubKillCount:
			dropEquipKillCountPub = equipPubKillCount
			tagJob = ownerPlayer.GetJob()

			if dropItemIDKillCountPub < itemIDPubKillCount:
			dropItemIDKillCountPub = itemIDPubKillCount

			equipDropRatePlus = max(equipDropRatePlus, PlayerControl.GetDropEquipPer(ownerPlayer))
			equipDropDoCountPlus = max(equipDropDoCountPlus, PlayerControl.GetDropEquipDoCount(ownerPlayer))

			@@ -771,189 +853,138 @@
			#GameWorld.DebugLog("NPC掉落: npcID=%s,itemJobList=%s,dropRatePlusValue=%s,equipDropRatePlus=%s,equipDropDoCountPlus=%s,doCountRate=%s,doCountAdd=%s"
			# % (npcID, itemJobList, dropRatePlusValue, equipDropRatePlus, equipDropDoCountPlus, doCountRate, doCountAdd), playerID)

			dropEquipInfoList = [] # [(阶,颜色,部位集合key), ...]
			# 2. 装备库 - 饼图概率
			dropEquipInfoList = [] # [(阶,颜色), ...]
			# 1. 装备库 - 饼图概率
			pieRateDoCnt = ipyDrop.GetPieRateDoCnt()
			if pieRateDoCnt:
			pieRateDoCnt = __GetNPCDropDoCountChange(pieRateDoCnt, doCountRate + equipDropDoCountPlus, doCountAdd)
			dropEquipInfoList += __GetNPCPieRateEquipDrop(ipyDrop, pieRateDoCnt, equipDropRatePlus)

			# 3. 装备库 - 独立概率
			# 2. 装备库 - 独立概率
			indepRateDoCnt = ipyDrop.GetIndepRateDoCnt()
			if indepRateDoCnt:
			indepRateDoCnt = __GetNPCDropDoCountChange(indepRateDoCnt, doCountRate + equipDropDoCountPlus, doCountAdd)
			dropEquipInfoList += __GetNPCIndepRateEquipDrop(ipyDrop, indepRateDoCnt, equipDropRatePlus)

			#GameWorld.DebugLog("阶,颜色,部位集合key,dropEquipInfoList=%s" % (dropEquipInfoList))
			placeDict = IpyGameDataPY.GetFuncCfg("EquipDropPartSets", 1)
			# 第x次击杀，附加装备产出; 前x次击杀，附加装备产出; 归属者综合附加掉落，所有归属者都增加击杀次数；
			# [次数,阶,颜色,[(概率,星级),...],部位集合key]
			killCountDropEquipEx, killCountDropEquipEx2 = ipyDrop.GetKillCountDropEquipEx(), ipyDrop.GetKillCountDropEquipEx2()
			isKillCountDropEquipEx = isKillCountDropEquipEx and (killCountDropEquipEx or killCountDropEquipEx2)
			if isKillCountDropEquipEx and killCountDropEquipEx and dropEquipExKillCount == killCountDropEquipEx[0]: # 优先第x次击杀
			tagKillCount, tagClassLV, tagColor, tagStarRateList, tagPlaceKey = killCountDropEquipEx
			elif isKillCountDropEquipEx and killCountDropEquipEx2 and dropEquipExKillCount <= killCountDropEquipEx2[0]: # 前x次击杀
			tagKillCount, tagClassLV, tagColor, tagStarRateList, tagPlaceKey = killCountDropEquipEx2
			else:
			tagKillCount, tagClassLV, tagColor, tagStarRateList, tagPlaceKey = 0, 0, 0, [], 0
			maxRecordKillCount = tagKillCount # 需要记录的最大击杀次数, 超过此击杀次数后暂时不累加记录
			if tagStarRateList:
			tagStar = GameWorld.GetResultByRandomList(tagStarRateList, 0)
			tagStarMin = tagStarRateList[0][1]
			else:
			tagStar = None # 有0星的情况，所以这里默认使用None
			tagStarMin = None
			tagPlaceList = [] if tagPlaceKey not in placeDict else placeDict[tagPlaceKey]
			tagPlace = 0
			tagJob = 0
			tagItemReplaceState = False
			dropEquipInfoList += __GetNPCIndepRateEquipDrop(ipyDrop, indepRateDoCnt, equipDropRatePlus, curGrade)
			#GameWorld.DebugLog("阶,颜色 key,dropEquipInfoList=%s" % (dropEquipInfoList))

			# 附加装备部位优先级分两个列表, 品质阶级都不满足的列表、品质阶级部分满足的列表
			# 部位优先级规则, 只算身上有穿的部位，没穿装备的不管
			#1）优先品质、阶数、星级都不满足，其次品质、阶数、星级部分满足
			#2）品质、阶数、星级都不满足时，按品质、阶数、星级、评分升序排序
			#3）品质、阶数、星级部分满足时，按品质、阶数、星级、评分升序排序
			#4）品质、阶数、星级都满足时，排除优先部位
			tagPlaceSortList, tagPlaceSortList2 = [], []
			for ownerPlayer in ownerPlayerList:
			# 有附加目标装备需求的，统计该归属者身上需要附加给装备的部位
			playerEquip = ownerPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
			if tagClassLV and tagColor and tagPlaceList:
			for equipIndex in xrange(playerEquip.GetCount()):
			if equipIndex not in tagPlaceList:
			continue
			curEquip = playerEquip.GetAt(equipIndex)
			if curEquip.IsEmpty():
			continue
			curEquipClassLV = ItemCommon.GetItemClassLV(curEquip)
			curEquipColor = curEquip.GetItemColor()
			curEquipStar = curEquip.GetItemQuality()
			equipGS = ItemCommon.GetEquipGearScore(curEquip)
			# 品质阶级都不满足
			if curEquipClassLV < tagClassLV and curEquipColor < tagColor and curEquipStar < tagStarMin:
			tagPlaceSortList.append([curEquipColor, curEquipClassLV, curEquipStar, equipGS, equipIndex, ownerPlayer.GetJob()])
			# 品质阶级部分不满足
			elif curEquipClassLV < tagClassLV or curEquipColor < tagColor or curEquipStar < tagStarMin:
			tagPlaceSortList2.append([curEquipColor, curEquipClassLV, curEquipStar, equipGS, equipIndex, ownerPlayer.GetJob()])

			# 增加击杀次数
			killCount = ownerPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCount % npcID) + 1
			if killCount <= maxRecordKillCount:
			PlayerControl.NomalDictSetProperty(ownerPlayer, ChConfig.Def_PDict_NPCKillCount % npcID, killCount)
			GameWorld.DebugLog("玩家击杀次数: npcID=%s,killCount=%s,maxRecordKillCount=%s"
			% (npcID, killCount, maxRecordKillCount), ownerPlayer.GetPlayerID())

			tagPlaceSortList.sort() # 升序排序
			tagPlaceSortList2.sort() # 升序排序
			if isKillCountDropEquipEx:
			GameWorld.DebugLog("都不满足目标装备的优先级信息: npcID=%s, 数量=%s, 颜色,阶,星,评分,部位,职业=%s" % (npcID, len(tagPlaceSortList), tagPlaceSortList), playerID)
			GameWorld.DebugLog("部分满足目标装备的优先级信息: npcID=%s, 数量=%s, 颜色,阶,星,评分,部位,职业=%s" % (npcID, len(tagPlaceSortList2), tagPlaceSortList2), playerID)
			if tagPlaceSortList or tagPlaceSortList2:
			isOptimalPlace = IpyGameDataPY.GetFuncCfg("DropEquipPlaceMode", 1) # 是否取最优解部位
			if isOptimalPlace:
			tagPlaceSortList += tagPlaceSortList2
			if tagPlaceSortList:
			tagPlace = tagPlaceSortList[0][-2]
			tagJob = tagPlaceSortList[0][-1]
			GameWorld.DebugLog("掉落目标部位取最优解: tagPlace=%s,tagJob=%s" % (tagPlace, tagJob), playerID)
			# 3. 第x次击杀，归属者公共附加掉落，所有归属者都增加击杀次数；
			tagClassLV, tagColor, tagIsSuit, tagPlaceKey = 0, 0, 0, 0
			killCountDropEquipPub = ipyDrop.GetKillCountDropEquipPub() # 第x次击杀附加必掉装备 {次数:[阶,颜色,是否套装,部位集合key], ...}
			killCountDropItemPub = ipyDrop.GetKillCountDropPub() # 击杀次数必掉（公共）{击杀次数:[[物品ID, ...], [随机物品ID, ...]], ...}
			maxRecordDropEquipKillCountPub = 0 if not killCountDropEquipPub else max(killCountDropEquipPub) # 需要记录的最大击杀次数, 超过此击杀次数后暂时不累加记录
			maxRecordDropItemIDKillCountPub = 0 if not killCountDropItemPub else max(killCountDropItemPub)
			#GameWorld.DebugLog("maxRecordDropEquipKillCountPub=%s,maxRecordDropItemIDKillCountPub=%s" % (maxRecordDropEquipKillCountPub, maxRecordDropItemIDKillCountPub))
			#GameWorld.DebugLog("dropEquipKillCountPub=%s,dropItemIDKillCountPub=%s" % (dropEquipKillCountPub, dropItemIDKillCountPub))
			if isKillCountDrop and killCountDropEquipPub and dropEquipKillCountPub in killCountDropEquipPub:
			tagClassLV, tagColor, tagIsSuit, tagPlaceKey = killCountDropEquipPub[dropEquipKillCountPub]
			if (tagClassLV, tagColor) not in dropEquipInfoList:
			dropEquipInfoList.insert(0, (tagClassLV, tagColor, tagIsSuit, tagPlaceKey, tagJob))
			else:
			randPlaceCountLimit = IpyGameDataPY.GetFuncCfg("DropEquipPlaceMode", 2) # 全不满足目标条件部位有几个时才优先随机
			if len(tagPlaceSortList) < randPlaceCountLimit:
			tagPlaceSortList += tagPlaceSortList2
			else:
			GameWorld.DebugLog("优先随机都不满足目标装备的,randPlaceCountLimit=%s" % randPlaceCountLimit, playerID)
			randPlaceIndex = random.randint(0, len(tagPlaceSortList) - 1)
			GameWorld.DebugLog("掉落目标部位随机, randPlaceIndex=%s, 颜色,阶,星,评分,部位,职业=%s" % (randPlaceIndex, tagPlaceSortList), playerID)
			tagPlace = tagPlaceSortList[randPlaceIndex][-2]
			tagJob = tagPlaceSortList[randPlaceIndex][-1]
			GameWorld.DebugLog("掉落目标部位随机不满足条件的: tagPlace=%s,tagJob=%s" % (tagPlace, tagJob), playerID)
			tagIndex = dropEquipInfoList.index((tagClassLV, tagColor))
			dropEquipInfoList[tagIndex] = (tagClassLV, tagColor, tagIsSuit, tagPlaceKey, tagJob)
			GameWorld.DebugLog("第%s次击杀掉落指定目标装备信息: npcID=%s,tagClassLV=%s,tagColor=%s,tagIsSuit=%s,tagPlaceKey=%s,tagJob=%s,dropEquipInfoList=%s"
			% (dropEquipKillCountPub, npcID, tagClassLV, tagColor, tagIsSuit, tagPlaceKey, tagJob, dropEquipInfoList), playerID)
			elif isKillCountDrop and killCountDropItemPub and dropItemIDKillCountPub in killCountDropItemPub:
			killCountItemIDList, killCountRandItemIDList = killCountDropItemPub[dropItemIDKillCountPub]
			if killCountItemIDList:
			dropIDList += killCountItemIDList
			if killCountRandItemIDList:
			klllCountRandItemID = random.choice(killCountRandItemIDList)
			dropIDList.append(klllCountRandItemID)
			GameWorld.DebugLog("第%s次击杀掉落指定目标物品信息: npcID=%s,killCountItemIDList=%s,killCountRandItemIDList=%s,dropIDList=%s"
			% (dropItemIDKillCountPub, npcID, killCountItemIDList, killCountRandItemIDList, dropIDList), playerID)

			if isKillCountDropEquipEx:
			GameWorld.DebugLog("附加掉落指定目标装备信息: npcID=%s,玩家最少的击杀次数=%s,目标击杀数=%s,tagClassLV=%s,tagColor=%s,tagStar=%s,tagStarMin=%s,tagPlace=%s,tagJob=%s"
			% (npcID, dropEquipExKillCount, tagKillCount, tagClassLV, tagColor, tagStar, tagStarMin, tagPlace, tagJob), playerID)
			# 颜色对应星级概率
			dropEquipIDDict = {}
			colorStarRateDict = ipyDrop.GetEquipStarInfo() # {颜色:[(概率, 星级),...], ...}, 没有配置的默认最低星紫-0，橙红-1
			gradeColorStarRateDict = {}
			fbGradeColorStarRateDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate", 2) # 评级影响品质星级概率 {npcID:{(颜色,星级):[D级影响概率, ..., S级影响概率], ...}, ...}
			if npcID in fbGradeColorStarRateDict:
			gradeColorStarRateDict = fbGradeColorStarRateDict[npcID]
			curGrade = GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)
			for ownerPlayer in ownerPlayerList:
			# 增加击杀次数
			killCountValue = ownerPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCount % npcID)
			equipPubKillCount = killCountValue % 100
			itemIDPubKillCount = killCountValue % 10000 / 100
			isUpd = False
			if equipPubKillCount < maxRecordDropEquipKillCountPub:
			equipPubKillCount += 1
			isUpd = True
			if itemIDPubKillCount < maxRecordDropItemIDKillCountPub:
			itemIDPubKillCount += 1
			isUpd = True

			if isUpd:
			itemIDPriKillCount = killCountValue / 10000
			updKillCountValue = itemIDPriKillCount * 10000 + itemIDPubKillCount * 100 + equipPubKillCount
			PlayerControl.NomalDictSetProperty(ownerPlayer, ChConfig.Def_PDict_NPCKillCount % npcID, updKillCountValue)
			GameWorld.DebugLog("更新玩家击杀次数值: npcID=%s,killCountValue=%s,updKillCountValue=%s" % (npcID, killCountValue, updKillCountValue), ownerPlayer.GetPlayerID())

			gradeColorSuitRateDict = {}
			fbGradeColorSuitRateDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate", 2) # 评级影响颜色套装概率 {npcID:{颜色:[D级影响概率, ..., S级影响概率], ...}, ...}
			if npcID in fbGradeColorSuitRateDict:
			gradeColorSuitRateDict = fbGradeColorSuitRateDict[npcID]
			curGrade = curGrade if curGrade else GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)

			placeKeyListDict = IpyGameDataPY.GetFuncCfg("EquipDropPartSets", 1)
			colorDropCntDict = {} # 装备颜色已经掉落数 {颜色:数量, ...}
			colorMaxDropCntDict = ipyDrop.GetIndepRateMaxDropCount() # {颜色:上限数量,...}
			for classLV, color, placeKey in dropEquipInfoList:

			# 装备颜色对应最大掉落件数改为公共限制条件
			colorMaxDropCntDict = ipyDrop.GetEquipColorMaxDropCount() # {颜色:上限数量,...}
			colorSuitRateDict = ipyDrop.GetEquipColorSuitInfo() # 装备颜色对应套装概率 {颜色:套装概率, ...}
			colorSuitPlaceKeyInfoDict = ipyDrop.GetEquipPartKeyRateInfo() # 装备部位集合信息 {(颜色,是否套装):部位集合key, ...}
			for dropEquipInfo in dropEquipInfoList:
			classLV, color = dropEquipInfo[:2]
			if color in colorMaxDropCntDict:
			maxCount = colorMaxDropCntDict[color]
			dropCount = colorDropCntDict.get(color, 0)
			if dropCount >= maxCount:
			GameWorld.DebugLog("已超过该颜色装备最大掉落数，不掉！color=%s,maxCount=%s" % (color, maxCount), playerID)
			continue
			colorDropCntDict[color] = dropCount + 1

			# 有附加目标装备时，如果常规掉落有产出同颜色的且还没替换过则直接替换该装备
			if tagColor == color and tagClassLV and tagStar != None and tagPlace and not tagItemReplaceState:
			tagItemReplaceState = True
			randEquipIDList = __GetEquipIDList(npcID, tagClassLV, tagColor, tagPlaceList, tagStar, [tagJob], tagPlace)
			if not randEquipIDList:
			continue
			randItemID = random.choice(randEquipIDList)
			dropIDList.append(randItemID)
			dropEquipIDDict[randItemID] = [tagColor, tagPlaceKey]
			GameWorld.DebugLog("替换指定颜色装备: npcID=%s,itemID=%s,tagClassLV=%s,tagColor=%s,tagPlace=%s,tagStar=%s,tagJob=%s,randEquipIDList=%s"
			% (npcID, randItemID, tagClassLV, tagColor, tagPlace, tagStar, tagJob, randEquipIDList), playerID)
			if len(dropEquipInfo) == 5:
			isSuit, placeKey, tagJob = dropEquipInfo[2:]
			jobList = [tagJob]
			else:
			if placeKey not in placeDict:
			GameWorld.ErrLog("部位集合key不存在!npcID=%s,placeKey=%s" % (npcID, placeKey))
			isSuit = 0
			if color in colorSuitRateDict:
			suitRate = colorSuitRateDict[color]
			# 评级对套装率的影响
			if color in gradeColorSuitRateDict:
			suitRateEffList = gradeColorSuitRateDict[color]
			suitRateEff = 10000 if (curGrade <= 0 or curGrade > len(suitRateEffList)) else suitRateEffList[curGrade - 1]
			suitRate = int(suitRate * suitRateEff / 10000.0)
			isSuit = GameWorld.CanHappen(suitRate, maxRate=Def_NPCMaxDropRate)
			colorSuitKey = (color, isSuit)
			if colorSuitKey not in colorSuitPlaceKeyInfoDict:
			GameWorld.ErrLog("未配置颜色是否套装对应部位集合key! npcID=%s,color=%s,isSuit=%s" % (npcID, color, isSuit))
			continue
			placeList = placeDict[placeKey]
			if color in colorStarRateDict:
			colorStarRateList = colorStarRateDict[color]
			if gradeColorStarRateDict:
			colorStarRateList = __GetFBGradeColorStarRateList(color, colorStarRateList, gradeColorStarRateDict, curGrade)
			star = GameWorld.GetResultByRandomList(colorStarRateList, 0) # 默认0星
			elif color >= ChConfig.Def_Quality_Orange: # 橙色及以上的默认1星
			star = 1
			else:
			star = 0

			randEquipIDList = __GetEquipIDList(npcID, classLV, color, placeList, star, itemJobList)
			if not randEquipIDList:
			continue
			randItemID = random.choice(randEquipIDList)
			dropIDList.append(randItemID)
			dropEquipIDDict[randItemID] = [color, placeKey]
			GameWorld.DebugLog("掉落装备: npcID=%s,itemID=%s,classLV=%s,color=%s,star=%s,placeKey=%s,itemJobList=%s,randEquipIDList=%s"
			% (npcID, randItemID, classLV, color, star, placeKey, itemJobList, randEquipIDList), playerID)

			# 如果没有替换指定装备，则指定装备直接当做附加赠送掉落给
			if not tagItemReplaceState and tagClassLV and tagColor and tagStar != None and tagPlace:
			randEquipIDList = __GetEquipIDList(npcID, tagClassLV, tagColor, tagPlaceList, tagStar, [tagJob], tagPlace)
			if randEquipIDList:
			randItemID = random.choice(randEquipIDList)
			dropIDList.append(randItemID)
			dropEquipIDDict[randItemID] = [tagColor, tagPlaceKey]
			GameWorld.DebugLog("掉落指定目标装备: npcID=%s,itemID=%s,tagClassLV=%s,tagColor=%s,tagStar=%s,tagPlace=%s,tagJob=%s,randEquipIDList=%s"
			% (npcID, randItemID, tagClassLV, tagColor, tagStar, tagPlace, tagJob, randEquipIDList), playerID)
			placeKey = colorSuitPlaceKeyInfoDict[colorSuitKey]
			jobList = itemJobList
			if placeKey not in placeKeyListDict:
			GameWorld.ErrLog("部位集合key不存在!npcID=%s,placeKey=%s" % (npcID, placeKey))
			continue
			placeList = placeKeyListDict[placeKey]
			randEquipIDList = __GetEquipIDList(npcID, classLV, color, isSuit, placeList, jobList)
			if not randEquipIDList:
			continue
			if color in colorMaxDropCntDict:
			colorDropCntDict[color] = dropCount + 1
			randItemID = random.choice(randEquipIDList)
			dropIDList.append(randItemID)
			GameWorld.DebugLog("掉落装备: npcID=%s,itemID=%s,classLV=%s,color=%s,isSuit=%s,placeKey=%s,jobList=%s,randEquipIDList=%s"
			% (npcID, randItemID, classLV, color, isSuit, placeKey, jobList, randEquipIDList), playerID)

			# 4. 指定物品ID库
			dropIDList += __GetAppointDropItemIDList(dropPlayer, npcID, ipyDrop, doCountRate, doCountAdd)

			# 检查掉落互斥ID组
			dropIDList = __RemoveMutexDropID(dropIDList, IpyGameDataPY.GetFuncCfg("MutexDrop", 1))

			# 获取掉落物品绑定信息
			isGameBoss = ChConfig.IsGameBoss(npcData)
			dropIDBindDict = __GetNPCDropItemBindInfo(mapID, isGameBoss, dropIDList, dropEquipIDDict)

			# 5. 私有掉落固定产出，所有掉落归属者每人一份，默认绑定，不区分职业
			# 5. 私有掉落
			if isSingle:
			# 击杀次数掉落
			killCountDropInfo = ipyDrop.GetKillCountDropPri()
			if killCountDropInfo:
			needKillCount, killDropItemList = killCountDropInfo[:2]
			killCountDropIDList = GetKillCountDropItemList(dropPlayer, npcID, needKillCount, killDropItemList)
			for kDropItemID in killCountDropIDList:
			dropIDList.append(kDropItemID) # 单独玩家掉落处理的，直接加到掉落列表里，不考虑是否放入背包或掉落的情况，由使用的功能自行处理
			#GameWorld.DebugLog("击杀次数掉落: kDropItemID=%s,needKillCount=%s" % (kDropItemID, needKillCount))

			# 固定产出，所有掉落归属者每人一份，默认绑定，不区分职业
			fbGradePriItemIDDropDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate", 3)
			if npcID in fbGradePriItemIDDropDict:
			gradePriItemIDDropDict = fbGradePriItemIDDropDict[npcID]
			curGrade = GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)
			curGrade = curGrade if curGrade else GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)
			priDropInfoList = gradePriItemIDDropDict.get(curGrade, [])
			priDropIDList = []
			for priItemID, priItemCount in priDropInfoList:
			@@ -962,12 +993,11 @@
			priDropIDList = ipyDrop.GetPriItemIDDrop()
			for priDropID in priDropIDList:
			dropIDList.append(priDropID)
			dropIDBindDict[priDropID] = 1
			#GameWorld.DebugLog("私有物品掉落: priDropID=%s" % priDropID)

			# 检查掉落互斥ID组
			dropIDList = __RemoveMutexDropID(dropIDList, IpyGameDataPY.GetFuncCfg("MutexDrop", 1))

			if dropIDList:
			GameWorld.DebugLog("最终掉落物品: npcID=%s,dropIDList=%s,dropIDBindDict=%s" % (npcID, dropIDList, dropIDBindDict), playerID)

			# 掉落金币
			dropMoneyDoCnt = ipyDrop.GetDropMoneyDoCnt()
			dropMoneyRate = ipyDrop.GetDropMoneyRate()
			@@ -984,90 +1014,16 @@
			moneyValue = __GetDropMoneyValue(dropPlayer, ipyDrop)
			#GameWorld.DebugLog(" 掉落金币value=%s" % (moneyValue))

			if not dropIDList and isGameBoss:
			if dropIDList:
			if ipyDrop.GetAucionItemCanSell():
			for dropID in dropIDList:
			if IpyGameDataPY.GetIpyGameDataNotLog("AuctionItem", dropID):
			auctionIDList.append(dropID)
			GameWorld.DebugLog("最终掉落物品: npcID=%s,dropIDList=%s" % (npcID, dropIDList), playerID)
			GameWorld.DebugLog(" auctionIDList=%s" % (auctionIDList), playerID)
			elif ChConfig.IsGameBoss(npcData):
			GameWorld.ErrLog("Boss没有掉落物品,NPCID=%s" % (npcID), dropPlayer.GetPlayerID())
			return dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue

			def __GetFBGradeColorStarRateList(color, colorStarRateList, gradeColorStarRateDict, curGrade):
			# {(颜色,星级):[D级影响概率, ..., S级影响概率], ...}
			newRateList = []
			commKey = (color, 0) # 代表都影响
			for i, rateInfo in enumerate(colorStarRateList):
			rate, star = rateInfo

			if i == 0:
			srcRate = rate
			else:
			srcRate = rate - colorStarRateList[i - 1][0]

			key = (color, star)
			if not star:
			newRate = srcRate
			elif key in gradeColorStarRateDict:
			starRateList = gradeColorStarRateDict[key]
			starRate = 10000 if (curGrade <= 0 or curGrade > len(starRateList)) else starRateList[curGrade - 1]
			newRate = int(srcRate * starRate / 10000.0)
			elif commKey in gradeColorStarRateDict:
			starRateList = gradeColorStarRateDict[commKey]
			starRate = 10000 if (curGrade <= 0 or curGrade > len(starRateList)) else starRateList[curGrade - 1]
			newRate = int(srcRate * starRate / 10000.0)
			else:
			newRate = srcRate

			if not newRateList:
			newRateList.append([newRate, star])
			else:
			newRateList.append([newRateList[-1][0] + newRate, star])

			#GameWorld.DebugLog(" 副本评级影响颜色品质星级: color=%s,源=%s" % (color, colorStarRateList))
			#GameWorld.DebugLog(" curGrade=%s,gradeColorStarRateDict=%s" % (curGrade, gradeColorStarRateDict))
			#GameWorld.DebugLog(" newRateList=%s" % (newRateList))
			return newRateList

			def __GetNPCDropItemBindInfo(mapID, isGameBoss, dropIDList, dropEquipIDDict):
			## 获取NPC掉落物品绑定信息字典
			mapID = FBCommon.GetRecordMapID(mapID)

			unBindEquipPlaceKeyList = IpyGameDataPY.GetFuncCfg("EquipDropBindingRule", 3) # 非绑定部位集合key [部位集合key1, 部位集合key2, ...]
			defaultMaxBindColor = IpyGameDataPY.GetFuncCfg("EquipDropBindingRule", 2) # 默认绑定最高颜色

			bossDropBindIDList = IpyGameDataPY.GetFuncCfg("BossDropBindingRule", 1) # Boss掉落绑定的物品ID: [ID1, ID2, ...]
			monsterDropNoBindIDList = IpyGameDataPY.GetFuncCfg("MonsterDropBindingRule", 1) # 小怪掉落不绑定的物品ID: [ID1, ID2, ...]

			mapDropBindDict = IpyGameDataPY.GetFuncCfg("MapDropBindRule", 1) # 地图掉落是否绑定：{MapID:是否绑定, ...}
			mapDropItemNoBindDict = IpyGameDataPY.GetFuncCfg("MapDropItemNoBind", 1) # 地图掉落不绑定物品ID：{MapID:[ID1, ID2, ...],...}
			mapDropItemBindDict = IpyGameDataPY.GetFuncCfg("MapDropItemBind", 1) # 地图掉落绑定物品ID：{MapID:[ID1, ID2, ...],...}

			mapDropItemIsBind = mapDropBindDict.get(mapID, None)
			mapDropItemNoBindList = mapDropItemNoBindDict.get(mapID, [])
			mapDropItemBindList = mapDropItemBindDict.get(mapID, [])

			dropIDBindDict = {} # 掉落物品ID绑定字典 {物品ID:是否绑定, ...}
			for dropItemID in dropIDList:
			if dropItemID in dropIDBindDict:
			continue

			# 装备绑定规则判断
			if dropItemID in dropEquipIDDict:
			color, placeKey = dropEquipIDDict[dropItemID]
			isBind = placeKey not in unBindEquipPlaceKeyList and color <= defaultMaxBindColor

			# 非装备
			else:
			if dropItemID in mapDropItemBindList:
			isBind = True
			elif dropItemID in mapDropItemNoBindList:
			isBind = False
			elif mapDropItemIsBind != None:
			isBind = mapDropItemIsBind
			elif isGameBoss:
			isBind = dropItemID in bossDropBindIDList
			else:
			isBind = dropItemID not in monsterDropNoBindIDList

			dropIDBindDict[dropItemID] = int(isBind)

			return dropIDBindDict
			return dropIDList, auctionIDList, dropMoneyCnt, moneyValue

			def __GetNPCDropDoCountChange(doCount, doCountRate, doCountAdd):
			## 获取掉落执行次数变更结果，可能增加或减少
			@@ -1107,6 +1063,8 @@
			# 1. 职业物品ID集合
			job = curPlayer.GetJob()
			JobItemDropSets = IpyGameDataPY.GetFuncCfg("JobItemDropSets", 1) # {物品ID集合key:[职业顺序物品ID列表], ...}
			itemDropSets = IpyGameDataPY.GetFuncCfg("JobItemDropSets", 2) # {物品ID集合key:[随机物品ID列表], ...}
			itemDropRateSets = IpyGameDataPY.GetFuncCfg("JobItemDropSets", 3) # {物品ID集合key:[随机物品ID饼图列表], ...}
			ItemKeyMaxDropCountDict = ipyDrop.GetItemKeyMaxDropCount() # {物品ID集合key:随机次数,...}

			# 1.1 只掉本职业的
			@@ -1137,20 +1095,14 @@
			# 1.2 随机掉落一个
			ItemKeyDropRateDict = ipyDrop.GetItemKeyDropRate() # {物品ID集合key:概率, ...}，随机掉一个，优先级低
			if ItemKeyDropRateDict:
			for jobItemKey, dropRate in ItemKeyDropRateDict.items():
			if jobItemKey not in JobItemDropSets:
			continue
			jobItemList = JobItemDropSets[jobItemKey]
			if len(jobItemList) < job:
			GameWorld.ErrLog("职业物品集合key没有配置对应职业ID: npcID=%s,jobItemKey=%s,job=%s" % (npcID, jobItemKey, job))
			continue
			for itemKey, dropRate in ItemKeyDropRateDict.items():
			# 在只掉本职业里的不处理
			if jobItemKey in ItemKeyDropRateJobDict:
			if itemKey in ItemKeyDropRateJobDict:
			continue
			mustDropCount = dropRate / Def_NPCMaxDropRate
			dropRate = dropRate % Def_NPCMaxDropRate # 基础概率
			canDropCount = mustDropCount
			doCnt = ItemKeyMaxDropCountDict.get(jobItemKey, 1) # 默认1个
			doCnt = ItemKeyMaxDropCountDict.get(itemKey, 1) # 默认1个
			doCnt = __GetNPCDropDoCountChange(doCnt, doCountRate, doCountAdd)
			for _ in xrange(doCnt):
			if not GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate):
			@@ -1158,9 +1110,20 @@
			canDropCount += 1

			for _ in xrange(canDropCount):
			randJobItemID = random.choice(jobItemList)
			dropItemIDList.append(randJobItemID)
			#GameWorld.DebugLog("掉落随机职业指定物品ID: jobItemKey=%s,randJobItemID=%s" % (jobItemKey, randJobItemID))
			if itemKey in itemDropRateSets:
			randItemRateList = itemDropRateSets[itemKey]
			randItemID = GameWorld.GetResultByRandomList(randItemRateList)
			#GameWorld.DebugLog("掉落饼图物品ID: itemKey=%s,randItemRateList=%s,randItemID=%s" % (itemKey, randItemRateList, randItemID))
			elif itemKey in itemDropSets:
			randItemList = itemDropSets[itemKey]
			randItemID = random.choice(randItemList)
			#GameWorld.DebugLog("掉落随机物品ID: itemKey=%s,randItemList=%s,randItemID=%s" % (itemKey, randItemList, randItemID))
			else:
			continue
			if not randItemID:
			continue
			dropItemIDList.append(randItemID)
			#GameWorld.DebugLog("掉落随机指定物品ID: itemKey=%s,randItemID=%s" % (itemKey, randItemID))

			# 2. 指定掉落ID处理, 受全局设定影响
			itemIDDropRateDict = ipyDrop.GetItemIDDropRate() # {物品ID:概率, ...}
			@@ -1227,17 +1190,17 @@
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "GlobalDropRate", msgInfo, len(msgInfo))

			# 4. 指定全服击杀次数必掉，算额外掉落
			globalKillDropDict = IpyGameDataPY.GetFuncEvalCfg("GlobalDropCD", 2) # {NPCID:{击杀次数:[是否本职业, [物品ID, ...], [随机物品ID, ...]]}, ...}
			globalKillDropDict = IpyGameDataPY.GetFuncEvalCfg("GlobalDropCD", 2) # {NPCID:{击杀次数:[是否本职业, {物品ID:个数, ...}, [[随机物品ID,个数], ...]]}, ...}
			if npcID in globalKillDropDict:
			killCountDropDict = globalKillDropDict[npcID]
			updNPCKilledCount = min(gw.GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_NPCKilledCount % npcID) + 1, ShareDefine.Def_UpperLimit_DWord)
			GameWorld.DebugLog("更新全服击杀次数： %s" % updNPCKilledCount)
			GameWorld.Log("更新全服击杀次数：npcID=%s, %s" % (npcID, updNPCKilledCount))
			# 通知GameServer记录
			msgInfo = str([npcID, updNPCKilledCount])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "GlobalKillCount", msgInfo, len(msgInfo))
			if updNPCKilledCount in killCountDropDict:
			isJobLimit, itemIDList, randItemIDList = killCountDropDict[updNPCKilledCount]
			for itemID in itemIDList:
			isJobLimit, itemIDCountDict, randItemIDCountList = killCountDropDict[updNPCKilledCount]
			for itemID, itemCount in itemIDCountDict.items():
			if isJobLimit:
			itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
			if not itemData:
			@@ -1247,12 +1210,12 @@
			# 非本职业可用，不掉落
			GameWorld.DebugLog("全服击杀次数必掉，非本职业可用，不掉落! itemID=%s" % itemID)
			continue
			dropItemIDList.append(itemID)
			GameWorld.DebugLog("全服击杀次数必掉物品: itemID=%s" % itemID)
			if randItemIDList:
			dropItemIDList += [itemID] * itemCount
			GameWorld.Log("全服击杀次数必掉物品: itemID=%s,itemCount=%s" % (itemID, itemCount))
			if randItemIDCountList:
			if isJobLimit:
			randJobItemList = []
			for rItemID in randItemIDList:
			for rItemID, rItemCount in randItemIDCountList:
			itemData = GameWorld.GetGameData().GetItemByTypeID(rItemID)
			if not itemData:
			continue
			@@ -1261,19 +1224,19 @@
			# 非本职业可用，不掉落
			GameWorld.DebugLog("全服击杀次数必掉随机，非本职业可用，不掉落! rItemID=%s" % rItemID)
			continue
			randJobItemList.append(rItemID)
			randItemID = random.choice(randJobItemList)
			randJobItemList.append([rItemID, rItemCount])
			randItemID, randItemCount = random.choice(randJobItemList)
			else:
			randItemID = random.choice(randItemIDList)
			dropItemIDList.append(randItemID)
			GameWorld.DebugLog("全服击杀次数必掉随机物品: randItemID=%s" % randItemID)
			randItemID, randItemCount = random.choice(randItemIDCountList)
			dropItemIDList += [randItemID] * randItemCount
			GameWorld.Log("全服击杀次数必掉随机物品: randItemID=%s,randItemCount=%s" % (randItemID, randItemCount))

			return dropItemIDList

			def __GetEquipIDList(npcID, classLV, color, placeList, star, itemJobList, tagPlace=None):
			def __GetEquipIDList(npcID, classLV, color, isSuit, placeList, itemJobList):
			#存一个满足要求的所有的物品的列表然后从当中随机选一个
			#注：阶、颜色、星、职业、部位，这5个条件可确认唯一一件装备
			key = "%s_%s_%s" % (classLV, color, star)
			#注：阶、颜色、套装ID、职业、部位，这5个条件可确认唯一一件装备
			key = "%s_%s" % (classLV, color)

			if key in PyGameData.g_filterEquipDict:
			filterItemIDDict = PyGameData.g_filterEquipDict[key]
			@@ -1294,37 +1257,39 @@
			continue
			if itemData.GetItemColor() != color:
			continue
			#if itemData.GetEquipPlace() not in placeList:
			# continue
			if itemData.GetItemQuality() != star:
			continue
			suiteID = itemData.GetSuiteID()
			itemJob = itemData.GetJobLimit() / 100
			itemPlace = itemData.GetEquipPlace()
			filterItemIDDict[(itemJob, itemPlace)] = itemData.GetItemTypeID()
			itemID = itemData.GetItemTypeID()
			if itemPlace not in filterItemIDDict:
			filterItemIDDict[itemPlace] = []
			placeItemList = filterItemIDDict[itemPlace]
			placeItemList.append([itemJob, suiteID, itemID])
			PyGameData.g_filterEquipDict[key] = filterItemIDDict
			GameWorld.Log("缓存掉落装备ID: classLV_color_star=%s, %s, %s" % (key, filterItemIDDict, PyGameData.g_filterEquipDict))
			GameWorld.Log("缓存掉落装备ID: classLV_color=%s, %s, %s" % (key, filterItemIDDict, PyGameData.g_filterEquipDict))

			itemIDList = []
			for itemJobPlace, itemID in filterItemIDDict.items():
			itemJob, itemPlace = itemJobPlace
			# 有职业限制的物品才需判断是否在可掉落的职业里
			if itemJob and itemJob not in itemJobList:
			for itemPlace, placeItemList in filterItemIDDict.items():
			if placeList and itemPlace not in placeList:
			continue
			if itemPlace not in placeList:
			continue
			if tagPlace != None and itemPlace != tagPlace:
			continue
			itemIDList.append(itemID)

			for itemInfo in placeItemList:
			itemJob, suiteID, itemID = itemInfo
			if itemJob and itemJobList and itemJob not in itemJobList:
			continue
			curIsSuit = suiteID > 0
			if curIsSuit != isSuit:
			continue
			itemIDList.append(itemID)

			if not itemIDList:
			GameWorld.ErrLog("找不到可掉落的装备ID: npcID=%s,classLV=%s,color=%s,star=%s,placeList=%s,tagPlace=%s,itemJobList=%s"
			% (npcID, classLV, color, star, placeList, tagPlace, itemJobList))
			GameWorld.ErrLog("找不到可掉落的装备ID: npcID=%s,classLV=%s,color=%s,isSuit=%s,placeList=%s,itemJobList=%s"
			% (npcID, classLV, color, isSuit, placeList, itemJobList))
			return itemIDList

			def __GetNPCPieRateEquipDrop(ipyDrop, doCnt, equipDropPlus):
			## 获取NPC饼图掉率装备掉落信息
			dropEquipInfoList = []
			pieRateDropList = ipyDrop.GetPieRateDrop() # [(概率,0),(概率,(阶,颜色,部位集合key)),...]
			pieRateDropList = ipyDrop.GetPieRateDrop() # 饼图概率掉落信息 [(概率,0),(概率,(阶,颜色)),...]
			dropRateList = pieRateDropList if not equipDropPlus else GameWorld.GetPlusPieList(pieRateDropList, equipDropPlus)
			#GameWorld.DebugLog("掉落饼图概率: %s, equipDropPlus=%s" % (pieRateDropList, equipDropPlus))
			#GameWorld.DebugLog("实际饼图概率: %s" % (dropRateList))
			@@ -1335,18 +1300,16 @@
			#GameWorld.DebugLog("饼图装备掉落结果: doCnt=%s, %s" % (doCnt, dropEquipInfoList))
			return dropEquipInfoList

			def __GetNPCIndepRateEquipDrop(ipyDrop, doCnt, equipDropPlus):
			def __GetNPCIndepRateEquipDrop(ipyDrop, doCnt, equipDropPlus, curGrade=0):
			## 获取NPC独立掉率装备掉落信息
			npcID = ipyDrop.GetNPCID()
			indepRateDict = ipyDrop.GetIndepRateDrop() # {(阶,颜色,部位集合key):概率,...}
			#colorMaxDropCntDict = ipyDrop.GetIndepRateMaxDropCount()
			#GameWorld.DebugLog("独立概率装备掉落处理: indepRateDict=%s,colorMaxDropCntDict=%s,equipDropPlus=%s"
			# % (indepRateDict, colorMaxDropCntDict, equipDropPlus))
			indepRateDict = ipyDrop.GetIndepRateDrop() # 独立概率掉落信息 {(阶,颜色):概率,...}
			#GameWorld.DebugLog("独立概率装备掉落处理: indepRateDict=%s,equipDropPlus=%s" % (indepRateDict, equipDropPlus))
			gradeColorRateDict = {}
			fbGradeColorRateDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate", 1) #{npcID:{颜色:[D级影响概率, ..., S级影响概率], ...}, ...}
			if npcID in fbGradeColorRateDict:
			gradeColorRateDict = fbGradeColorRateDict[npcID]
			curGrade = GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)
			curGrade = curGrade if curGrade else GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)

			#colorDropCntDict = {} # 装备颜色已经掉落数 {颜色:数量, ...}
			dropEquipInfoList = []
			@@ -1369,19 +1332,7 @@
			curDropCount += 1
			if not curDropCount:
			continue
			#掉落颜色对应件数上限提到外部，修改为作为掉落装备的公共限制条件
			#=======================================================================================
			# if color in colorMaxDropCntDict:
			# maxCount = colorMaxDropCntDict[color]
			# dropCount = colorDropCntDict.get(color, 0)
			# if dropCount >= maxCount:
			# #GameWorld.DebugLog(" 已超过该颜色装备最大掉落数，不掉！color=%s,maxCount=%s" % (color, maxCount))
			# continue
			# maxCanDropCount = maxCount - dropCount
			# curDropCount = min(curDropCount, maxCanDropCount)
			# colorDropCntDict[color] = dropCount + curDropCount
			# #GameWorld.DebugLog(" maxCanDropCount=%s,curDropCount=%s" % (maxCanDropCount, curDropCount))
			#=======================================================================================

			for _ in xrange(curDropCount):
			dropEquipInfoList.append(dropInfo)
			#GameWorld.DebugLog("独立概率装备掉落结果: doCnt=%s, %s" % (doCnt, dropEquipInfoList))
			@@ -1415,15 +1366,17 @@

			def GetKillCountDropItemList(curPlayer, npcID, needKillCount, killDropItemList):
			## 获取击杀次数额外掉落
			dropRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCountDrop % npcID)
			killCount = dropRecord / 10
			if dropRecord % 10:
			#GameWorld.DebugLog("杀掉次数已经掉落过! npcID=%s,killCount=%s,dropRecord=%s" % (npcID, killCount, dropRecord), curPlayer.GetPlayerID())
			killCountValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCKillCount % npcID)
			killCountPri = killCountValue / 10000
			if killCountPri >= needKillCount:
			#GameWorld.DebugLog("杀掉次数已经掉落过! npcID=%s,killCountValue=%s,dropRecord=%s" % (npcID, killCountValue, dropRecord), curPlayer.GetPlayerID())
			return []

			killCount += 1
			killCountPri += 1
			updRecordValue = killCountPri * 10000 + killCountValue % 10000

			jobDropInfo = []
			if killCount >= needKillCount:
			if killCountPri >= needKillCount:
			isJobLimit = 1
			#[itemID,...]
			for dropItemID in killDropItemList:
			@@ -1437,12 +1390,11 @@
			#GameWorld.DebugLog("非本职业可用，不掉落! dropItemID=%s" % dropItemID)
			continue
			jobDropInfo.append(dropItemID)
			recordValue = killCount * 10 + 1
			#GameWorld.DebugLog("击杀次数必掉落! npcID=%s,needKillCount=%s,jobDropInfo=%s,killDropItemList=%s,recordValue=%s"
			# % (npcID, needKillCount, jobDropInfo, killDropItemList, recordValue), curPlayer.GetPlayerID())
			else:
			recordValue = killCount * 10
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_NPCKillCountDrop % npcID, recordValue)
			GameWorld.DebugLog("击杀次数必掉落! npcID=%s,needKillCount=%s,jobDropInfo=%s,killDropItemList=%s,updRecordValue=%s"
			% (npcID, needKillCount, jobDropInfo, killDropItemList, updRecordValue), curPlayer.GetPlayerID())

			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_NPCKillCount % npcID, updRecordValue)
			GameWorld.DebugLog("更新击杀次数比掉落值: killCountValue=%s,killCountPri=%s,updRecordValue=%s" % (killCountValue, killCountPri, updRecordValue), curPlayer.GetPlayerID())
			return jobDropInfo
			######################################################################
			#---------------------------------------------------------------------
			@@ -1986,9 +1938,8 @@
			# 设置npc死亡及自身处理
			SetDeadEx(summonNPC)

			if curNPC.GetGameObjType() == IPY_GameWorld.gotNPC and \
			curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotSummon:
			FBLogic.DoFB_SummonNPCDead(curNPC)
			if curNPC.GetGameObjType() == IPY_GameWorld.gotNPC:
			FBLogic.DoFB_NPCDead(curNPC)

			summonPlayerID = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_SummonMapNPCPlayerID)
			if summonPlayerID > 0:
			@@ -1998,14 +1949,8 @@
			if ChConfig.IsGameBoss(curNPC):
			# 通知GameServer boss状态封魔坛在副本里单独处理
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog('BOSSInfo', npcid)
			if ipyData and ipyData.GetMapID() != ChConfig.Def_FBMapID_SealDemon:
			mapID = GameWorld.GetMap().GetMapID()
			lineID = GameWorld.GetGameWorld().GetLineID()
			msgList = [npcid, 0, mapID, lineID]
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'GameWorldBossState',
			'%s' % (msgList), len(str(msgList)))
			bosskey = ShareDefine.Def_Notify_WorldKey_GameWorldBossReborn % npcid
			GameWorld.GetGameWorld().SetGameWorldDict(bosskey, 0)
			if ipyData and ipyData.GetMapID() not in [ChConfig.Def_FBMapID_SealDemon, ChConfig.Def_FBMapID_ZhuXianBoss]:
			GameServe_GameWorldBossState(npcid, 0)
			#GameWorld.GetGameWorld().SetGameWorldDict(ChConfig.Map_NPC_WorldBossDeadTick % npcid, GameWorld.GetGameWorld().GetTick())
			#因为存在boss分流，所以用gameFB字典，但是存活状态还是用GameWorld字典
			GameWorld.GetGameFB().SetGameFBDict(ChConfig.Map_NPC_WorldBossDeadTick % npcid, GameWorld.GetGameWorld().GetTick())
			@@ -2019,20 +1964,91 @@
			AttackCommon.ClearTeamPlayerHurtValue(curNPC)
			# 清除自定义伤血列表
			#BossHurtMng.ClearHurtValueList(curNPC)

			if curNPC.GetType() == ChConfig.ntRobot:
			lineID = GameWorld.GetGameWorld().GetLineID()
			lineRobotJobDict = PyGameData.g_fbRobotJobDict.get(lineID, {})
			lineRobotJobDict.pop(curNPC.GetID(), 0)
			PyGameData.g_fbRobotJobDict[lineID] = lineRobotJobDict

			# C++设置npc死亡
			curNPC.SetDead(curNPC.GetDictByKey(ChConfig.Def_NPCDead_Reason),
			curNPC.GetDictByKey(ChConfig.Def_NPCDead_KillerType),
			curNPC.GetDictByKey(ChConfig.Def_NPCDead_KillerID))
			return

			def GameServer_KillGameWorldBoss(bossID, killerName, hurtValue, isNotify=True):
			isAddKillCnt = 0 # 页游逻辑，手游暂写死不增
			mapID = GameWorld.GetMap().GetMapID()
			killMsg = str([bossID, killerName, hurtValue, isAddKillCnt, isNotify, mapID])
			def GameServer_KillGameWorldBoss(bossID, killPlayerName, hurtValue, isNotify=True, killerIDList=[]):
			dataMapID = GameWorld.GetGameWorld().GetMapID()
			realMapID = GameWorld.GetGameWorld().GetRealMapID()
			copyMapID = GameWorld.GetGameWorld().GetCopyMapID()
			killMsg = str([bossID, killPlayerName, hurtValue, isNotify, realMapID, dataMapID, copyMapID, killerIDList])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'KillGameWorldBoss', killMsg, len(killMsg))
			GameWorld.DebugLog("Boss被击杀: bossID=%s,dataMapID=%s,realMapID=%s,copyMapID=%s,killerIDList=%s" % (bossID, dataMapID, realMapID, copyMapID, killerIDList))
			return

			def GameServe_GameWorldBossState(bossID, isAlive):
			dataMapID = GameWorld.GetGameWorld().GetMapID()
			realMapID = GameWorld.GetGameWorld().GetRealMapID()
			copyMapID = GameWorld.GetGameWorld().GetCopyMapID()
			stateMsg = str([bossID, isAlive, dataMapID, realMapID, copyMapID])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'GameWorldBossState', '%s' % stateMsg, len(stateMsg))
			GameWorld.DebugLog("Boss状态变更: bossID=%s,isAlive=%s,dataMapID=%s,realMapID=%s,copyMapID=%s"
			% (bossID, isAlive, dataMapID, realMapID, copyMapID))
			if not isAlive:
			if dataMapID in ChConfig.Def_CrossZoneMapTableName:
			tableName = ChConfig.Def_CrossZoneMapTableName[dataMapID]
			realMapID = GameWorld.GetGameWorld().GetRealMapID()
			copyMapID = GameWorld.GetGameWorld().GetCopyMapID()
			zoneIpyData = IpyGameDataPY.GetIpyGameData(tableName, realMapID, dataMapID, copyMapID)
			if not zoneIpyData:
			return
			zoneID = zoneIpyData.GetZoneID()
			GameWorld.GetGameWorld().SetGameWorldDict(ShareDefine.Def_Notify_WorldKey_GameWorldBossRebornCross % (zoneID, bossID), 0)
			else:
			GameWorld.GetGameWorld().SetGameWorldDict(ShareDefine.Def_Notify_WorldKey_GameWorldBossReborn % bossID, 0)
			return

			def OnPlayerKillBoss(curPlayer, npcID, mapID, isCrossServer):
			killBossCntLimitDict = IpyGameDataPY.GetFuncCfg('KillBossCntLimit', 1)
			limitIndex = GameWorld.GetDictValueByKey(killBossCntLimitDict, npcID)
			if limitIndex != None:
			#今日杀怪次数+1
			key = ChConfig.Def_PDict_Boss_KillCnt % limitIndex
			newCnt = curPlayer.NomalDictGetProperty(key, 0) + 1
			PlayerControl.NomalDictSetProperty(curPlayer, key, newCnt)
			BossHurtMng.NotifyAttackBossCnt(curPlayer, limitIndex)
			GameWorld.DebugLog("今日杀怪次数 playerID=%s, newCnt=%s" % (curPlayer.GetPlayerID(), newCnt))

			dataDict = {"objID":npcID, "bossID":npcID, "touchCnt":newCnt,
			"AccID":curPlayer.GetAccID(), "PlayerID":curPlayer.GetPlayerID()}
			DataRecordPack.SendEventPack("AddKillBossCnt", dataDict, curPlayer)
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillBoss, 1, [limitIndex])

			if isCrossServer:
			return

			if limitIndex == ShareDefine.Def_Boss_Func_World:
			# 世界BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillWorldBoss, 1)
			# 每日活动
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_WorldBOSS)
			PlayerBossReborn.AddBossRebornActionCnt(curPlayer, ChConfig.Def_BRAct_WorldBOSS, 1)
			PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_WorldBoss, 1)
			PlayerNewFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_WorldBoss, 1)
			PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_WorldBOSS, 1)
			PlayerActLogin.AddLoginAwardActionCnt(curPlayer, ChConfig.Def_LoginAct_WorldBOSS, 1)

			if mapID == ChConfig.Def_FBMapID_BossHome:
			#BOSS之家
			# BOSS之家BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillBossHomeBoss, 1)
			# 每日活动
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_BOSSHome)
			PlayerBossReborn.AddBossRebornActionCnt(curPlayer, ChConfig.Def_BRAct_BOSSHome, 1)
			PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_BossHome, 1)
			PlayerNewFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_BossHome, 1)
			PlayerWeekParty.AddWeekPartyActionCnt(curPlayer, ChConfig.Def_WPAct_BOSSHome, 1)
			return

			#################################################
			## NPC控制定义
			#
			@@ -2052,6 +2068,7 @@
			self.__Killer = None # 击杀者, 由各种规则得出, 一般也是物品归属的代表, 用于广播、记录等确保与归属一致
			self.__AllKillerDict = {} # 所有击杀的玩家ID对应字典, 非队伍, 一般也是归属的拥有者
			self.__FeelPlayerList = [] # 所有摸怪玩家列表，处理任务及某些逻辑用
			self.__ownerPlayerList = [] # 归属者列表

			self.__OwnerHurtType = 0
			self.__OwnerHurtID = 0
			@@ -2382,7 +2399,7 @@
			def GetIsBossView(self):
			# 主动视野情况，GetIsBoss 0 1 4 为普通NPC视野（有视野范围配置，但去除视野刷新），其他为BOSS类视野有刷新
			curNPC = self.__Instance
			if not ChConfig.IsGameBoss(curNPC) and not GetFaction(curNPC):
			if not ChConfig.IsGameBoss(curNPC) and not GetFaction(curNPC) and curNPC.GetType() != ChConfig.ntRobot:
			return False

			return True
			@@ -2881,6 +2898,10 @@
			# GameWorld.DebugLog("伤血玩家血量为0，清除该伤血!playerID=%s" % hurtID)
			# return True

			if hurtPlayer.GetInitOK() and not hurtPlayer.GetVisible():
			GameWorld.DebugLog("伤血玩家不可见，清除该伤血!playerID=%s" % hurtID)
			return True

			if not self.GetIsInRefreshPoint(hurtPlayer.GetPosX(), hurtPlayer.GetPosY(), refreshPoint):
			GameWorld.DebugLog("伤血玩家不在boss范围里，清除该伤血!playerID=%s" % hurtID)
			return True
			@@ -2914,6 +2935,10 @@
			#GameWorld.DebugLog("队员不在本线路，不计！playerID=%s" % playerID)
			continue

			if curTeamPlayer.GetInitOK() and not curTeamPlayer.GetVisible():
			#GameWorld.DebugLog("队员不可见，不计！playerID=%s" % playerID)
			continue

			if curTeamPlayer.GetHP() <= 0 or curTeamPlayer.GetPlayerAction() == IPY_GameWorld.paDie:
			deadTime = curTeamPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)
			if time.time() - deadTime >= IpyGameDataPY.GetFuncCfg("BossHurtValue", 1):
			@@ -2931,7 +2956,7 @@
			teamHurtPlayerIDList.append(playerID)

			if not teamHurtPlayerIDList:
			GameWorld.DebugLog("伤血队伍没有活着的队员在boss区域内，清除该伤血!teamID=%s,mapTeamPlayerIDList=%s" % (teamID, mapTeamPlayerIDList))
			GameWorld.DebugLog("伤血队伍没有符合条件的队员在boss区域内，清除该伤血!teamID=%s,mapTeamPlayerIDList=%s" % (teamID, mapTeamPlayerIDList))
			return teamHurtPlayerIDList

			def RefreshHurtList(self, tick, refreshInterval=3000):
			@@ -3305,7 +3330,12 @@
			#范围校验
			posMapX = posMap.GetPosX()
			posMapY = posMap.GetPosY()
			posMapArea = posMap.GetArea()

			if curNPC.GetType() == IPY_GameWorld.ntFunctionNPC: #功能NPC
			posMapArea = 0
			else:
			posMapArea = posMap.GetArea()

			#获取范围内一点可以移动的点
			posX, poxY = GameMap.GetNearbyPosByDis(posMapX, posMapY, posMapArea)

			@@ -3429,12 +3459,7 @@
			# 通知GameServer boss刷新成功
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog('BOSSInfo', curNPCID)
			if ipyData:
			mapID = GameWorld.GetMap().GetMapID()
			lineID = GameWorld.GetGameWorld().GetLineID()
			msgList = [curNPCID, 1, mapID, lineID]
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'GameWorldBossState',
			'%s' % (msgList), len(str(msgList)))

			GameServe_GameWorldBossState(curNPCID, 1)
			if GetDropOwnerType(curNPC) == ChConfig.DropOwnerType_Family:
			FamilyRobBoss.FamilyOwnerBossOnReborn(curNPC)

			@@ -3654,7 +3679,7 @@
			# @remarks 刷新NPC属性
			def RefreshNPCAttrState(self, canSyncClient=True, isReborn=False):
			curNPC = self.__Instance
			curNPCMaxHP_Before = GameObj.GetMaxHP(curNPC)
			#curNPCMaxHP_Before = GameObj.GetMaxHP(curNPC)
			#清空NPC战斗属性
			curNPC.ClearBattleEffect()
			#--------------------------------------------
			@@ -3691,6 +3716,28 @@

			return

			def SetHelpBattleRobotRebornAttr(self, fightPower):
			'''助战机器人只设置血量属性
			血量算法，（助战玩家=助战机器人）：每个副本配置伤害（助战玩家战力/副本规定战力）系数值系数值暂定为50
			'''
			curNPC = self.__Instance
			mapID = FBCommon.GetRecordMapID(GameWorld.GetMap().GetMapID())
			funcLineID = FBCommon.GetFBPropertyMark()
			ipyData = IpyGameDataPY.GetIpyGameData("FBHelpBattle", mapID, funcLineID)
			if not ipyData:
			return

			SetSuppressFightPower(curNPC, fightPower)
			fbFightPower = ipyData.GetFightPowerMin()
			baseHurt = ipyData.GetRobotBaseHurt()
			hpCoefficient = ipyData.GetRobotHPCoefficient()
			maxHP = int(eval(IpyGameDataPY.GetFuncCompileCfg("HelpBattleRobot", 2)))
			GameWorld.DebugLog("设置助战机器人属性: objID=%s,fightPower=%s,maxHP=%s" % (curNPC.GetID(), fightPower, maxHP))
			GameObj.SetMaxHP(curNPC, maxHP)
			GameObj.SetHP(curNPC, maxHP)
			curNPC.Notify_HPEx()
			curNPC.Notify_MaxHPEx()
			return

			# NPC移动速度特殊处理，只处理百分比不能处理固定值
			# 因为 ChConfig.TYPE_Calc_AttrSpeed 非服务端移动速度，偷懒处理法
			@@ -3701,11 +3748,13 @@
			if not speedPer:
			if curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_SpeedPer):
			curNPC.SetDict(ChConfig.Def_NPC_Dict_SpeedPer, 0)
			return
			speed = int(curNPC.GetSpeed() * (ShareDefine.Def_MaxRateValue) / max(100.0, float(ShareDefine.Def_MaxRateValue + speedPer)))

			curNPC.SetSpeed(speed)
			curNPC.SetDict(ChConfig.Def_NPC_Dict_SpeedPer, speedPer)
			else:
			speed = int(curNPC.GetSpeed() * (ShareDefine.Def_MaxRateValue) / max(100.0, float(ShareDefine.Def_MaxRateValue + speedPer)))
			curNPC.SetSpeed(speed)
			curNPC.SetDict(ChConfig.Def_NPC_Dict_SpeedPer, speedPer)
			if GameWorld.GetMap().GetMapID() == ChConfig.Def_FBMapID_GatherSoul:
			#目前只在聚魂副本里通知
			NPCSpeedChangeNotify(curNPC, curNPC.GetSpeed())
			return


			@@ -3715,7 +3764,6 @@
			# @remarks 刷新NPC行为属性
			def RefreshNPCActionState(self):
			curNPC = self.__Instance

			OperControlManager.ClearObjActionState(curNPC)

			#根据BUFF 加上状态
			@@ -3834,7 +3882,8 @@
			if GetDropOwnerType(curNPC) == ChConfig.DropOwnerType_Family:
			killerName = FamilyRobBoss.FamilyOwnerBossOnKilled(curNPC, self.__OwnerHurtID)
			#KillerJob = 0 if not self.__Killer else self.__Killer.GetJob()
			GameServer_KillGameWorldBoss(curNPC.GetNPCID(), killerName, 0)
			killerIDList = [player.GetPlayerID() for player in self.__ownerPlayerList]
			GameServer_KillGameWorldBoss(curNPC.GetNPCID(), killerName, 0, True, killerIDList)
			#===========================================================================================
			# # 暗金boss
			# if curNPC.GetIsBoss() == ChConfig.Def_NPCType_Boss_Dark:
			@@ -3919,16 +3968,36 @@
			return moneyID
			return moneyItemList[-1][1]

			def __NPCSpecialDropItem(self, ownerPlayerList, ipyDrop):
			def __NPCSpecialDropItem(self, dropPlayer, ownerPlayerList, ipyDrop):
			'''特殊掉落 (私有特殊掉落 + 击杀次数特殊掉落), 支持摸怪
			@return: None
			@return: [[ownerPlayer, itemID, isBind, isDropInItemPack], ...]
			@return: [[ownerPlayer, itemID, isAuctionItem, isDropInItemPack], ...]
			'''
			curNPC = self.__Instance
			npcID = curNPC.GetNPCID()
			specDropItemList = []

			playerLV = dropPlayer.GetLV()
			maxDropLV = ipyDrop.GetMaxDropLV()
			if maxDropLV and playerLV > maxDropLV:
			GameWorld.DebugLog("超过最大可掉落等级，不掉落物品，特殊掉落！npcID=%s,playerLV(%s) > maxDropLV(%s)" % (npcID, playerLV, maxDropLV))
			return specDropItemList

			auctionItemCanSell = ipyDrop.GetAucionItemCanSell()
			# 击杀次数掉落算摸怪
			killCountDropInfo = ipyDrop.GetKillCountDropPri()
			if killCountDropInfo:
			for feelPlayer in self.__FeelPlayerList:
			needKillCount, killDropItemList, isDropInItemPack = killCountDropInfo
			killCountDropItemList = GetKillCountDropItemList(feelPlayer, npcID, needKillCount, killDropItemList)
			for dropItemID in killCountDropItemList:
			isAuctionItem = 1 if auctionItemCanSell and IpyGameDataPY.GetIpyGameDataNotLog("AuctionItem", dropItemID) else 0
			specDropItemList.append([feelPlayer, dropItemID, isAuctionItem, isDropInItemPack])
			GameWorld.DebugLog("击杀次数必掉(可摸怪): npcID=%s,dropItemID=%s,needKillCount=%s,isDropInItemPack=%s,isAuctionItem=%s"
			% (npcID, dropItemID, needKillCount, isDropInItemPack, isAuctionItem), feelPlayer.GetPlayerID())

			# 私有掉落
			isDropInItemPack = False
			fbGradePriItemIDDropDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate", 3)
			if npcID in fbGradePriItemIDDropDict:
			gradePriItemIDDropDict = fbGradePriItemIDDropDict[npcID]
			@@ -3939,25 +4008,12 @@
			priDropIDList += [priItemID] * priItemCount
			else:
			priDropIDList = ipyDrop.GetPriItemIDDrop()

			# 击杀次数掉落算摸怪
			killCountDropInfo = ipyDrop.GetKillCountDrop()
			if killCountDropInfo:
			for feelPlayer in self.__FeelPlayerList:
			needKillCount, isDropInItemPack, isBind, killDropItemList = killCountDropInfo
			killCountDropItemList = GetKillCountDropItemList(feelPlayer, npcID, needKillCount, killDropItemList)
			for dropItemID in killCountDropItemList:
			specDropItemList.append([feelPlayer, dropItemID, isBind, isDropInItemPack])
			GameWorld.DebugLog("击杀次数必掉(可摸怪): npcID=%s,dropItemID=%s,needKillCount=%s,isDropInItemPack=%s,isBind=%s"
			% (npcID, dropItemID, needKillCount, isDropInItemPack, isBind), feelPlayer.GetPlayerID())

			# 私有掉落算归属
			for ownerPlayer in ownerPlayerList:

			for dropItemID in priDropIDList:
			specDropItemList.append([ownerPlayer, dropItemID, 1, False]) # 默认绑定
			for dropItemID in priDropIDList:
			isAuctionItem = 1 if auctionItemCanSell and IpyGameDataPY.GetIpyGameDataNotLog("AuctionItem", dropItemID) else 0
			for ownerPlayer in ownerPlayerList:
			specDropItemList.append([ownerPlayer, dropItemID, isAuctionItem, isDropInItemPack]) # 默认绑定
			#GameWorld.DebugLog("私有物品掉落: dropItemID=%s" % dropItemID, ownerPlayer.GetPlayerID())


			return specDropItemList

			def __NPCDropItemByPlayers(self, dropPlayerList, mapID, ipyDrop):
			@@ -3968,13 +4024,13 @@
			return

			#GameWorld.DebugLog("NPC多玩家混合掉落: dropPlayerCount=%s" % len(dropPlayerList))
			dropItemBindDict = {}
			auctionItemIDList = []
			dropItemList = []
			for dropPlayer in dropPlayerList:
			dropInfo = GetNPCDropInfo(dropPlayer, mapID, npcID, ipyDrop=ipyDrop)
			if not dropInfo:
			continue
			dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue = dropInfo
			dropIDList, auctionIDList, dropMoneyCnt, moneyValue = dropInfo
			moneyID = self.__GetDropMoneyModelID(moneyValue)
			if dropMoneyCnt:
			dropIDList += [moneyID] * dropMoneyCnt
			@@ -3983,7 +4039,7 @@
			#GameWorld.DebugLog(" dropPlayerID=%s,dropIDList=%s" % (dropPlayerID, dropIDList))
			for dropID in dropIDList:
			dropItemList.append([dropID, dropPlayerID])
			dropItemBindDict.update(dropIDBindDict)
			auctionItemIDList += auctionIDList

			#打乱物品顺序
			random.shuffle(dropItemList)
			@@ -4004,8 +4060,8 @@
			itemID, ownerID = dropItemList[index]
			index += 1
			itemCnt = moneyValue if itemID == moneyID else 1
			isBind = dropItemBindDict.get(itemID, 1)
			curItem = self.__CreateDropItem(curNPC, itemID, itemCnt, isBind)
			iaAuctionItem = itemID in auctionItemIDList
			curItem = self.__CreateDropItem(curNPC, itemID, itemCnt, iaAuctionItem, dropPlayer)
			if not curItem:
			continue
			self.__MapCreateItem(curItem, resultX, resultY, ChConfig.Def_NPCHurtTypePlayer, ownerID)
			@@ -4027,7 +4083,7 @@
			mapID = FBCommon.GetRecordMapID(mapID)
			isGameBoss = ChConfig.IsGameBoss(curNPC)
			if isGameBoss:
			GameWorld.Log("NPC开始掉落: npcID=%s,dropPlayerID=%s" % (npcID, dropPlayer.GetPlayerID()))
			GameWorld.Log("NPC开始掉落: npcID=%s,dropPlayerID=%s" % (npcID, dropPlayer.GetPlayerID()), dropPlayer.GetPlayerID())
			if mapID == ChConfig.Def_FBMapID_MunekadoTrial:
			return
			ipyDrop = GetNPCDropIpyData(npcID)
			@@ -4041,23 +4097,27 @@
			# dropPlayerList = GameLogic_MunekadoTrial.GetCanDropPlayerList()
			# return self.__NPCDropItemByPlayers(dropPlayerList, mapID, ipyDrop)

			dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue = [], {}, 0, 0
			dropIDList, auctionIDList, dropMoneyCnt, moneyValue = [], [], 0, 0
			dropInfo = GetNPCDropInfo(dropPlayer, mapID, npcID, ownerPlayerList, ipyDrop, False)
			if dropInfo:
			dropIDList, dropIDBindDict, dropMoneyCnt, moneyValue = dropInfo
			dropIDList, auctionIDList, dropMoneyCnt, moneyValue = dropInfo

			moneyID = self.__GetDropMoneyModelID(moneyValue)
			if moneyID and dropMoneyCnt:
			dropIDList += [moneyID] * dropMoneyCnt

			specItemSign = "SpecItem"
			playerSpecDropList = self.__NPCSpecialDropItem(ownerPlayerList, ipyDrop) # 特殊掉落 [[ownerPlayer, itemID, isBind, isDropInItemPack], ...] 私有特殊掉落 + 击杀次数特殊掉落
			playerSpecDropList = self.__NPCSpecialDropItem(dropPlayer, ownerPlayerList, ipyDrop) # 特殊掉落 [[ownerPlayer, itemID, isAuctionItem, isDropInItemPack], ...] 私有特殊掉落 + 击杀次数特殊掉落
			dropIDList += [specItemSign] * len(playerSpecDropList)

			if len(dropIDList) > 5:
			#打乱物品顺序
			random.shuffle(playerSpecDropList)
			random.shuffle(dropIDList)

			if not dropIDList and isGameBoss:
			GameWorld.ErrLog("Boss没有掉落: dropPlayerLV=%s,ipyWorldLV=%s,maxDropLV=%s"
			% (dropPlayer.GetLV(), ipyDrop.GetMaxWorldLV(), ipyDrop.GetMaxDropLV()), dropPlayer.GetPlayerID())

			gameMap = GameWorld.GetMap()
			dropPosX, dropPosY = curNPC.GetPosX(), curNPC.GetPosY() # 以NPC为中心点开始掉落
			@@ -4080,37 +4140,48 @@
			if not playerSpecDropList:
			continue
			itemCnt = 1
			ownerPlayer, itemID, isBind, isDropInItemPack = playerSpecDropList[0]
			ownerPlayer, itemID, isAuctionItem, isDropInItemPack = playerSpecDropList[0]
			ownerType, ownerID = ChConfig.Def_NPCHurtTypePlayer, ownerPlayer.GetPlayerID()
			playerSpecDropList = playerSpecDropList[1:]
			else:
			ownerPlayer = dropPlayer
			ownerType, ownerID = hurtType, hurtID
			itemCnt = moneyValue if itemID == moneyID else 1
			isBind = dropIDBindDict.get(itemID, 1)
			isAuctionItem = itemID in auctionIDList

			curItem = self.__CreateDropItem(curNPC, itemID, itemCnt, isBind)
			curItem = self.__CreateDropItem(curNPC, itemID, itemCnt, isAuctionItem, dropPlayer)
			if not curItem:
			continue

			if mapID == ChConfig.Def_FBMapID_GatherSoul:#聚魂副本特殊处理
			GameLogic_GatherSoul.KillGatherSoulNPCDropAward(itemID, itemCnt, isAuctionItem)
			dropItemDataStr = ChItem.GetMapDropItemDataStr(curItem)
			self.SendVirtualItemDrop(ownerPlayer, itemID, resultX, resultY, dropItemDataStr)
			curItem.Clear()
			continue

			if isDropInItemPack:
			curItem.SetUserAttr(ShareDefine.Def_IudetSource, ShareDefine.Item_Source_VirtualItemDrop)
			dropItemDataStr = ChItem.GetMapDropItemDataStr(curItem)
			#可以放入背包
			if ItemControler.DoLogic_PutItemInPack(ownerPlayer, curItem, True, True,
			event=["NPCDrop", False, {"npcID":npcID}]):
			if ItemControler.DoLogic_PutItemInPack(ownerPlayer, curItem, event=["NPCDrop", False, {"npcID":npcID}]):
			#通知客户端
			vItemDrop = ChPyNetSendPack.tagMCVirtualItemDrop()
			vItemDrop.ItemTypeID = itemID
			vItemDrop.PosX = resultX
			vItemDrop.PosY = resultY
			vItemDrop.UserData = dropItemDataStr
			vItemDrop.UserDataLen = len(vItemDrop.UserData)
			NetPackCommon.SendFakePack(ownerPlayer, vItemDrop)
			self.SendVirtualItemDrop(ownerPlayer, itemID, resultX, resultY, dropItemDataStr)

			else:
			self.__MapCreateItem(curItem, resultX, resultY, ownerType, ownerID)
			return

			def SendVirtualItemDrop(self, player, itemID, posX, posY, userDataStr):
			#通知客户端
			vItemDrop = ChPyNetSendPack.tagMCVirtualItemDrop()
			vItemDrop.ItemTypeID = itemID
			vItemDrop.PosX = posX
			vItemDrop.PosY = posY
			vItemDrop.UserData = userDataStr
			vItemDrop.UserDataLen = len(vItemDrop.UserData)
			NetPackCommon.SendFakePack(player, vItemDrop)
			return
			#---------------------------------------------------------------------
			## NPC被杀死逻辑处理
			# @param self 类实例
			@@ -4310,7 +4381,8 @@
			dropPlayer = curPlayer
			self.__KilledByPlayerSetPrize(curPlayer)
			ownerPlayerList.append(curPlayer)

			self.__ownerPlayerList = ownerPlayerList

			#调用物品掉落
			self.__NPCDropItem(dropPlayer, hurtType, hurtID, ownerPlayerList)

			@@ -4511,6 +4583,13 @@
			hurtID = killerDict.keys()[0]
			if isGameBoss:
			GameWorld.Log(" 归属默认玩家, npcID=%s,playerID=%s" % (npcID, hurtID))
			elif GameWorld.GetMap().GetMapID() == ChConfig.Def_FBMapID_GatherSoul:
			player = FBCommon.GetCurSingleFBPlayer()
			if player:
			hurtID = player.GetPlayerID()
			killerDict[hurtID] = player
			hurtType = ChConfig.Def_NPCHurtTypePlayer
			#GameWorld.Log(" 聚魂副本归属默认玩家, npcID=%s,playerID=%s" % (npcID, hurtID))

			return killerDict, killTeam, hurtType, hurtID

			@@ -4745,6 +4824,7 @@

			self.__DoNormalTeamExp(curPlayer)
			self.__KillNPCFuncEx(curPlayer, curNPC, maxHurtID, True)
			self.__ownerPlayerList = ownerPlayerList

			#调用物品掉落
			self.__NPCDropItem(dropPlayer, hurtType, hurtID, ownerPlayerList)
			@@ -4773,6 +4853,7 @@
			maxLV = curPlayerLV
			dropPlayer = player
			ownerPlayerList.append(player)
			self.__ownerPlayerList = ownerPlayerList

			if not ownerPlayerList:
			GameWorld.Log("奖励归属仙盟，但是不存在可获得该奖励的成员!npcID=%s,hurtType=%s,hurtID=%s"
			@@ -4812,47 +4893,33 @@
			npcID = curNPC.GetNPCID()
			defObjType = curNPC.GetGameObjType()
			mapFBType = GameWorld.GetMap().GetMapFBType()
			mapID = GameWorld.GetMap().GetMapID()
			playerID = curPlayer.GetPlayerID()
			mapID = FBCommon.GetRecordMapID(GameWorld.GetMap().GetMapID())
			#playerID = curPlayer.GetPlayerID()

			# 如果是NPC
			if defObjType == IPY_GameWorld.gotNPC:
			if defObjType != IPY_GameWorld.gotNPC:
			return

			# 跨服服务器处理
			if GameWorld.IsCrossServer():
			#掉落归属
			if mapFBType != IPY_GameWorld.fbtNull:
			FBLogic.DoFB_DropOwner(curPlayer , curNPC)
			else:
			if curNPC.GetLV()>=curPlayer.GetLV() - IpyGameDataPY.GetFuncCfg('DailyQuestKillMonster'):
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_KillNPC)

			killBossCntLimitDict = IpyGameDataPY.GetFuncCfg('KillBossCntLimit', 1)
			limitIndex = GameWorld.GetDictValueByKey(killBossCntLimitDict, npcID)
			if limitIndex != None:
			#今日杀怪次数+1
			key = ChConfig.Def_PDict_Boss_KillCnt % limitIndex
			newCnt = curPlayer.NomalDictGetProperty(key, 0) + 1
			PlayerControl.NomalDictSetProperty(curPlayer, key, newCnt)
			BossHurtMng.NotifyAttackBossCnt(curPlayer, limitIndex)
			GameWorld.DebugLog("今日杀怪次数 playerID=%s, newCnt=%s" % (curPlayer.GetPlayerID(), newCnt))

			dataDict = {"objID":curNPC.GetID(), "bossID":npcID, "touchCnt":newCnt,
			"AccID":curPlayer.GetAccID(), "PlayerID":curPlayer.GetPlayerID()}
			DataRecordPack.SendEventPack("AddKillBossCnt", dataDict, curPlayer)
			if limitIndex == 0:
			# 世界BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillWorldBoss, 1)
			# 每日活动
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_WorldBOSS)
			PlayerBossReborn.AddBossRebornActionCnt(curPlayer, ChConfig.Def_BRAct_WorldBOSS, 1)
			PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_WorldBoss, 1)
			elif limitIndex == 1: #BOSS之家
			# BOSS之家BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillBossHomeBoss, 1)
			# 每日活动
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_BOSSHome)
			PlayerBossReborn.AddBossRebornActionCnt(curPlayer, ChConfig.Def_BRAct_BOSSHome, 1)
			PlayerFairyCeremony.AddFCPartyActionCnt(curPlayer, ChConfig.Def_PPAct_BossHome, 1)
			if ChConfig.IsGameBoss(curNPC):
			OnPlayerKillBoss(curPlayer, npcID, mapID, True)
			return

			#掉落归属
			if mapFBType != IPY_GameWorld.fbtNull:
			FBLogic.DoFB_DropOwner(curPlayer , curNPC)
			else:
			if curNPC.GetLV()>=curPlayer.GetLV() - IpyGameDataPY.GetFuncCfg('DailyQuestKillMonster'):
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_KillNPC)
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillSpecificNPC, 1, [npcID])


			if ChConfig.IsGameBoss(curNPC):
			OnPlayerKillBoss(curPlayer, npcID, mapID, False)
			return

			#---------------------------------------------------------------------
			@@ -4878,7 +4945,7 @@
			#GameWorld.DebugLog("__MissionOnKillNPC isFeel=%s" % (isFeel), curPlayer.GetPlayerID())
			killBossCntLimitDict = IpyGameDataPY.GetFuncCfg('KillBossCntLimit', 1)
			limitIndex = GameWorld.GetDictValueByKey(killBossCntLimitDict, npcID)
			isWorldBoos = limitIndex == 0
			isWorldBoos = limitIndex == ShareDefine.Def_Boss_Func_World
			if isFeel:
			#击杀NPC触发摸怪任务事件
			EventShell.EventRespons_OnKillByFeel(curPlayer, curNPC)
			@@ -4990,7 +5057,7 @@
			#===========================================================================================

			# 在地上添加物品(统一接口)
			dropNPCID = 0 if not curNPC.GetIsBoss() else curNPCID
			dropNPCID = 0 if not ChConfig.IsGameBoss(curNPC) else curNPCID
			specOwnerIDList = self.__AllKillerDict.keys() if (len(self.__AllKillerDict) > 1 or dropType == ChConfig.Def_NPCHurtTypeSpecial) else []
			curMapItem = ChItem.AddMapDropItem(posX, posY, curItem, ownerInfo=[dropType, ownerID, specOwnerIDList], dropNPCID=dropNPCID)

			@@ -5005,18 +5072,11 @@
			#self.__SetItemProtect(curMapItem, dropType, ownerID)
			return

			def __CreateDropItem(self, curNPC, itemID, count, isBind):
			def __CreateDropItem(self, curNPC, itemID, count, isAuctionItem, dropPlayer):
			## 创建掉落的物品
			curItem = ItemControler.GetOutPutItemObj(itemID)
			curItem = ItemControler.GetOutPutItemObj(itemID, count, isAuctionItem, curPlayer=dropPlayer)
			if not curItem:
			return

			curMapID = GameWorld.GetMap().GetMapID()
			curMapID = FBCommon.GetRecordMapID(curMapID)

			# 掉落数量
			curItem.SetCount(count)
			curItem.SetIsBind(isBind)
			return curItem

			#---------------------------------------------------------------------
			@@ -5075,129 +5135,87 @@
			) = range(Def_CollNPCCfg_Len)


			## 该NPC可否同时采集
			# @param curNPC：采集NPC实例
			# @return False-不可以，True-可以
			def CanNPCCollectTogether(curNPC):
			npcID = curNPC.GetNPCID()
			collectNPCCfg = ReadChConfig.GetEvalChConfig('CollectNPCCfg')
			if npcID not in collectNPCCfg:
			def CheckCanCollectByNPCID(curPlayer, npcID, collectNPCIpyData):
			# 根据NPCID判断是否可以采集

			if GameWorld.IsCrossServer():
			return True

			collectNPCInfo = collectNPCCfg[npcID]
			if len(collectNPCInfo) != Def_CollNPCCfg_Len:
			return True

			canCollTogether = collectNPCInfo[Def_CollNPCCfg_CanTogether]
			return canCollTogether

			## 采集NPC开始采集
			# @param curPlayer：采集玩家实例
			# @param curNPC：采集NPC实例
			# @return False-非采集NPC，True-是采集NPC逻辑
			def DoCollectNPCBegin(curPlayer, curNPC):
			npcID = curNPC.GetNPCID()
			collectNPCCfg = ReadChConfig.GetEvalChConfig('CollectNPCCfg')
			if npcID not in collectNPCCfg:
			GameWorld.DebugLog("DoCollectNPCBegin 非特定采集NPC...")
			limitMaxTime = collectNPCIpyData.GetMaxCollectCount()
			if limitMaxTime > 0 and GetTodayCollectCount(curPlayer, npcID) >= limitMaxTime:
			PlayerControl.NotifyCode(curPlayer, collectNPCIpyData.GetCollectCountLimitNotify(), [limitMaxTime])
			return False

			collectNPCInfo = collectNPCCfg[npcID]
			if len(collectNPCInfo) != Def_CollNPCCfg_Len:
			GameWorld.ErrLog("CollectNPCCfg.txt配置错误，npcID=%s" % npcID)
			return True
			#如果是打坐召唤的NPC
			isSitCollect = npcID == IpyGameDataPY.GetFuncCfg('RealmSitNPCID')
			if isSitCollect:
			summonOwner = GetSummonNPCOwner(IPY_GameWorld.gotPlayer, curNPC)
			#ownerDetail = GetNpcObjOwnerDetail(curNPC)
			if not summonOwner:
			return True
			if summonOwner.GetID() == curPlayer.GetID():
			GameWorld.DebugLog("不能采集自己的打坐召唤兽 summonOwner.GetID()=%s" % summonOwner.GetID())
			return True
			#背包空间判断
			if collectNPCIpyData.GetCollectAward() and not ItemCommon.CheckPackHasSpace(curPlayer, IPY_GameWorld.rptItem):
			PlayerControl.NotifyCode(curPlayer, "GeRen_lhs_202580")
			return False

			canCollTogether = collectNPCInfo[Def_CollNPCCfg_CanTogether]
			#消耗物品采集，待扩展...

			return True

			def GetTodayCollectCount(curPlayer, npcID):
			## 获取采集NPC今日已采集次数
			todayCollTime = 0
			collectTimeShareIDList = IpyGameDataPY.GetFuncEvalCfg("CollectNPC", 1)
			for npcIDList in collectTimeShareIDList:
			if npcID not in npcIDList:
			continue
			for collNPCID in npcIDList:
			todayCollTime += curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % collNPCID)
			return todayCollTime
			return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)

			def OnCollectNPCBegin(curPlayer, curNPC, tick):
			## 采集NPC开始采集
			npcID = curNPC.GetNPCID()
			collectNPCIpyData = IpyGameDataPY.GetIpyGameData("CollectNPC", npcID)
			if not collectNPCIpyData:
			GameWorld.DebugLog("非特定采集NPC...")
			return False

			if not CheckCanCollectByNPCID(curPlayer, npcID, collectNPCIpyData):
			return True

			canCollTogether = 1
			collectPlayerID = GetCollectNPCPlayerID(curNPC)
			# 如果不允许同时采，且有人在采，则直接返回
			if not canCollTogether and collectPlayerID > 0 and collectPlayerID != curPlayer.GetPlayerID():
			GameWorld.DebugLog("DoCollectNPCBegin 不允许同时采集！")
			sysMark = collectNPCInfo[Def_CollNPCCfg_SysMsgMark]
			GameWorld.DebugLog("不允许同时采集！")
			sysMark = "GeRen_liubo_436832"
			if sysMark:
			PlayerControl.NotifyCode(curPlayer, sysMark)
			return True

			# 采集次数判断
			limitMaxTime, todayCollTime = 0, 0
			npcFuncType = curNPC.GetFunctionType()
			npcFuncCollectCntLimitDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeLimit')
			if npcFuncType in npcFuncCollectCntLimitDict:
			vipLV = curPlayer.GetVIPLv()
			limitMaxTime = eval(npcFuncCollectCntLimitDict[npcFuncType])
			todayBuyTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcBuyTime % npcFuncType)
			todayCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcCollTime % npcFuncType)
			limitMaxTime += todayBuyTime
			GameWorld.DebugLog(" vipLV=%s,maxTime=%s,todayTime=%s,todayBuyTime=%s" % (vipLV, limitMaxTime, todayCollTime, todayBuyTime))

			npcIDCollectCntLimitDict = ReadChConfig.GetEvalChConfig("CollectNPCIDTimeLimit")
			if npcID in npcIDCollectCntLimitDict:
			limitMaxTime = npcIDCollectCntLimitDict[npcID][0]
			todayCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)
			GameWorld.DebugLog(" maxTime=%s,todayTime=%s" % (limitMaxTime, todayCollTime))

			if limitMaxTime > 0 and todayCollTime >= limitMaxTime:

			PlayerControl.NotifyCode(curPlayer, collectNPCInfo[Def_CollNPCCfg_LimitSysMsgMark], [limitMaxTime])
			return True
			DoCollectNPCBegin(curPlayer, curNPC, collectNPCIpyData, tick)
			return True

			def DoCollectNPCBegin(curPlayer, curNPC, collectNPCIpyData, tick):
			## 开始采集

			# 采集消耗
			isAutoBuy = True #默认自动购买
			costItemInfo = collectNPCInfo[Def_CollNPCCfg_CostItemInfo]
			if costItemInfo:
			costItemID, costItemCnt = costItemInfo
			if costItemID > 0:
			itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
			enough, indexList, hasBind, lackCnt = ItemCommon.GetItem_FromPack_ByID_ExEx(
			costItemID, itemPack, costItemCnt)
			if not enough and not isAutoBuy:
			GameWorld.DebugLog("DoCollectNPCLogic 采集消耗物品不足,npcID=%s,costItemID=%s,cnt=%s" \
			% (npcID, costItemID, costItemCnt))
			PlayerControl.NotifyCode(curPlayer, collectNPCInfo[Def_CollNPCCfg_NotCostItemNotify],
			[npcID, costItemID, costItemCnt])
			return True


			# 改为在采集成功后扣除道具
			#ItemCommon.ReduceItem(curPlayer, itemPack, indexList, costItemCnt, False)

			#背包空间判断
			if not ItemCommon.CheckPackHasSpace(curPlayer, IPY_GameWorld.rptItem):
			PlayerControl.NotifyCode(curPlayer, "GeRen_lhs_202580")
			return True

			canCollTogether = 1
			if not canCollTogether and not SetCollectNPC(curPlayer, curNPC):
			GameWorld.ErrLog("DoCollectNPCBegin SetCollectNPC fail!")
			return True
			GameWorld.ErrLog("SetCollectNPC fail!")
			return

			# 采集耗时
			prepareTime = collectNPCInfo[Def_CollNPCCfg_PrepareTime]
			prepareTime = collectNPCIpyData.GetPrepareTime() * 1000
			collTimeReduceRate = PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_CollTimeReduceRate)
			if collTimeReduceRate:
			prepareTime = max(1000, int(prepareTime * (ShareDefine.Def_MaxRateValue - collTimeReduceRate) / float(ShareDefine.Def_MaxRateValue)))

			PlayerControl.Sync_PrepareBegin(curPlayer, prepareTime, IPY_GameWorld.pstMissionCollecting, \
			prepareID=curNPC.GetID())
			PlayerControl.Sync_PrepareBegin(curPlayer, prepareTime, IPY_GameWorld.pstMissionCollecting, prepareID=curNPC.GetID())

			if collectNPCIpyData.GetLostHPPer():
			curPlayer.SetDict(ChConfig.Def_PlayerKey_CollectLostHPTick, tick)

			FBLogic.OnBeginCollect(curPlayer, curNPC)
			##添加这个NPC的伤血列表，用于判断可否同时采集，改为字典判断
			AttackCommon.AddHurtValue(curNPC, curPlayer.GetPlayerID(), ChConfig.Def_NPCHurtTypePlayer, 1)
			return


			## 设置玩家采集该NPC
			# @param curPlayer：玩家实例
			# @param curNPC：采集NPC实例
			# @return False-失败，True-成功
			def SetCollectNPC(curPlayer, curNPC):
			## 设置玩家采集该NPC
			curPlayerID = curPlayer.GetPlayerID()
			curNPCObjID = curNPC.GetID()
			curCollectPlayerID = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_CollectPlayerID)
			@@ -5250,424 +5268,125 @@
			#GameWorld.DebugLog(" set collectNPCObjID 0")
			return

			## 采集NPC采集结束
			# @param curPlayer：采集玩家实例
			# @param npcID：采集NPCID
			# @return False-非采集NPC，True-是采集NPC逻辑
			def DoCollectNPCOK(curPlayer, npcID):
			isOK = DoGetCollectionNPCAwardLogic(curPlayer, npcID, True, 1)
			ClearCollectNPC(curPlayer)
			return isOK

			#// A2 20 开启采集NPC奖励箱子 #tagCMOpenCollNPCBox
			#
			#struct tagCMOpenCollNPCBox
			#{
			# tagHead Head;
			# DWORD MapID; //MapID
			# DWORD NPCID; //NPCID
			# BYTE OpenCnt; //开启次数
			# BYTE IsAutoBuy; //消耗道具不足是否自动购买
			# BYTE IsOnlyGold; //是否只消耗钻石
			#};
			def OnOpenCollNPCBox(index, clientData, tick):
			mapID = clientData.MapID
			npcID = clientData.NPCID
			openCnt = clientData.OpenCnt
			isAutoBuy = clientData.IsAutoBuy
			isOnlyGold = clientData.IsOnlyGold
			npcIDCollectCntLimitDict = ReadChConfig.GetEvalChConfig("CollectNPCIDTimeLimit")
			if npcID not in npcIDCollectCntLimitDict:
			GameWorld.DebugLog("该NPC不是自定义采集NPC箱子, 不可开启! npcID=%s" % npcID)
			def DoCollectNPCOK(curPlayer, npcID, tick):
			## 采集NPC采集结束
			collectNPCIpyData = IpyGameDataPY.GetIpyGameData("CollectNPC", npcID)
			if not collectNPCIpyData:
			GameWorld.DebugLog(" 非特定采集NPC...npcID=%s" % npcID)
			return
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			GameWorld.DebugLog("OnOpenCollNPCBox...npcID=%s,openCnt=%s,isAutoBuy=%s" % (npcID, openCnt, isAutoBuy))
			DoGetCollectionNPCAwardLogic(curPlayer, npcID, isAutoBuy, openCnt, mapID, isOnlyGold)

			PlayerState.DoCollectingLostHP(curPlayer, collectNPCIpyData, tick, True)

			if GameWorld.IsCrossServer():
			# 发送回本服采集完成
			serverGroupID = PlayerControl.GetPlayerServerGroupID(curPlayer)
			msgInfo = {"Result":1, "PlayerID":curPlayer.GetPlayerID(), "NPCID":npcID}
			GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_CollectNPCOK, msgInfo, [serverGroupID])
			else:
			DoGiveCollectNPCAward(curPlayer, npcID, collectNPCIpyData)

			FBLogic.OnCollectOK(curPlayer, npcID, tick)

			ClearCollectNPC(curPlayer)
			return True

			def CrossServerMsg_CollectNPCOK(curPlayer, msgData):
			## 收到跨服同步的采集完成
			if not msgData["Result"]:
			return
			npcID = msgData["NPCID"]
			collectNPCIpyData = IpyGameDataPY.GetIpyGameData("CollectNPC", npcID)
			if collectNPCIpyData:
			DoGiveCollectNPCAward(curPlayer, npcID, collectNPCIpyData)
			return

			## isOnlyGold:是否全消耗钻石，不扣道具
			def DoGetCollectionNPCAwardLogic(curPlayer, npcID, isAutoBuy=False, collectCnt=1, mapID=None, isOnlyGold=False):
			GameWorld.DebugLog("DoGetCollectionNPCAwardLogic...npcID=%s,collectCnt=%s" % (npcID, collectCnt))
			collectNPCCfg = ReadChConfig.GetEvalChConfig('CollectNPCCfg')
			if npcID not in collectNPCCfg:
			GameWorld.DebugLog(" 非特定采集NPC...npcID=%s" % npcID)
			return False

			def DoGiveCollectNPCAward(curPlayer, npcID, collectNPCIpyData, collectCnt=1):
			GameWorld.DebugLog("给采集奖励: npcID=%s,collectCnt=%s" % (npcID, collectCnt))
			if collectCnt <= 0:
			return True

			collectNPCInfo = collectNPCCfg[npcID]
			if len(collectNPCInfo) != Def_CollNPCCfg_Len:
			GameWorld.ErrLog("CollectNPCCfg.txt配置错误，npcID=%s" % npcID)
			return True
			return

			# 采集消耗
			costItemID, costItemCnt = 0, 0
			costItemInfo = collectNPCInfo[Def_CollNPCCfg_CostItemInfo]
			if costItemInfo and len(costItemInfo) == 2:
			costItemID, costItemCnt = costItemInfo

			curNPC = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not curNPC:
			return True

			# 根据NPC功能号
			npcFuncType = curNPC.GetFunctionType()
			npcFuncCollectCntLimitDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeLimit')
			limitMaxTime = 0 # 0表示不限制次数
			todayCollTime = 0
			if npcFuncType in npcFuncCollectCntLimitDict:
			vipLV = curPlayer.GetVIPLv()
			todayCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcCollTime % npcFuncType)
			limitMaxTime = eval(npcFuncCollectCntLimitDict[npcFuncType])

			# 根据NPCID
			npcIDCollectCntLimitDict = ReadChConfig.GetEvalChConfig("CollectNPCIDTimeLimit")
			if npcID in npcIDCollectCntLimitDict:
			limitMaxTime = npcIDCollectCntLimitDict[npcID][0]
			todayCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)

			limitMaxTime = collectNPCIpyData.GetMaxCollectCount()
			if limitMaxTime > 0:
			todayCollTime = GetTodayCollectCount(curPlayer, npcID)
			canCollectCnt = max(0, limitMaxTime - todayCollTime)
			collectCnt = min(collectCnt, canCollectCnt)
			if collectCnt <= 0:
			GameWorld.DebugLog(" 该NPC已达到最大采集次数: todayCollTime=%s,limitMaxTime=%s" % (todayCollTime, limitMaxTime))
			return True
			return

			costItemCntTotal = costItemCnt * collectCnt
			# 需要消耗道具的情况
			bindCnt = 0
			if costItemID > 0 and costItemCntTotal > 0:
			costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID)
			lackCnt = max(0, costItemCntTotal - bindCnt - unBindCnt) if not isOnlyGold else costItemCntTotal
			lackCost = 0 # 缺少道具个数
			itemGold = 0 # 自动购买单价
			if lackCnt > 0 and not isAutoBuy:
			GameWorld.DebugLog(" 采集消耗物品不足,npcID=%s,costItemID=%s,costItemCnt=%s,collectCnt=%s,hasCnt=(%s+%s)" \
			% (npcID, costItemID, costItemCnt, collectCnt, bindCnt, unBindCnt))
			PlayerControl.NotifyCode(curPlayer, collectNPCInfo[Def_CollNPCCfg_NotCostItemNotify],
			[npcID, costItemID, costItemCnt])
			return True

			if lackCnt > 0:
			itemGold = PlayerSuperMarket.GetStoreItemPrice(costItemID, IPY_GameWorld.TYPE_Price_Gold_Money)
			lackCost = lackCnt * itemGold
			if lackCost <= 0:
			return True
			if not PlayerControl.HaveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, lackCost, True):
			return True

			giveItemInfoList = []
			# 饼图随机表，独立概率随机表
			prizeInfo = __GetGiveCollectItemInfo(curPlayer, collectNPCInfo[Def_CollNPCCfg_GiveItemModeID])
			pieRandomList, randomAllInfoList = prizeInfo[:2]
			besureInfoList = prizeInfo[2] if len(prizeInfo) > 2 else [] # 按次数必出配置

			if not mapID:
			mapID = GameWorld.GetMap().GetMapID()

			successCnt = 0 # 成功次数
			if pieRandomList or randomAllInfoList:

			for i in xrange(collectCnt):
			isBind = 1 if successCnt < bindCnt else 0
			getItemInfo = __DoGiveCollectionNPCSingleAward(curPlayer, mapID, npcID, isBind, pieRandomList, randomAllInfoList, besureInfoList)
			if not getItemInfo:
			break
			giveItemInfoList.extend(getItemInfo)
			successCnt += 1

			if successCnt <= 0:
			return True
			else:
			successCnt = collectCnt

			# 给额外奖励
			reLV = curPlayer.GetLV()
			reExp = PlayerControl.GetPlayerReExp(curPlayer)
			reMoney = PlayerControl.GetPlayerReMoney(curPlayer)

			addExp = eval(collectNPCInfo[Def_CollNPCCfg_ExpFormat]) * successCnt
			addMoney = eval(collectNPCInfo[Def_CollNPCCfg_MoneyFormat]) * successCnt
			addZhenQi = collectNPCInfo[Def_CollNPCCfg_ZhenQi] * successCnt

			playerControl = PlayerControl.PlayerControl(curPlayer)
			playerControl.AddExp(addExp)
			addDataDict = {ChConfig.Def_Give_Reason_SonKey:npcID}
			PlayerControl.GiveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Silver_Money, addMoney,
			ChConfig.Def_GiveMoney_CollectNPC, addDataDict)
			PlayerControl.PlayerAddZhenQi(curPlayer, addZhenQi, True, True, "Collection")
			GameWorld.DebugLog(" successCnt=%s,addExp=%s,addMoney=%s,addZhenQi=%s"
			% (successCnt, addExp, addMoney, addZhenQi))

			# 需要消耗道具的情况, 扣除消耗
			if costItemID > 0 and costItemCntTotal > 0:
			unCostCnt = successCnt # 未扣除的消耗个数
			if not isOnlyGold:
			bindIndexList, unBindIndexList = costItemIndexList
			itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
			if bindCnt > 0:
			bindCostCnt = bindCnt if unCostCnt >= bindCnt else unCostCnt # 绑定道具消耗个数
			unCostCnt -= bindCostCnt
			ItemCommon.ReduceItem(curPlayer, itemPack, bindIndexList, bindCostCnt, True, "CollectNPC")
			GameWorld.DebugLog(" 扣除绑定道具: %s" % (bindCostCnt), curPlayer.GetPlayerID())

			if unCostCnt > 0 and unBindCnt > 0:
			unBindCostCnt = unBindCnt if unCostCnt >= unBindCnt else unCostCnt # 绑定道具消耗个数
			unCostCnt -= unBindCostCnt
			ItemCommon.ReduceItem(curPlayer, itemPack, unBindIndexList, unBindCostCnt, True, "CollectNPC")
			GameWorld.DebugLog(" 扣除未绑道具: %s" % (unBindCostCnt), curPlayer.GetPlayerID())

			if unCostCnt > 0:
			reduceGold = int(unCostCnt * itemGold)
			infoDict = {"PerGold":itemGold, "unCostCnt":unCostCnt, ChConfig.Def_Cost_Reason_SonKey:costItemID}
			PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, reduceGold,
			ChConfig.Def_Cost_BuyStoreItem, infoDict, unCostCnt)
			GameWorld.DebugLog(" 扣除消耗钻石: unCostCnt=%s,perGold=%s,reduceGold=%s"
			% (unCostCnt, itemGold, reduceGold), curPlayer.GetPlayerID())

			# 增加当日采集次数
			if limitMaxTime > 0:
			updCollTime = todayCollTime + successCnt
			npcFuncType = curNPC.GetFunctionType()
			npcFuncCollectCntLimitDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeLimit')
			if npcFuncType in npcFuncCollectCntLimitDict:
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcCollTime % npcFuncType, updCollTime)
			SyncCollNPCTime(curPlayer, [npcFuncType])

			if npcID in npcIDCollectCntLimitDict:
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTime % npcID, updCollTime)
			SyncCollNPCTime(curPlayer, npcIDList=[npcID])
			updCollTime = todayCollTime + collectCnt
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTime % npcID, updCollTime)
			SyncCollNPCTime(curPlayer, [npcID])
			GameWorld.DebugLog(" 增加当日采集次数: todayCollTime=%s,updCollTime=%s" % (todayCollTime, updCollTime))
			#采集成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_Collect, successCnt, [npcID])
			SyncCollectionItemInfo(curPlayer, addExp, addMoney, addZhenQi, giveItemInfoList, npcID)
			#DataRecordPack.DR_CollectNPCOK(curPlayer, npcID, addMoney, addExp, addZhenQi, giveItemInfoList)
			return True

			def __DoGiveCollectionNPCSingleAward(curPlayer, mapID, npcID, setBind, pieRandomList, randomAllInfoList, besureInfoList):
			# 单次采集NPC箱子奖励

			giveItemInfoList = [] # 最终会给到玩家身上的物品列表
			#GameWorld.DebugLog(" 给物品几率列表giveItemRateList=%s" % giveItemInfoList)
			# 先随机饼图概率物品
			if pieRandomList:
			pieRandomItemInfo = GameWorld.GetResultByRandomList(pieRandomList)
			giveItemInfoList.append(pieRandomItemInfo)

			#GameWorld.DebugLog(" 饼图物品giveItemInfoList=%s" % giveItemInfoList)
			# 再处理各自概率的物品
			if randomAllInfoList:
			maxRandomCnt, randomInfoList = randomAllInfoList
			randomInfoListEx = []
			for itemInfo in randomInfoList:
			giveRate = itemInfo[0]
			appendItemInfo = itemInfo[1:]
			# 最大概率必出，不受maxRandomCnt影响
			if giveRate == ShareDefine.Def_MaxRateValue:
			giveItemInfoList.append(appendItemInfo)
			maxRandomCnt -= 1
			continue

			if not GameWorld.CanHappen(giveRate, ShareDefine.Def_MaxRateValue):
			continue

			# 先加到待出列表里，再按需要出的个数随机
			randomInfoListEx.append(appendItemInfo)

			#GameWorld.DebugLog(" maxRandomCnt=%s,randomInfoListEx=%s" % (maxRandomCnt, randomInfoListEx))
			#GameWorld.DebugLog(" giveItemInfoList=%s" % giveItemInfoList)

			giveItemList = collectNPCIpyData.GetCollectAward()
			if giveItemList:
			itemID, itemCount, isAuctionItem = giveItemList
			ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem])

			if maxRandomCnt > 0 and randomInfoListEx:
			getRandomCnt = min(maxRandomCnt, len(randomInfoListEx))
			giveItemInfoList.extend(random.sample(randomInfoListEx, getRandomCnt))

			# 必出物品
			if besureInfoList:
			collTotalCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcCollTotalCnt % npcID)
			besureCnt, besureItemInfo = besureInfoList
			if collTotalCnt == besureCnt:
			giveItemInfoList = [besureItemInfo] # 必出时设定只给必出的物品
			GameWorld.DebugLog(" 此次必出物品, npcID=%s,besureCnt=%s,collTotalCnt=%s" % (npcID, besureCnt, collTotalCnt))

			if collTotalCnt <= besureCnt:
			# 目前只在小于等于的时候才增加次数，为以后如果需要做多个必出配置时，老玩家不用再管key的值
			collTotalCnt += 1
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcCollTotalCnt % npcID, collTotalCnt)
			GameWorld.DebugLog(" 更新采集总次数: %s" % collTotalCnt)

			GameWorld.DebugLog(" 最终可得到物品giveItemInfoList=%s" % giveItemInfoList)

			syncItemInfoList = [] # 同步的采集到的物品信息列表
			for itemID, itemCnt, isBind in giveItemInfoList:
			if not ItemCommon.CheckPackHasSpace(curPlayer, IPY_GameWorld.rptItem):
			break

			isBind = setBind or isBind

			getItemObj = ItemControler.GetOutPutItemObj(itemID)
			# elif itemType == 1:
			# itemDictData = ItemControler.GetAppointItemDictData(itemID, isBind)
			# getItemObj = ItemControler.GetItemByData(itemDictData)
			# elif itemType == 2:
			# quality = ItemCommon.GetRandEquipQualityByTable(itemID, "CollectEquipRandQuality")
			# if quality == 0:
			# isBroadcast = False
			# getItemObj = ItemCommon.RandNormalEquip(curPlayer, itemID, isBind, "CollectNormalEquip")
			# else:
			# getItemObj, isBroadcast = ItemCommon.RandGreateEquip(curPlayer, itemID, isBind, "CollectGreateEquip", quality)
			# if getItemObj == None:
			# continue
			#
			# itemID = getItemObj.GetItemTypeID()
			userData = getItemObj.GetUserData()
			getItemObj.SetCount(itemCnt)
			getItemObj.SetIsBind(isBind)
			ItemCommon.NotifyItemDropByKill(curPlayer, getItemObj, npcID)

			#SendGameServerGoodItemRecord(mapID, npcID, curPlayer.GetPlayerName(), curPlayer.GetPlayerID(), itemID)
			#可以放入背包
			if not ItemControler.DoLogic_PutItemInPack(curPlayer, getItemObj, True, True,
			event=["CollectNPC", False, {"npcID":npcID}]):
			break
			syncItemInfoList.append([itemID, itemCnt, isBind, userData])
			return syncItemInfoList
			#采集成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_Collect, collectCnt, [npcID])
			#SyncCollectionItemInfo(curPlayer, addExp, addMoney, addZhenQi, giveItemInfoList, npcID)
			return

			## 采集结果同步
			# @param None
			# @param None
			def SyncCollectionItemInfo(curPlayer, addExp, addMoney, addZhenQi, syncItemInfoList, collectNPCID=0):
			return #暂不同步
			if addExp <= 0 and addMoney <= 0 and addZhenQi <= 0 and not syncItemInfoList:

			def SyncCollNPCTime(curPlayer, npcIDList=[]):
			## 同步采集NPC功能号采集次数

			isSyncAll = False
			if not npcIDList:
			isSyncAll = True
			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCollectNPCCount()):
			ipyData = ipyDataMgr.GetCollectNPCByIndex(index)
			if ipyData.GetMaxCollectCount():
			npcIDList.append(ipyData.GetNPCID())

			if not npcIDList:
			return

			collItemInfo = ChPyNetSendPack.tagMCCollectionItemInfo()
			collItemInfo.Clear()
			collItemInfo.NPCID = collectNPCID
			collItemInfo.Exp = addExp
			collItemInfo.SilverMoney = addMoney
			collItemInfo.ZhenQi = addZhenQi
			collItemInfo.CollItemList = []

			for syncItemInfo in syncItemInfoList:
			itemType, itemID, itemCnt, isBind, itemInfo = 0, 0, 0, 0, ""
			if len(syncItemInfo) == 3:
			itemID, itemCnt, isBind = syncItemInfo
			elif len(syncItemInfo) == 4:
			itemType, itemID, itemCnt, isBind = syncItemInfo
			elif len(syncItemInfo) == 5:
			itemType, itemID, itemCnt, isBind, itemInfo = syncItemInfo

			if itemID <= 0:
			syncList = []
			for npcID in npcIDList:
			collCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)
			if isSyncAll and not collCount:
			continue
			collCntInfo = ChPyNetSendPack.tagMCNPCIDCollectionCnt()
			collCntInfo.Clear()
			collCntInfo.NPCID = npcID
			collCntInfo.CollectionCnt = collCount
			syncList.append(collCntInfo)

			collItem = ChPyNetSendPack.tagMCCollectionItem()
			collItem.Clear()
			collItem.ItemType = itemType
			collItem.ItemID = itemID
			collItem.ItemCnt = itemCnt
			collItem.IsBind = isBind
			collItem.ItemInfoLen = len(itemInfo)
			collItem.ItemInfo = itemInfo
			collItemInfo.CollItemList.append(collItem)
			if not syncList:
			return

			collItemInfo.CollItemIDCnt = len(collItemInfo.CollItemList)
			NetPackCommon.SendFakePack(curPlayer, collItemInfo)
			npcIDCollInfo = ChPyNetSendPack.tagMCNPCIDCollectionCntInfo()
			npcIDCollInfo.Clear()
			npcIDCollInfo.NPCCollCntList = syncList
			npcIDCollInfo.CollNPCCnt = len(npcIDCollInfo.NPCCollCntList)
			NetPackCommon.SendFakePack(curPlayer, npcIDCollInfo)
			return

			## 给采集物品信息列表
			# @param curPlayer：玩家实例
			# @param awardItemInfoDict：奖励物品配置字典
			# @return None
			def __GetGiveCollectItemInfo(curPlayer, lvModeIDDict):
			if not lvModeIDDict:
			return [[], []]

			modeID = ""
			playerLV = curPlayer.GetLV()
			for lvKey, mIDStr in lvModeIDDict.items():
			if lvKey[0] <= playerLV <= lvKey[1]:
			modeID = mIDStr
			break

			if not modeID:
			return [[], []]

			collectItemInfoDict = ReadChConfig.GetEvalChConfig('CollectItemInfo_%s' % modeID)
			if not collectItemInfoDict:
			return [[], []]

			infoKey = () # 默认key
			job = curPlayer.GetJob()
			for key in collectItemInfoDict.keys():
			# 如果玩家职业在配置的key里，则取指定的key信息
			if job in key:
			infoKey = key
			break

			if infoKey not in collectItemInfoDict:
			GameWorld.ErrLog('CollectItemInfo_%s.txt can not find key=%s!' % (modeID, infoKey))
			return [[], []]
			GameWorld.DebugLog(" __GetGiveCollectItemInfo job=%s,modeID=%s,key=%s,itemList=%s"
			% (job, modeID, infoKey, collectItemInfoDict[infoKey]))
			return collectItemInfoDict[infoKey]

			## 同步采集NPC功能号采集次数
			# @param curPlayer：采集玩家实例
			# @param funcType：功能号，默认为0，即同步配表中全部
			# @return None
			def SyncCollNPCTime(curPlayer, funcTypeList=[], npcIDList=[]):
			if not funcTypeList:
			npcFuncCollectCntLimitDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeLimit')
			funcTypeList = npcFuncCollectCntLimitDict.keys()

			if not npcIDList:
			collectNPCIDTimeLimit = ReadChConfig.GetEvalChConfig('CollectNPCIDTimeLimit')
			npcIDList = collectNPCIDTimeLimit.keys()

			# if funcTypeList:
			# collection = ChPyNetSendPack.tagMCFuncNPCCollectionCnt()
			# for fType in funcTypeList:
			# todayCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcCollTime % fType)
			# collection.Clear()
			# collection.FuncType = fType
			# collection.CollectionCnt = todayCollTime
			# collection.BuyCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcBuyTime % fType)
			# NetPackCommon.SendFakePack(curPlayer, collection)

			if npcIDList:
			npcIDCollInfo = ChPyNetSendPack.tagMCNPCIDCollectionCntInfo()
			npcIDCollInfo.Clear()
			npcIDCollInfo.NPCCollCntList = []
			for npcID in npcIDList:
			collCntInfo = ChPyNetSendPack.tagMCNPCIDCollectionCnt()
			collCntInfo.Clear()
			collCntInfo.NPCID = npcID
			collCntInfo.CollectionCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)
			npcIDCollInfo.NPCCollCntList.append(collCntInfo)
			npcIDCollInfo.CollNPCCnt = len(npcIDCollInfo.NPCCollCntList)
			NetPackCommon.SendFakePack(curPlayer, npcIDCollInfo)
			return


			## 采集NPCOnDay处理
			# @param curPlayer：玩家实例
			# @return None
			def CollNPCTimeOnDay(curPlayer, funcTypeList=[]):
			npcFuncCollectCntLimitDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeLimit')
			funcTypeList = npcFuncCollectCntLimitDict.keys() if not funcTypeList else funcTypeList
			for funcType in funcTypeList:
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcCollTime % funcType, 0)
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcBuyTime % funcType, 0)

			collectNPCIDTimeLimit = ReadChConfig.GetEvalChConfig('CollectNPCIDTimeLimit')
			for npcID, collCntInfo in collectNPCIDTimeLimit.items():
			isResetOnDay = collCntInfo[1]
			if not isResetOnDay:
			def CollNPCTimeOnDay(curPlayer):
			## 采集NPCOnDay处理
			resetNPCIDList = []
			ipyDataMgr = IpyGameDataPY.IPY_Data()
			for index in xrange(ipyDataMgr.GetCollectNPCCount()):
			ipyData = ipyDataMgr.GetCollectNPCByIndex(index)
			npcID = ipyData.GetNPCID()
			if not ipyData.GetMaxCollectCount():
			continue
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTime % npcID, 0)

			SyncCollNPCTime(curPlayer)
			if not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID):
			continue
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTime % npcID, 0)
			resetNPCIDList.append(npcID)

			if resetNPCIDList:
			SyncCollNPCTime(curPlayer, resetNPCIDList)
			return


			@@ -5753,28 +5472,43 @@
			# @param queryNPCIDList：查询的NPCID列表
			# @param tick
			# @return {NPCID:cnt}
			def GetNPCCntInfo(queryNPCIDList, tick):
			def GetNPCCntInfo(queryNPCIDList, tick, copyMapID=None):
			npcCntDict = {}

			if not queryNPCIDList:
			return npcCntDict
			#if not queryNPCIDList:
			# return npcCntDict

			gameNPCManager = GameWorld.GetNPCManager()
			GameWorld.DebugLog("GetNPCCntInfo...queryNPCIDList=%s" % (str(queryNPCIDList)))

			for index in xrange(gameNPCManager.GetNPCCount()):
			curNPC = gameNPCManager.GetNPCByIndex(index)
			curID = curNPC.GetID()
			if curID == 0:
			continue

			curNPCID = curNPC.GetNPCID()

			if curNPCID not in queryNPCIDList:
			continue
			if curNPC.GetCurAction() == IPY_GameWorld.laNPCDie or not curNPC.IsAlive():
			continue
			npcCntDict[curNPCID] = npcCntDict.get(curNPCID, 0) + 1

			if isinstance(copyMapID, int):
			for index in xrange(gameNPCManager.GetNPCCountByGWIndex(copyMapID)):
			curNPC = gameNPCManager.GetNPCByIndexByGWIndex(copyMapID, index)
			curID = curNPC.GetID()
			if curID == 0:
			continue

			curNPCID = curNPC.GetNPCID()

			if queryNPCIDList and curNPCID not in queryNPCIDList:
			continue
			if curNPC.GetCurAction() == IPY_GameWorld.laNPCDie or not curNPC.IsAlive():
			continue
			npcCntDict[curNPCID] = npcCntDict.get(curNPCID, 0) + 1
			else:
			for index in xrange(gameNPCManager.GetNPCCount()):
			curNPC = gameNPCManager.GetNPCByIndex(index)
			curID = curNPC.GetID()
			if curID == 0:
			continue

			curNPCID = curNPC.GetNPCID()

			if queryNPCIDList and curNPCID not in queryNPCIDList:
			continue
			if curNPC.GetCurAction() == IPY_GameWorld.laNPCDie or not curNPC.IsAlive():
			continue
			npcCntDict[curNPCID] = npcCntDict.get(curNPCID, 0) + 1

			GameWorld.DebugLog(" npcCntDict=%s" % (str(npcCntDict)))
			return npcCntDict
			@@ -5801,7 +5535,7 @@
			NetPackCommon.SendFakePack(curPlayer, npcInfoPack)
			return

			def SendGameServerGoodItemRecord(mapID, npcID, playerName, playerID, itemID, equipInfo=[]):
			def SendGameServerGoodItemRecord(mapID, npcID, playerName, playerID, itemID, equipInfo=[], serverGroupID=0):
			# @param equipInfo: [equipPlace, itemClassLV, itemColor, itemQuality, itemUserData]
			# GameWorld.DebugLog("检查物品是否发送GameServer: mapID=%s, npcID=%s, playerName=%s, itemID=%s"
			# % (mapID, npcID, playerName, itemID))
			@@ -5832,13 +5566,9 @@
			if not needRecord:
			return

			dropEquipMsg = str([playerID, playerName, mapID, npcID, itemID, itemUserData, weightValue])
			dropEquipMsg = str([playerID, playerName, mapID, npcID, itemID, itemUserData, weightValue, serverGroupID])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'BossDropGoodItem', dropEquipMsg, len(dropEquipMsg))
			GameWorld.DebugLog("发送GameServer记录拾取掉落好物品: %s" % dropEquipMsg, playerID)

			msgList = [playerName, playerID, mapID, npcID, itemID, itemUserData]

			PlayerControl.WorldNotify(0, 'DropRecord' , msgList)
			return

			#// A5 52 购买功能NPC采集次数 #tagCMBuyCollectionCnt
			@@ -5853,38 +5583,6 @@
			# @param None None
			# @return None
			def OnBuyCollectionCnt(index, clientData, tick):
			# curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			#
			# if not curPlayer:
			# return
			#
			# funcType = clientData.FuncType
			# #buyCnt = clientData.BuyCnt # 暂时默认购买一次
			#
			# playerID = curPlayer.GetPlayerID()
			# CollectNPCFuncTimeBuyCostDict = ReadChConfig.GetEvalChConfig('CollectNPCFuncTimeBuyCost')
			# if funcType not in CollectNPCFuncTimeBuyCostDict:
			# GameWorld.Log("采集功能次数限制类型，不能购买！funcType=%s" % funcType, playerID)
			# return
			#
			# buyTimeKey = ChConfig.Def_PDict_CollNpcBuyTime % funcType
			# alreadyBuyCnt = curPlayer.NomalDictGetProperty(buyTimeKey)
			# costFormat = CollectNPCFuncTimeBuyCostDict[funcType]
			# costGold = eval(costFormat)
			#
			# if not PlayerControl.HaveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, costGold):
			# return
			#
			# isOK = PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, costGold,
			# ShareDefine.Def_GoldCostType_BuyCollectionTime, alreadyBuyCnt)
			#
			# if not isOK:
			# return
			#
			# # 增加购买次数
			# PlayerControl.NomalDictSetProperty(curPlayer, buyTimeKey, alreadyBuyCnt + 1)
			# SyncCollNPCTime(curPlayer, [funcType])
			# GameWorld.Log("购买采集次数：funcType=%s,alreadyBuyCnt=%s,costGold=%s" % (funcType, alreadyBuyCnt, costGold), playerID)
			return

			#// A5 0A 购买可击杀boss次数 #tagCMBuyKillBossCnt
			@@ -5970,3 +5668,13 @@
			GameWorld.DebugLog("通知GameServer地图Boss分流信息: mapID=%s,lineID=%s,shuntPlayerDict=%s" % (mapID, lineID, shuntPlayerDict), lineID)
			return

			def NPCSpeedChangeNotify(curNPC, speed):
			##通知NPC速度
			sendPack = ChNetSendPack.tagObjInfoRefresh()
			sendPack.Clear()
			sendPack.ObjID = curNPC.GetID()
			sendPack.ObjType = curNPC.GetGameObjType()
			sendPack.RefreshType = IPY_GameWorld.CDBPlayerRefresh_Speed
			sendPack.Value = speed
			curNPC.NotifyAll(sendPack.GetBuffer(), sendPack.GetLength())
			return