Project_SG_ServerCode.git

			@@ -40,22 +40,12 @@
			import DataRecordPack
			import NetPackCommon
			import FBCommon
			import PlayerActivity
			import PlayerSuccess
			import BossHurtMng
			import PlayerPrestigeSys
			import GY_Query_BossFirstKill
			import GameLogic_FamilyInvade
			import GameLogic_GatherSoul
			import FormulaControl
			import PlayerBossReborn
			import PlayerFairyCeremony
			import PlayerCrossYaomoBoss
			import PlayerActCollectWords
			import PlayerNewFairyCeremony
			import GameLogic_CrossGrassland
			import PlayerActGarbageSorting
			import PlayerActBossTrial
			import PlayerTongTianLing
			import CrossPlayerData
			import PlayerFeastWish
			@@ -63,19 +53,13 @@
			import PlayerGoldInvest
			import PlayerWeekParty
			import NPCRealmRefresh
			import NPCHurtManager
			import PlayerActLogin
			import PlayerActTask
			import PlayerZhanling
			import FamilyRobBoss
			#import PlayerZhanling
			import IpyGameDataPY
			import PlayerGubao
			import PlayerState
			import TurnAttack
			import PyGameData
			import PlayerTeam
			import NPCHurtMgr
			import PlayerVip
			import GameObj
			import ChNPC

			@@ -121,20 +105,14 @@
			# NPC等级
			if hasattr(curNPC, "GetCurLV"):
			return max(curNPC.GetCurLV(), curNPC.GetLV())
			if curPlayer and PlayerControl.GetRealmDifficulty(curPlayer):
			npcID = curNPC.GetNPCID()
			needRealmLV = PlayerControl.GetDifficultyRealmLV(PlayerControl.GetRealmDifficulty(curPlayer))
			realmNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCRealmStrengthen", npcID, needRealmLV)
			if realmNPCIpyData:
			return realmNPCIpyData.GetLV()
			return curNPC.GetLV()

			def GetNPCDataEx(npcID):
			## 获取NPC扩展数据表，可热更
			npcDataEx = IpyGameDataPY.GetIpyGameDataNotLog("NPCEx", npcID)
			def GetNPCDataPy(npcID):
			## 获取NPC数据表，py自定义的表，可热更
			npcDataEx = IpyGameDataPY.GetIpyGameDataNotLog("NPC", npcID)
			if not npcDataEx:
			if False: # 不可能成立的条件，只为了 . 出代码提示
			npcDataEx = IpyGameDataPY.IPY_NPCEx()
			npcDataEx = IpyGameDataPY.IPY_NPC()
			return npcDataEx
			return npcDataEx

			@@ -142,11 +120,9 @@
			def SetRealmLV(curNPC, realmLV): return curNPC.SetMAtkMin(realmLV) # NPC表中此字段含义改成境界等级
			def GetIsLVSuppress(curNPC): return curNPC.GetWindDef() # 风防代表是否等级压制
			def GetFightPowerLackAtkLimit(curNPC): # 战力不足限制攻击，默认不限制
			npcDataEx = GetNPCDataEx(curNPC.GetNPCID())
			return npcDataEx.GetFightPowerLackAtkLimit() if npcDataEx else 0
			def GetSuppressFightPower(curNPC):
			npcDataEx = GetNPCDataEx(curNPC.GetNPCID())
			return npcDataEx.GetSuppressFightPower() if npcDataEx else curNPC.GetThunderDef() # 雷防代表压制战力
			return 0
			def GetSuppressFightPower(curNPC): # 压制战力
			return 0
			def SetSuppressFightPower(curNPC, value): return curNPC.SetThunderDef(min(value, ShareDefine.Def_UpperLimit_DWord))
			def GetCommendFightPower(curNPC): return curNPC.GetFireDef() # 火防代表推荐战力
			def GetDropOwnerType(curNPC): return curNPC.GetThunderAtk() # 雷攻代表掉落归属类型
			@@ -158,122 +134,6 @@
			def GetNPCSeries(curNPC): return curNPC.GetPoisionDef() # 毒防字段代表NPC系，按二进制位区分

			def DoNPCAttrStrengthen(curNPC, isReborn, isDyn=False):
			'''NPC属性增强, NPC属性成长由两个因素决定
			1.NPC成长等级，成长等级决定成长属性，与成长表结合使用
			可设置地图NPC等级动态成长，但是已经刷新出来的NPC等级不变，动态等级变更后刷新的NPC等级才会使用最新等级

			2.玩家人数因素，决定NPC属性的额外成长系数，可单独使用，或者和1一起使用
			可设置马上刷新NPC属性
			除血量外，其他属性会根据动态因素直接变更
			血量会根据血量百分比动态变更至相应的百分比
			'''
			npcID = curNPC.GetNPCID()
			strengthenIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCStrengthen", npcID)
			if not strengthenIpyData:
			#GameWorld.DebugLog("该NPC属性不成长！npcID=%s" % npcID)
			return

			strengthenLV = 0
			strengthenPlayerCnt = 0

			gameFB = GameWorld.GetGameFB()

			if strengthenIpyData.GetIsStrengthenByPlayerCount():
			if FamilyRobBoss.IsHorsePetRobBoss(npcID):
			strengthenPlayerCnt = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_HorsePetRobBossPlayerCount)
			else:
			strengthenPlayerCnt = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenPlayerCnt)
			if not strengthenPlayerCnt:
			GameWorld.ErrLog("NPC配置了按玩家人数成长类型，但是无法获取到对应的玩家人数！npcID=%s" % (npcID))
			return

			lvStrengthenType = strengthenIpyData.GetLVStrengthenType()
			# 根据世界等级
			if lvStrengthenType == 3:
			strengthenLV = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
			# 根据最大等级
			elif lvStrengthenType == 2:
			strengthenLV = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_NPCStrengthenMaxLV)
			# 根据平均等级
			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)
			# 根据境界难度
			elif lvStrengthenType == 5:
			realmLV = PlayerControl.GetDifficultyRealmLV(curNPC.GetSightLevel())
			realmNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCRealmStrengthen", npcID, realmLV)
			if realmNPCIpyData:
			strengthenLV = realmNPCIpyData.GetLV()
			else:
			lvStrengthenType = 0

			# 木桩怪最大、平均成长等级处理，直接取归属玩家等级
			if lvStrengthenType in [1, 2] and curNPC.GetType() in [ChConfig.ntPriWoodPilePVE, ChConfig.ntPriWoodPilePVP]:
			owner = None
			summonPlayerID = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_PriWoodPilePlayerID)
			if summonPlayerID:
			owner = GameWorld.GetObj(summonPlayerID, IPY_GameWorld.gotPlayer)
			if owner:
			strengthenLV = owner.GetLV()

			if strengthenIpyData.GetCmpNPCBaseLV():
			strengthenLV = max(strengthenLV, curNPC.GetLV())

			if lvStrengthenType in [1, 2] and not strengthenLV:
			GameWorld.ErrLog("NPC配置了成长等级类型，但是无法获取到对应的成长等级值！npcID=%s,lvStrengthenType=%s" % (npcID, lvStrengthenType))
			return

			# 副本特殊指定
			npcFBAttrDict = FBLogic.GetFBNPCStrengthenAttr(curNPC, isReborn)
			if "LV" in npcFBAttrDict:
			strengthenLV = npcFBAttrDict["LV"]

			attrDict = GetNPCStrengthenAttrDict(npcID, strengthenLV, strengthenPlayerCnt, strengthenIpyData)
			attrDict.update(npcFBAttrDict) # 如果副本有指定属性，则以副本为主
			if not attrDict:
			return

			# 成长等级只在重生的时候设置一次
			if isReborn and curNPC.GetCurLV() != strengthenLV:
			curNPC.SetCurLV(strengthenLV, False) # 重生的不通知等级变更，属性成长刷新后由NPC出现包通知

			befMaxHP = GameObj.GetMaxHP(curNPC)
			befHP = GameObj.GetHP(curNPC)
			#GameWorld.DebugLog("NPC属性成长刷新，isReborn=%s,npcID=%s,LV=%s,curLV=%s,befMaxHP=%s,befHP=%s,attrDict=%s"
			# % (isReborn, npcID, curNPC.GetLV(), curNPC.GetCurLV(), befMaxHP, befHP, attrDict))
			for attrKey, strengthenValue in attrDict.items():
			if not hasattr(curNPC, "Set%s" % attrKey):
			if attrKey == "FightPower":
			SetSuppressFightPower(curNPC, strengthenValue)
			continue

			if attrKey == "MaxHP":
			GameObj.SetMaxHP(curNPC, strengthenValue)
			else:
			strengthenValue = min(strengthenValue, ChConfig.Def_UpperLimit_DWord)
			getattr(curNPC, "Set%s" % attrKey)(strengthenValue)
			#GameWorld.DebugLog(" %s=%s" % (attrKey, strengthenValue))

			aftMaxHP = GameObj.GetMaxHP(curNPC)
			if befMaxHP != aftMaxHP:
			if isReborn:
			GameObj.SetHP(curNPC, aftMaxHP)
			elif isDyn:
			# 动态刷新属性的，血量按百分比继承
			aftHP = int(aftMaxHP * befHP / befMaxHP)
			GameObj.SetHP(curNPC, aftHP)
			curNPC.Notify_HP()
			curNPC.Notify_MaxHP()
			#GameWorld.DebugLog(" aftHP=%s,aftMaxHP=%s" % (aftHP, aftMaxHP))

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

			return

			def __OnFBRobotReborn(curNPC, npcLV):
			@@ -300,151 +160,6 @@
			FBLogic.OnRandomRobotJob(curNPC, lineRobotJobDict)
			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):
			if not strengthenLV and not strengthenPlayerCnt:
			return {}
			npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not npcData:
			return {}

			attrStrengthenInfo = ReadChConfig.GetEvalChConfig("NPCAttrStrengthen")
			if not attrStrengthenInfo:
			return {}

			attrDict = {}
			paramDict = attrStrengthenInfo[NPCAttr_ParamDict] # 过程参数公式字典
			attrStrengthenDict = attrStrengthenInfo[NPCAttr_AttrStrengthenList] # 属性成长公式字典
			playerCntCoefficient = attrStrengthenInfo[NPCAttr_PlayerCntCoefficient] # 人数系数
			npcIDPlayerCntCoefficient = attrStrengthenInfo[NPCAttr_NPCPlayerCntCoefficient] # 特殊NPC人数系数
			baseMaxHP = GameObj.GetHP(npcData) # NPCData 没有提供Max接口，对应使用GetHP

			if strengthenLV:
			if not strengthenIpyData:
			strengthenIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCStrengthen", npcID)
			if not strengthenIpyData:
			return {}

			playerCurLVIpyData = PlayerControl.GetPlayerLVIpyData(strengthenLV) # 取增强怪物等级对应此等级的玩家参考属性值
			if not playerCurLVIpyData:
			return {}

			# NPC表可用参数
			SkillAtkRate = GetSkillAtkRate(npcData) # 技能伤害
			FinalHurt = GetFinalHurt(npcData)

			# 参考玩家属性参数
			ReMaxHP = playerCurLVIpyData.GetReMaxHP() # 最大生命值
			ReAtk = playerCurLVIpyData.GetReAtk() # 攻击（最小、最大攻击）
			ReDef = playerCurLVIpyData.GetReDef() # 防御
			ReHit = playerCurLVIpyData.GetReHit() # 命中
			ReMiss = playerCurLVIpyData.GetReMiss() # 闪避
			ReAtkSpeed = playerCurLVIpyData.GetReAtkSpeed() # 攻击速度
			ReSkillAtkRate = playerCurLVIpyData.GetReSkillAtkRate() # 技能伤害比例
			ReDamagePer = playerCurLVIpyData.GetReDamagePer() # 增加伤害
			ReDamReduce = playerCurLVIpyData.GetReDamReduce() # 减少伤害
			ReIgnoreDefRate = playerCurLVIpyData.GetReIgnoreDefRate() # 无视防御比例
			ReLuckyHitRate = playerCurLVIpyData.GetReLuckyHitRate() # 会心一击率
			ReLuckyHit = playerCurLVIpyData.GetReLuckyHit() # 会心一击伤害
			ReBleedDamage = playerCurLVIpyData.GetReBleedDamage() # 流血伤害增加
			ReIceAtk = playerCurLVIpyData.GetReIceAtk() # 真实伤害
			ReIceDef = playerCurLVIpyData.GetReIceDef() # 真实抵御
			RePetAtk = playerCurLVIpyData.GetRePetAtk() # 灵宠攻击
			RePetSkillAtkRate = playerCurLVIpyData.GetRePetSkillAtkRate() # 灵宠技能
			RePetDamPer = playerCurLVIpyData.GetRePetDamPer() # 灵宠伤害增加
			ReFinalHurt = playerCurLVIpyData.GetReFinalHurt() # 固定伤害增加
			ReFinalHurtReduce = playerCurLVIpyData.GetReFinalHurtReduce() # 固定伤害减少
			RePotionReply = playerCurLVIpyData.GetRePotionReply() # 血瓶恢复量
			RePotionCD = playerCurLVIpyData.GetRePotionCD() # ѪƿCD
			ReFightPower = playerCurLVIpyData.GetReFightPower() # 战斗力

			# 增加NPC属性参数
			HitTime = strengthenIpyData.GetHitTime() # 怪物受击次数
			DefCoefficient = strengthenIpyData.GetDefCoefficient() # 人物防御系数
			AtkCoefficient = strengthenIpyData.GetAtkCoefficient() # 人物攻击系数
			AdjustCoefficient = strengthenIpyData.GetAdjustCoefficient() # 调整系数比例
			AtkInterval = strengthenIpyData.GetAtkInterval() # 怪物攻击间隔
			HitRate = strengthenIpyData.GetHitRate() # 对人物的命中率
			MissRate = strengthenIpyData.GetMissRate() # 对人物的闪避率
			MonterNum = strengthenIpyData.GetMonterNum() # 怪物数
			IceAtkCoefficient = strengthenIpyData.GetIceAtkCoefficient() # 元素攻击比例
			IceDefCoefficient = strengthenIpyData.GetIceDefCoefficient() # 元素抗性比例
			MaxEnduranceTime = strengthenIpyData.GetMaxEnduranceTime() # 玩家最大承受伤害时间
			FightPowerCoefficient = strengthenIpyData.GetFightPowerCoefficient() # 压制战斗力系数

			# 过程参数
			AtkReplyCoefficient = eval(FormulaControl.GetCompileFormula("NPCParam_AtkReplyCoefficient",
			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_%s" % (attrKey,LVStrengthenMark), strengthenFormat)))
			#GameWorld.DebugLog(" %s=%s" % (attrKey, strengthenValue))
			locals()[attrKey] = strengthenValue # 创建该属性局部变量作为参数提供给后面属性计算时用
			attrDict[attrKey] = strengthenValue

			# 当战力系数为0时，NPC战力默认为NPC表压制战力
			if FightPowerCoefficient:
			attrDict["FightPower"] = int(ReFightPower * FightPowerCoefficient / 10000.0)

			if strengthenPlayerCnt:
			mapID = GameWorld.GetMap().GetMapID()
			dataMapID = FBCommon.GetRecordMapID(mapID)
			formulaKey = "MapCoefficient_%s" % mapID
			playerCntAttrCoefficient = playerCntCoefficient.get(mapID, {})
			if not playerCntAttrCoefficient and dataMapID in playerCntCoefficient:
			playerCntAttrCoefficient = playerCntCoefficient[dataMapID]
			formulaKey = "MapCoefficient_%s" % dataMapID
			if npcID in npcIDPlayerCntCoefficient:
			playerCntAttrCoefficient = npcIDPlayerCntCoefficient[npcID]
			formulaKey = "NPCCoefficient_%s" % npcID
			for attrKey, coefficientDict in playerCntAttrCoefficient.items():
			if attrKey in attrDict:
			attrValue = attrDict[attrKey]
			elif attrKey == "MaxHP":
			attrValue = baseMaxHP
			else:
			attrFuncName = "Get%s" % attrKey
			if not hasattr(npcData, attrFuncName):
			continue
			attrValue = getattr(npcData, attrFuncName)()
			# 按字典配置
			if isinstance(coefficientDict, dict):
			coefficient = GameWorld.GetDictValueByRangeKey(coefficientDict, strengthenPlayerCnt, 1)
			# 按公式配置
			elif isinstance(coefficientDict, str):
			formulaKey = "%s_%s" % (formulaKey, attrKey)
			coefficient = eval(FormulaControl.GetCompileFormula(formulaKey, coefficientDict))
			else:
			coefficient = 1
			attrDict[attrKey] = int(attrValue * coefficient)

			#GameWorld.DebugLog("计算NPC属性成长: npcID=%s,strengthenLV=%s,strengthenPlayerCnt=%s,baseMaxHP=%s,attrDict=%s"
			# % (npcID, strengthenLV, strengthenPlayerCnt, baseMaxHP, attrDict))
			return attrDict

			def GiveKillNPCDropPrize(curPlayer, mapID, npcCountDict, exp_rate=None, mailTypeKey=None, isMail=False,
			extraItemList=[], prizeMultiple=1, dropItemMapInfo=[], curGrade=0, isVirtualDrop=False):
			'''给玩家击杀NPC掉落奖励
			@@ -459,975 +174,19 @@
			@param curGrade: 评级
			@param isVirtualDrop: 是否给物品虚拟掉落表现
			'''
			if not exp_rate:
			exp_rate = PlayerControl.GetPlayerExpRate(curPlayer)

			npcID = 0
			totalExp = 0
			totalMoney = 0
			itemCountDict = {}
			auctionItemIDList = []

			if prizeMultiple > 1:
			hadDropItemKeyList, hadDropItemPlaceList = [], [] # 已经掉落过的物品集合key列表，已经掉落过的装备部位列表
			mPrizeItemIDList = IpyGameDataPY.GetFuncEvalCfg("SealDemonDoubleDrop", 1) # 允许多倍奖励的物品ID列表
			mPrizePlaceList = IpyGameDataPY.GetFuncEvalCfg("SealDemonDoubleDrop", 2) # 允许多倍奖励的装备部位
			mPrizeItemKeyList = IpyGameDataPY.GetFuncEvalCfg("SealDemonDoubleDrop", 3) # 允许多倍奖励的物品ID集合

			itemKeyDict = IpyGameDataPY.GetFuncEvalCfg("JobItemDropSets") # {物品ID集合key:[职业顺序物品ID列表], ...}
			itemIDKeyDict = {}
			for itemKey, itemIDList in itemKeyDict.items():
			for itemID in itemIDList:
			itemIDKeyDict[itemID] = itemKey

			for npcID, count in npcCountDict.items():
			baseExp = GetNPCExp(curPlayer, npcID)
			addExp = int(baseExp * exp_rate / float(ChConfig.Def_MaxRateValue)) # 基础加成
			totalCount = count * prizeMultiple
			totalExp += (addExp * totalCount)

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

			for itemID in dropIDList:
			if prizeMultiple > 1:
			itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
			if not itemData:
			continue
			itemPlace = itemData.GetEquipPlace()
			itemKey = itemIDKeyDict.get(itemID)

			# 超过指定最大只数时，代表多倍奖励，多倍奖励的物品只允许给指定规则内的物品，只对已经掉过的物品有限制
			if dCount > count:
			if ItemCommon.GetIsEquip(itemData):
			if itemPlace in hadDropItemPlaceList and itemPlace not in mPrizePlaceList:
			GameWorld.DebugLog(" 多倍奖励不能给的物品部位: itemID=%s,itemPlace=%s" % (itemID, itemPlace))
			continue
			elif itemKey != None:
			if itemKey in hadDropItemKeyList and itemKey not in mPrizeItemKeyList:
			GameWorld.DebugLog(" 多倍奖励不能给的物品ID集合: itemID=%s,itemKey=%s" % (itemID, itemKey))
			continue
			else:
			if itemID in itemCountDict and itemID not in mPrizeItemIDList:
			GameWorld.DebugLog(" 多倍奖励不能给的物品ID: itemID=%s" % (itemID))
			continue

			if itemPlace and itemPlace not in hadDropItemPlaceList:
			hadDropItemPlaceList.append(itemPlace)
			if itemKey != None and itemKey not in hadDropItemKeyList:
			hadDropItemKeyList.append(itemKey)

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

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

			needSpace = 0
			prizeItemList = []
			jsonItemList = []
			for itemID, itemCount in itemCountDict.items():
			itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
			if not itemData:
			continue

			isAuctionItem = itemID in auctionItemIDList

			if ItemCommon.GetIsEquip(itemData):
			for _ in xrange(itemCount):
			curItem = ItemControler.GetOutPutItemObj(itemID, 1, isAuctionItem, curPlayer=curPlayer)
			if curItem:
			needSpace += 1
			prizeItemList.append(curItem)
			jsonItemList.append(ItemCommon.GetJsonItem(curItem))
			else:
			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 = dropItemMapInfo[:2]
			isOnlySelfSee = dropItemMapInfo[2] if len(dropItemMapInfo) > 2 else False # 是否仅自己可见
			isDropDisperse = dropItemMapInfo[3] if len(dropItemMapInfo) > 3 else False # 堆叠的物品是否散开掉落
			## 虚拟掉落表现
			if isVirtualDrop:
			DoGiveItemByVirtualDrop(curPlayer, prizeItemList, npcID, dropPosX, dropPosY, isDropDisperse, mailTypeKey)
			else:
			DoMapDropPrizeItem(curPlayer, prizeItemList, npcID, dropPosX, dropPosY, isDropDisperse, isOnlySelfSee)

			## 发邮件或背包空间不足
			elif isMail or needSpace > ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem, needSpace):
			mailItemList = []
			for prizeItem in prizeItemList:
			if isinstance(prizeItem, list):
			mailItemList.append(prizeItem)
			else:
			mailItemList.append(ItemCommon.GetMailItemDict(prizeItem))
			prizeItem.Clear() # 发邮件已经创建的物品实例要清空, 不然会导致内存泄露
			#if totalExp:
			# expItemID = 0
			# mailItemList.append([expItemID, totalExp, 1])
			PlayerControl.SendMailByKey(mailTypeKey, [curPlayer.GetPlayerID()], mailItemList, silver=totalMoney)

			## 直接放入背包
			else:
			event = [ChConfig.ItemGive_NPCDrop, False, {"NPCID":npcID}]
			for prizeItem in prizeItemList:
			if isinstance(prizeItem, list):
			itemID, itemCount, isAuctionItem = prizeItem
			ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem],
			event=event)
			else:
			ItemControler.DoLogic_PutItemInPack(curPlayer, prizeItem, event=event)

			if totalExp:
			PlayerControl.PlayerControl(curPlayer).AddExp(totalExp)

			if totalMoney:
			PlayerControl.GiveMoney(curPlayer, IPY_GameWorld.TYPE_Price_Silver_Money, totalMoney)

			#GameWorld.DebugLog("给玩家击杀NPC掉落奖励: mapID=%s,npcCountDict=%s,exp_rate=%s,mailTypeKey=%s,isMail=%s,extraItemList=%s"
			# % (mapID, npcCountDict, exp_rate, mailTypeKey, isMail, extraItemList))
			#GameWorld.DebugLog(" totalExp=%s,totalMoney=%s,needSpace=%s,jsonItemList=%s" % (totalExp, totalMoney, needSpace, jsonItemList))
			return jsonItemList, totalExp, totalMoney

			def DoMapDropPrizeItem(curPlayer, prizeItemList, npcID, dropPosX, dropPosY, isDropDisperse=True, isOnlySelfSee=True):
			## 奖励物品真实掉落地图，先拆开分散再掉落

			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()
			sightLevel = PlayerControl.GetMapRealmDifficulty(curPlayer)
			for posX, posY in ChConfig.Def_DropItemAreaMatrix:
			resultX = dropPosX + posX
			resultY = dropPosY + posY

			if not gameMap.CanMove(resultX, resultY):
			#玩家不可移动这个点
			continue

			if index > len(dropItemList) - 1:
			break

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

			if not curItem:
			continue

			ChItem.AddMapDropItem(resultX, resultY, curItem, ownerInfo=[ChConfig.Def_NPCHurtTypePlayer, playerID],
			dropNPCID=npcID, isOnlySelfSee=isOnlySelfSee, sightLevel=sightLevel)
			return

			def DoGiveItemByVirtualDrop(curPlayer, giveItemList, npcID, dropPosX=0, dropPosY=0, isDropDisperse=True, mailTypeKey="ItemNoPickUp", extraVirtualItemList=[]):
			## 给物品并且做假掉落表现，直接先堆叠给物品，再拆开做虚假掉落表现

			if not giveItemList:
			return

			mapID = PlayerControl.GetCustomMapID(curPlayer)
			lineID = PlayerControl.GetCustomLineID(curPlayer)
			if not mapID:
			mapID = GameWorld.GetGameWorld().GetMapID()

			playerID = curPlayer.GetPlayerID()
			giveItemObjList = []
			virtualItemDropList = []
			itemControl = ItemControler.PlayerItemControler(curPlayer)
			for itemInfo in giveItemList:
			if isinstance(itemInfo, list) or isinstance(itemInfo, tuple):
			itemID, itemCount, isAuctionItem = itemInfo
			curItem = ItemControler.GetOutPutItemObj(itemID, itemCount, isAuctionItem, curPlayer=curPlayer)
			if not curItem:
			continue
			elif hasattr(itemInfo, "GetItemTypeID"):
			curItem = itemInfo
			itemID = curItem.GetItemTypeID()
			itemCount = curItem.GetCount()
			isAuctionItem = ItemControler.GetIsAuctionItem(curItem)
			else:
			continue
			dropItemDataStr = ChItem.GetMapDropItemDataStr(curItem)
			giveItemObjList.append(curItem)

			# 散开掉落
			if isDropDisperse:
			for _ in xrange(itemCount):
			virtualItemDropList.append([itemID, dropItemDataStr])
			else:
			virtualItemDropList.append([itemID, dropItemDataStr])

			# 先通知掉落，再给物品，因为前端表现弹框需要这个顺序需求
			if extraVirtualItemList: #只显示假掉落
			for itemInfo in extraVirtualItemList:
			itemID, itemCount, isAuctionItem = itemInfo
			curItem = ItemControler.GetOutPutItemObj(itemID, itemCount, isAuctionItem, curPlayer=curPlayer)
			if not curItem:
			continue
			dropItemDataStr = ChItem.GetMapDropItemDataStr(curItem)
			# 散开掉落
			if isDropDisperse:
			for _ in xrange(itemCount):
			virtualItemDropList.append([itemID, dropItemDataStr])
			else:
			virtualItemDropList.append([itemID, dropItemDataStr])
			curItem.Clear()

			gameMap = GameWorld.GetMap()
			index = 0
			for posX, posY in ChConfig.Def_DropItemAreaMatrix:
			if dropPosX or dropPosY:
			resultX = dropPosX + posX
			resultY = dropPosY + posY
			if not gameMap.CanMove(resultX, resultY):
			#玩家不可移动这个点
			continue
			else:
			resultX, resultY = 0, 0
			if index > len(virtualItemDropList) - 1:
			break
			itemID, dropItemDataStr = virtualItemDropList[index]
			index += 1
			SendVirtualItemDrop(curPlayer, itemID, resultX, resultY, dropItemDataStr)

			# 再给物品
			mailItemList = []
			for itemObj in giveItemObjList:
			itemID = itemObj.GetItemTypeID()
			mailItem = ItemCommon.GetMailItemDict(itemObj)
			equipInfo = [itemObj.GetEquipPlace(), ItemCommon.GetItemClassLV(itemObj), itemObj.GetItemColor(),
			itemObj.GetSuiteID(), itemObj.GetUserData()]
			packIndex = ChConfig.GetItemPackType(itemObj)
			if not itemControl.PutInItem(packIndex, itemObj, event=[ChConfig.ItemGive_Pickup, False, {"NPCID":npcID}]):
			mailItemList.append(mailItem)

			if npcID:
			SendGameServerGoodItemRecord(curPlayer, mapID, lineID, npcID, itemID, equipInfo)

			# 放不下的发邮件
			if mailItemList:
			PlayerControl.SendMailByKey(mailTypeKey, [playerID], mailItemList, [mapID])
			return

			################################### NPC掉落 ###################################
			Def_NPCMaxDropRate = 1000000 # NPC掉落相关的最大概率, 数值设定

			def GetNPCDropIpyData(npcID):
			ipyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("NPCDropItem", npcID)
			if not ipyDataList:
			GameWorld.DebugLog("该NPC没配置掉落！npcID=%s" % npcID)
			return
			ipyDrop = None
			maxWorldLV = 0
			curWorldLV = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
			if len(ipyDataList) == 1:
			ipyDrop = ipyDataList[0]
			maxWorldLV = ipyDrop.GetMaxWorldLV()
			if maxWorldLV and curWorldLV > maxWorldLV:
			GameWorld.DebugLog("该NPC当前世界等级无法掉落物品!npcID=%s,curWorldLV(%s) > maxWorldLV(%s)" % (npcID, curWorldLV, maxWorldLV))
			return
			else:
			for ipyData in ipyDataList:
			maxWorldLV = ipyData.GetMaxWorldLV()
			if curWorldLV <= maxWorldLV:
			ipyDrop = ipyData
			break
			if not ipyDrop:
			GameWorld.DebugLog("该NPC当前世界等级无法掉落物品!npcID=%s,curWorldLV=%s,maxWorldLV=%s" % (npcID, curWorldLV, maxWorldLV))
			return
			return ipyDrop

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

			if not ownerPlayerList:
			ownerPlayerList = [dropPlayer]

			playerID = dropPlayer.GetPlayerID()
			playerLV = dropPlayer.GetLV()
			maxDropLV = ipyDrop.GetMaxDropLV()

			realmNPCIpyData = None
			realmMapIDList = IpyGameDataPY.GetFuncEvalCfg("RealmDifficulty", 1)
			realmDifficulty = PlayerControl.GetRealmDifficulty(dropPlayer)
			if mapID in realmMapIDList and realmDifficulty:
			realmLV = PlayerControl.GetDifficultyRealmLV(realmDifficulty)
			realmNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCRealmStrengthen", npcID, realmLV)
			if realmNPCIpyData:
			maxDropLV = realmNPCIpyData.GetMaxDrapLV()

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

			npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not npcData:
			GameWorld.ErrLog("获取NPC掉落配置错误!表不存在该NPCID=%s" % npcID, playerID)
			return

			tianxuanState = False # 是否有天玄额外掉落状态
			tianxuanBuff = SkillCommon.FindBuffByID(dropPlayer, ChConfig.Def_SkillID_TianxuanBuff)[0]
			curGrade = curGrade if curGrade else GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)

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

			# 通用掉率相关
			gameFB = GameWorld.GetGameFB()
			doCountAdd = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_DropDoCountAdd)
			doCountRate = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_DropDoCountRate) # 直接覆盖基值, 无值时取默认值
			if not doCountRate:
			doCountRate = ChConfig.Def_MaxRateValue

			# 归属者相关信息
			tagJob = 0
			dropEquipKillCountPub = 0 # 装备附加掉落综合击杀次数，取次数最大的那个，至少第一次
			dropItemIDKillCountPub = 0 # 物品ID附加掉落综合击杀次数，取次数最大的那个，至少第一次
			equipDropRatePlus = 0 # 装备掉落概率提升
			equipDropDoCountPlus = 0 # 装备掉落执行次数提升
			for ownerPlayer in ownerPlayerList:
			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))

			dropRatePlusValue = ipyDrop.GetCanDropRatePlus()
			if not dropRatePlusValue & pow(2, 0):
			equipDropRatePlus = 0

			if not dropRatePlusValue & pow(2, 1):
			equipDropDoCountPlus = 0

			#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 = [] # [(阶,颜色), ...]
			# 1. 装备库 - 饼图概率
			pieRateDoCnt = ipyDrop.GetPieRateDoCnt()
			if pieRateDoCnt:
			pieRateDoCnt = __GetNPCDropDoCountChange(pieRateDoCnt, doCountRate + equipDropDoCountPlus, doCountAdd)
			dropEquipInfoList += __GetNPCPieRateEquipDrop(ipyDrop, pieRateDoCnt, equipDropRatePlus)

			# 2. 装备库 - 独立概率
			indepRateDoCnt = ipyDrop.GetIndepRateDoCnt()
			if indepRateDoCnt:
			indepRateDoCnt = __GetNPCDropDoCountChange(indepRateDoCnt, doCountRate + equipDropDoCountPlus, doCountAdd)
			dropEquipInfoList += __GetNPCIndepRateEquipDrop(mapID, ipyDrop, indepRateDoCnt, equipDropRatePlus, curGrade)
			#GameWorld.DebugLog("阶,颜色 key,dropEquipInfoList=%s" % (dropEquipInfoList))

			# 天玄丹
			tianxuanEquipRateList = ipyDrop.GetTianxuanEquipRateList()
			if tianxuanBuff and tianxuanEquipRateList:
			tianxuanState = True
			dropInfo = GameWorld.GetResultByRandomList(tianxuanEquipRateList)
			if dropInfo:
			dropEquipInfoList.append(dropInfo)

			# 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:
			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)

			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]

			equipColorDropLimitDay = IpyGameDataPY.GetFuncEvalCfg("ItemDropCountLimit", 1, {}) # 每日个人掉落装备个数限制 {品质:每日掉落个数, ...}
			colorDropCntDict = {} # 装备颜色已经掉落数 {颜色:数量, ...}
			colorMaxDropCntDict = ipyDrop.GetEquipColorMaxDropCount() # {颜色:上限数量,...}
			colorSuitRateDict = ipyDrop.GetEquipColorSuitInfo() # 装备颜色对应套装概率 {颜色:套装概率, ...}
			colorSuitPlaceKeyInfoDict = ipyDrop.GetEquipPartKeyRateInfo() # 装备部位集合信息 {(颜色,是否套装):部位集合key, ...}
			colorSuitPartOptimization = ipyDrop.GetColorSuitPartOptimization() # 部位颜色套评分优选掉落，十位代表颜色，个位代表套装
			optColor, optIsSuit = colorSuitPartOptimization / 10, colorSuitPartOptimization % 10
			optPlace = None # 优选部位

			for dropEquipInfo in dropEquipInfoList:
			classLV, color = dropEquipInfo[:2]
			if realmNPCIpyData:
			classLV = realmNPCIpyData.GetEquipClassLV()
			GameWorld.DebugLog("掉落对应难度境界装备: classLV=%s" % classLV, playerID)

			colorCountToday = 0
			if color in equipColorDropLimitDay:
			colorCountMax = equipColorDropLimitDay[color]
			colorCountToday = dropPlayer.NomalDictGetProperty(ChConfig.Def_PDict_DropColorToday % color)
			if colorCountToday >= colorCountMax:
			GameWorld.DebugLog("已超过该颜色装备今日最大掉落数，不掉！color=%s,colorCountMax=%s" % (color, colorCountMax), playerID)
			continue

			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

			if len(dropEquipInfo) == 5:
			isSuit, placeKey, tagJob = dropEquipInfo[2:]
			jobList = [tagJob]
			else:
			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
			placeKey = colorSuitPlaceKeyInfoDict[colorSuitKey]
			# 掉落优选部位处理
			if color == optColor and isSuit == optIsSuit and optPlace == None:
			allEquipPlaceList = GetAllEquipPlaceByPlaceKey(placeKey)
			#GameWorld.DebugLog(" 所有可优选部位: %s" % allEquipPlaceList)
			if allEquipPlaceList:
			optPlace = __GetOptimizationEquipPlace(dropPlayer, classLV, optColor, optIsSuit, allEquipPlaceList)
			jobList = itemJobList
			if optPlace > 0:
			GameWorld.DebugLog(" 最终优选部位: %s" % optPlace)
			placeList = [optPlace]
			jobList = [dropPlayer.GetJob()]
			optPlace = 0 # 只有一次性的，置为0
			else:
			placeList = GetEquipPlaceByPlaceKey(placeKey)
			if not placeList:
			GameWorld.ErrLog("部位集合key不存在!npcID=%s,placeKey=%s" % (npcID, placeKey))
			continue
			randEquipIDList = __GetEquipIDList(npcID, classLV, color, isSuit, placeList, jobList)
			if not randEquipIDList:
			continue
			if color in equipColorDropLimitDay:
			colorCountToday += 1
			PlayerControl.NomalDictSetProperty(dropPlayer, ChConfig.Def_PDict_DropColorToday % color, colorCountToday)
			if color in colorMaxDropCntDict:
			colorDropCntDict[color] = dropCount + 1
			if isSuit and len(jobList) > 1:
			randItemID = __GetRandDropSuitEquipID(dropPlayer, randEquipIDList)
			else:
			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)
			if colorCountToday:
			GameWorld.DebugLog(" 更新掉落特殊品质装备今日次数: color=%s,colorCountToday=%s" % (color, colorCountToday), playerID)

			# 4. 指定物品ID库
			dropIDList += __GetAppointDropItemIDList(dropPlayer, npcID, ipyDrop, doCountRate, doCountAdd, tianxuanBuff)
			if tianxuanBuff and (ipyDrop.GetTianxuanItemKeyRate() or ipyDrop.GetTianxuanItemIDRate()):
			tianxuanState = True

			# 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]
			priDropInfoList = gradePriItemIDDropDict.get(curGrade, [])
			priDropIDList = []
			for priItemID, priItemCount in priDropInfoList:
			priDropIDList += [priItemID] * priItemCount
			else:
			priDropIDList = ipyDrop.GetPriItemIDDrop()
			for priDropID in priDropIDList:
			dropIDList.append(priDropID)
			#GameWorld.DebugLog("私有物品掉落: priDropID=%s" % priDropID)

			# 6. 地图评级额外掉落
			fbGradeDropItemExDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate2", 2) # 地图评级额外物品掉落 {"mapID":{"评级":[[物品ID,个数], ...], ...}}
			if curGrade and str(mapID) in fbGradeDropItemExDict:
			gradeItemExDict = fbGradeDropItemExDict[str(mapID)]
			gradeItemExList = gradeItemExDict.get(str(curGrade), [])
			#GameWorld.DebugLog("评级额外掉落物品: curGrade=%s,gradeItemExList=%s" % (curGrade, gradeItemExList))
			for gItemExID, gItemExCount in gradeItemExList:
			dropIDList += [gItemExID] * gItemExCount

			# 7.相关活动掉落
			feastWishDropIDList = PlayerFeastWish.GetFeastWishDropItemIDList(dropPlayer, npcData)
			if feastWishDropIDList:
			dropIDList.extend(feastWishDropIDList)

			#bossƾ֤
			killBossCntLimitDict = IpyGameDataPY.GetFuncCfg('KillBossCntLimit', 1)
			if mapID == ChConfig.Def_FBMapID_PersonalBoss:
			limitIndex = ChConfig.Def_FBMapID_PersonalBoss
			else:
			limitIndex = GameWorld.GetDictValueByKey(killBossCntLimitDict, npcID)
			if limitIndex != None:
			bossTrialDrop = PlayerActBossTrial.GetBossTrialDropItemIDList(dropPlayer, limitIndex)
			if bossTrialDrop:
			bossTrialItemID, bossTrialItemCount = bossTrialDrop
			GameWorld.DebugLog("掉落boss凭证: bossTrialItemID=%s, bossTrialItemCount=%s" % (bossTrialItemID, bossTrialItemCount))
			dropIDList += [bossTrialItemID] * bossTrialItemCount

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

			# 掉落金币
			dropMoneyDoCnt = ipyDrop.GetDropMoneyDoCnt()
			dropMoneyRate = ipyDrop.GetDropMoneyRate()
			if dropMoneyRate == ChConfig.Def_NPCMapDropRate:
			dropMoneyCnt = dropMoneyDoCnt
			else:
			dropMoneyCnt = 0
			for _ in xrange(dropMoneyDoCnt):
			if GameWorld.CanHappen(dropMoneyRate, ChConfig.Def_NPCMapDropRate):
			dropMoneyCnt += 1

			#GameWorld.DebugLog("NPCID=%s,金币掉率: %s, 执行次数=%s, 掉落金币数=%s" % (npcID, dropMoneyRate, dropMoneyDoCnt, dropMoneyCnt))
			if dropMoneyCnt:
			moneyValue = __GetDropMoneyValue(dropPlayer, ipyDrop, realmNPCIpyData)
			#GameWorld.DebugLog(" 掉落金币value=%s" % (moneyValue))

			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())

			if tianxuanBuff and tianxuanState:
			GameWorld.DebugLog(" 去除天玄丹buff: Layer=%s" % tianxuanBuff.GetLayer(), playerID)
			BuffSkill.SetBuffLayer(dropPlayer, tianxuanBuff, max(tianxuanBuff.GetLayer() - 1, 0), True, ChConfig.Def_SkillID_TianxuanBuff, isSync=True)

			return dropIDList, auctionIDList, dropMoneyCnt, moneyValue

			def __GetRandDropSuitEquipID(curPlayer, randEquipIDList):
			## 获取随机掉落的套装ID，为了玩家掉落体验，当非本职业套装时可至多重新随机X次
			randItemID = 0
			suitRandCountEx = IpyGameDataPY.GetFuncCfg("EquipSuitDrop", 1) + 1
			for _ in xrange(suitRandCountEx):
			randItemID = random.choice(randEquipIDList)
			itemData = GameWorld.GetGameData().GetItemByTypeID(randItemID)
			if not itemData:
			continue
			if ItemCommon.CheckJob(curPlayer, itemData):
			break
			return randItemID

			def GetAllEquipPlaceByPlaceKey(placeKey):
			placeKeyRateListDict = IpyGameDataPY.GetFuncEvalCfg("EquipDropPartSets", 2, {}) # {集合数字key1:[[概率1,部位1],...],...}
			if placeKey in placeKeyRateListDict:
			return [rateInfo[1] for rateInfo in placeKeyRateListDict[placeKey]]
			placeKeyListDict = IpyGameDataPY.GetFuncEvalCfg("EquipDropPartSets", 1, {}) # {集合数字key1:[部位1,部位2,...],...}
			if placeKey in placeKeyListDict:
			return placeKeyListDict[placeKey]
			return []

			def GetEquipPlaceByPlaceKey(placeKey):
			## 获取装备位集合对应的部位信息，集合ID重复时，优先饼图
			placeList = []
			placeKeyRateListDict = IpyGameDataPY.GetFuncEvalCfg("EquipDropPartSets", 2, {}) # {集合数字key1:[[概率1,部位1],...],...}
			if placeKey in placeKeyRateListDict:
			placeRateList = placeKeyRateListDict[placeKey]
			place = GameWorld.GetResultByRandomList(placeRateList)
			if place:
			placeList = [place]
			#GameWorld.DebugLog(" 掉落部位概率集合: placeKey=%s,placeRateList=%s,place=%s,placeList=%s" % (placeKey, placeRateList, place, placeList))

			if not placeList:
			placeKeyListDict = IpyGameDataPY.GetFuncEvalCfg("EquipDropPartSets", 1, {}) # {集合数字key1:[部位1,部位2,...],...}
			if placeKey in placeKeyListDict:
			placeList = placeKeyListDict[placeKey]
			#GameWorld.DebugLog(" 掉落部位均衡集合: placeKey=%s,placeList=%s" % (placeKey, placeList))

			return placeList

			def __GetOptimizationEquipPlace(dropPlayer, classLV, optColor, optIsSuit, optPlaceList):
			''' 获取掉落优选部位
			几个默认规则
			1. 颜色大于指定优选颜色的，无论是否套装都不计算在内
			2. 颜色小于指定优选颜色的，无论是否套装都计算在内
			'''
			#GameWorld.DebugLog("处理优选部位掉落: classLV=%s,optColor=%s,optIsSuit=%s,optPlaceList=%s" % (classLV, optColor, optIsSuit, optPlaceList))
			minGSPlace = None
			minGS = None
			equipPack = dropPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
			for optPlace in optPlaceList:
			ipyData = IpyGameDataPY.GetIpyGameData('EquipPlaceIndexMap', classLV, optPlace)
			if not ipyData:
			continue
			equipIndex = ipyData.GetGridIndex()
			curEquip = equipPack.GetAt(equipIndex)
			if not curEquip or curEquip.IsEmpty():
			#GameWorld.DebugLog(" 没穿装备，直接默认返回该部位: optPlace=%s" % optPlace)
			return optPlace
			curColor = curEquip.GetItemColor()
			curIsSuit = 1 if curEquip.GetSuiteID() else 0
			if curColor > optColor:
			# 超过优选指定颜色的不算，无论是否有套装
			#GameWorld.DebugLog(" 颜色超过优选颜色，不算该部位: optPlace=%s,curColor=%s,curIsSuit=%s" % (optPlace, curColor, curIsSuit))
			continue
			if curColor == optColor and curIsSuit >= optIsSuit:
			# 与优选指定颜色相同，且满足是否套装的不算
			#GameWorld.DebugLog(" 颜色套装满足优选，不算该部位: optPlace=%s,curColor=%s,curIsSuit=%s" % (optPlace, curColor, curIsSuit))
			continue
			curGS = ItemCommon.GetEquipGearScore(curEquip)
			if minGS == None or curGS < minGS:
			minGS = curGS
			minGSPlace = optPlace

			return minGSPlace

			def __GetNPCDropDoCountChange(doCount, doCountRate, doCountAdd):
			## 获取掉落执行次数变更结果，可能增加或减少
			if doCountRate != ChConfig.Def_MaxRateValue:
			doCount = max(1, int(doCount * doCountRate / 10000.0))
			if doCountAdd:
			doCount = max(1, doCount + doCountAdd) # 支持正负，保底1，负值待扩展
			return doCount

			def __RemoveMutexDropID(dropIDList, mutexDropInfo):
			## 移除互斥的掉落物品，每组互斥的ID最多只能掉落一个，列表顺序为掉落优先级 [[互斥组1ID, ID, ...], [互斥组2ID, ID, ...], ...]
			for mutexDropList in mutexDropInfo:
			isMutex = False
			for mutexID in mutexDropList:
			if mutexID not in dropIDList:
			continue
			if not isMutex:
			isMutex = True
			curDropIDCnt = dropIDList.count(mutexID)
			# 如果超过1个，则移除多余的，只保留一个
			if curDropIDCnt > 1:
			for _ in xrange(curDropIDCnt - 1):
			dropIDList.remove(mutexID)
			continue

			# 已经是互斥的了，该ID不可掉落，全部移除
			while mutexID in dropIDList:
			dropIDList.remove(mutexID)

			return dropIDList

			def __GetAppointDropItemIDList(curPlayer, npcID, ipyDrop, doCountRate, doCountAdd, tianxuanBuff):
			## 指定物品ID掉落

			dropItemIDList = []

			itemDropLimitDayInfo = IpyGameDataPY.GetFuncEvalCfg("ItemDropCountLimit", 2, {}) # 每日个人掉落物品个数限制 {物品ID:每日掉落上限, ...}
			# 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 只掉本职业的
			ItemKeyDropRateJobDict = ipyDrop.GetItemKeyDropRateJob() # {物品ID集合key:概率, ...}，只掉本职业的，优先级高
			if ItemKeyDropRateJobDict:
			for jobItemKey, dropRate in ItemKeyDropRateJobDict.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
			mustDropCount = dropRate / Def_NPCMaxDropRate
			dropRate = dropRate % Def_NPCMaxDropRate # 基础概率
			canDropCount = mustDropCount
			doCnt = ItemKeyMaxDropCountDict.get(jobItemKey, 1) # 默认1个
			doCnt = __GetNPCDropDoCountChange(doCnt, doCountRate, doCountAdd)
			for _ in xrange(doCnt):
			if not GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate):
			continue
			canDropCount += 1

			jobItemID = jobItemList[job - 1]
			for _ in xrange(canDropCount):
			dropItemIDList.append(jobItemID)
			#GameWorld.DebugLog("掉落自身职业指定物品ID: jobItemKey=%s,jobItemID=%s" % (jobItemKey, jobItemID))

			# 1.2 随机掉落一个
			ItemKeyDropRateDict = ipyDrop.GetItemKeyDropRate() # {物品ID集合key:概率, ...}，随机掉一个，优先级低
			tianxuanItemKeyRateDict = ipyDrop.GetTianxuanItemKeyRate() # 天玄丹指定ID集合Key概率{物品ID集合key:概率, ...}
			if tianxuanBuff and tianxuanItemKeyRateDict:
			ItemKeyDropRateDict = copy.deepcopy(ItemKeyDropRateDict)
			ItemKeyDropRateDict.update(tianxuanItemKeyRateDict)

			if ItemKeyDropRateDict:
			GameWorld.DebugLog("ItemKeyDropRateDict:%s" % ItemKeyDropRateDict)
			for itemKey, dropRate in ItemKeyDropRateDict.items():
			# 在只掉本职业里的不处理
			if itemKey in ItemKeyDropRateJobDict:
			continue
			mustDropCount = dropRate / Def_NPCMaxDropRate
			dropRate = dropRate % Def_NPCMaxDropRate # 基础概率
			canDropCount = mustDropCount
			doCnt = ItemKeyMaxDropCountDict.get(itemKey, 1) # 默认1个
			doCnt = __GetNPCDropDoCountChange(doCnt, doCountRate, doCountAdd)
			for _ in xrange(doCnt):
			if not GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate):
			continue
			canDropCount += 1

			for _ in xrange(canDropCount):
			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
			if __dropIDCountLimitToday(curPlayer, randItemID, itemDropLimitDayInfo):
			continue
			dropItemIDList.append(randItemID)
			#GameWorld.DebugLog("掉落随机指定物品ID: itemKey=%s,randItemID=%s" % (itemKey, randItemID))

			# 2. 指定掉落ID处理, 受全局设定影响
			itemIDDropRateDict = ipyDrop.GetItemIDDropRate() # {物品ID:概率, ...}
			itemIDDropMaxCntDict = ipyDrop.GetItemIDMaxDropCount() # {物品ID:最大掉落个数,...}
			tianxuanItemIDRate = ipyDrop.GetTianxuanItemIDRate() # 天玄丹指定ID概率 {物品ID:概率, ...}
			if tianxuanBuff and tianxuanItemIDRate:
			itemIDDropRateDict = copy.deepcopy(itemIDDropRateDict)
			itemIDDropRateDict.update(tianxuanItemIDRate)

			# 全局材料掉落控制
			globalDropCDDict = IpyGameDataPY.GetFuncCfg("GlobalDropCD", 1) # {物品ID:分钟, ...}
			globalDropRateDict = IpyGameDataPY.GetFuncCfg("NPCGlobalDropRate", 1) # {物品ID:[[npcID列表], "概率公式"], ...}
			gw = GameWorld.GetGameWorld()

			if itemIDDropRateDict:
			GameWorld.DebugLog("itemIDDropRateDict=%s" % itemIDDropRateDict)

			for itemID, dropRate in itemIDDropRateDict.items():

			if not dropRate:
			continue

			# 根据击杀次数来的另外计算，不在此判断
			if itemID in globalDropRateDict:
			continue

			doCnt = itemIDDropMaxCntDict.get(itemID, 1) # 默认1个

			# 判断是否全局掉落CD中
			if itemID in globalDropCDDict:
			curTime = int(time.time())
			lastDropTime = gw.GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_LastDropTime % itemID)
			cdTime = globalDropCDDict[itemID] * 60
			remainTime = cdTime - (curTime - lastDropTime)
			if remainTime > 0:
			GameWorld.DebugLog("该物品全局掉落CD中，不掉落！itemID=%s,cdTime=%s,curTime=%s,lastDrop=%s,remainTime=%s"
			% (itemID, cdTime, curTime, lastDropTime, remainTime))
			continue
			else:
			doCnt = __GetNPCDropDoCountChange(doCnt, doCountRate, doCountAdd)

			#GameWorld.DebugLog(" 指定判断: itemID=%s, dropRate=%s, doCnt=%s" % (itemID, dropRate, doCnt))
			for _ in xrange(doCnt):
			if not GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate):
			continue

			if __dropIDCountLimitToday(curPlayer, itemID, itemDropLimitDayInfo):
			continue

			dropItemIDList.append(itemID)
			if itemID in globalDropCDDict:
			# 通知GameServer记录
			msgInfo = str([itemID, curTime])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "GlobalDropCD", msgInfo, len(msgInfo))
			DataRecordPack.DR_GlobalDropCD(curPlayer, npcID, itemID)
			break

			# 3. 指定击杀次数全局掉率
			for itemID, dropInfo in globalDropRateDict.items():
			npcIDList, rateFormat = dropInfo
			if npcID not in npcIDList:
			continue

			killedCnt = gw.GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_DropNPCKilledCnt % itemID)
			dropRate = eval(FormulaControl.GetCompileFormula("KilledCntDropRate_%s" % itemID, rateFormat))
			isDrop = GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate)
			if isDrop:
			dropItemIDList.append(itemID)
			DataRecordPack.DR_GlobalDropRate(curPlayer, npcID, itemID, killedCnt, dropRate)

			# 通知GameServer记录
			updKilledCnt = 0 if isDrop else (killedCnt + 1)
			msgInfo = str([itemID, updKilledCnt])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "GlobalDropRate", msgInfo, len(msgInfo))

			# 4. 指定全服击杀次数必掉，算额外掉落
			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.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, itemIDCountDict, randItemIDCountList = killCountDropDict[updNPCKilledCount]
			for itemID, itemCount in itemIDCountDict.items():
			if isJobLimit:
			itemData = GameWorld.GetGameData().GetItemByTypeID(itemID)
			if not itemData:
			continue
			itemJob = itemData.GetJobLimit()
			if itemJob and itemJob != curPlayer.GetJob():
			# 非本职业可用，不掉落
			GameWorld.DebugLog("全服击杀次数必掉，非本职业可用，不掉落! itemID=%s" % itemID)
			continue
			dropItemIDList += [itemID] * itemCount
			GameWorld.Log("全服击杀次数必掉物品: itemID=%s,itemCount=%s" % (itemID, itemCount))
			if randItemIDCountList:
			if isJobLimit:
			randJobItemList = []
			for rItemID, rItemCount in randItemIDCountList:
			itemData = GameWorld.GetGameData().GetItemByTypeID(rItemID)
			if not itemData:
			continue
			itemJob = itemData.GetJobLimit()
			if itemJob and itemJob != curPlayer.GetJob():
			# 非本职业可用，不掉落
			GameWorld.DebugLog("全服击杀次数必掉随机，非本职业可用，不掉落! rItemID=%s" % rItemID)
			continue
			randJobItemList.append([rItemID, rItemCount])
			randItemID, randItemCount = random.choice(randJobItemList)
			else:
			randItemID, randItemCount = random.choice(randItemIDCountList)
			dropItemIDList += [randItemID] * randItemCount
			GameWorld.Log("全服击杀次数必掉随机物品: randItemID=%s,randItemCount=%s" % (randItemID, randItemCount))

			return dropItemIDList

			def __dropIDCountLimitToday(curPlayer, itemID, itemDropLimitDayInfo):
			## 处理今日掉落物品ID个数限制
			# @return: 是否限制
			if itemID not in itemDropLimitDayInfo:
			return False
			dropCountTodayMax = itemDropLimitDayInfo[itemID]
			if not dropCountTodayMax:
			return False
			dropCountToday = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_DropCountToday % itemID)
			if dropCountToday >= dropCountTodayMax:
			GameWorld.DebugLog(" 物品ID今日掉落次数已达上限: itemID=%s,dropCountToday=%s" % (itemID, dropCountToday), curPlayer.GetPlayerID())
			return True
			dropCountToday += 1
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_DropCountToday % itemID, dropCountToday)
			GameWorld.DebugLog(" 更新物品ID今日掉落次数: itemID=%s,dropCountToday=%s" % (itemID, dropCountToday), curPlayer.GetPlayerID())
			return False

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

			@@ -1452,9 +211,9 @@
			if not itemData.GetCanNPCDrop():
			continue

			if ItemCommon.GetItemClassLV(itemData) != classLV:
			if classLV != None and ItemCommon.GetItemClassLV(itemData) != classLV:
			continue
			if itemData.GetItemColor() != color:
			if color != None and itemData.GetItemColor() != color:
			continue
			suiteID = itemData.GetSuiteID()
			itemJob = itemData.GetJobLimit()
			@@ -1476,7 +235,7 @@
			if itemJob and itemJobList and itemJob not in itemJobList:
			continue
			curIsSuit = suiteID > 0
			if curIsSuit != isSuit:
			if isSuit != None and curIsSuit != isSuit:
			continue
			itemIDList.append(itemID)

			@@ -1485,128 +244,6 @@
			% (findType, findID, classLV, color, isSuit, placeList, itemJobList))
			return itemIDList

			def __GetNPCPieRateEquipDrop(ipyDrop, doCnt, equipDropPlus):
			## 获取NPC饼图掉率装备掉落信息
			dropEquipInfoList = []
			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))
			for _ in xrange(doCnt):
			dropInfo = GameWorld.GetResultByRandomList(dropRateList)
			if dropInfo:
			dropEquipInfoList.append(dropInfo)
			#GameWorld.DebugLog("饼图装备掉落结果: doCnt=%s, %s" % (doCnt, dropEquipInfoList))
			return dropEquipInfoList

			def __GetNPCIndepRateEquipDrop(mapID, ipyDrop, doCnt, equipDropPlus, curGrade=0):
			## 获取NPC独立掉率装备掉落信息
			npcID = ipyDrop.GetNPCID()
			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]

			orangeEquipPer = 0
			fbGradeOrangeEquipPerDict = IpyGameDataPY.GetFuncEvalCfg("FBGradeEquipDropRate2", 1) # 地图评级影响橙装概率百分率 {"mapID":[D级影响概率, ..., S级影响概率], ..}
			if str(mapID) in fbGradeOrangeEquipPerDict and curGrade:
			orangeEquipPerList = fbGradeOrangeEquipPerDict[str(mapID)]
			orangeEquipPer = 0 if (curGrade <= 0 or curGrade > len(orangeEquipPerList)) else orangeEquipPerList[curGrade - 1]

			#colorDropCntDict = {} # 装备颜色已经掉落数 {颜色:数量, ...}
			dropEquipInfoList = []
			for _ in xrange(doCnt):
			for dropInfo, rate in indepRateDict.iteritems():
			dropRate = rate
			color = dropInfo[1]
			if color in gradeColorRateDict:
			colorRateList = gradeColorRateDict[color]
			colorRate = 10000 if (curGrade <= 0 or curGrade > len(colorRateList)) else colorRateList[curGrade - 1]
			dropRate = int(dropRate * colorRate / 10000.0)
			#GameWorld.DebugLog(" 评级影响颜色概率: curGrade=%s,colorRate=%s,dropRate=%s" % (curGrade, colorRate, dropRate))

			if color == ChConfig.Def_Quality_Orange and orangeEquipPer:
			dropRate = int(dropRate * orangeEquipPer / 100.0)
			#GameWorld.DebugLog("评级橙装掉率加成: orangeEquipPer=%s,dropRate=%s" % (orangeEquipPer, dropRate))

			dropRate = dropRate if not equipDropPlus else (dropRate + int(dropRate * equipDropPlus / 10000.0))
			mustDropCount = dropRate / Def_NPCMaxDropRate
			dropRate = dropRate % Def_NPCMaxDropRate # 基础概率
			#GameWorld.DebugLog(" dropInfo=%s,rate=%s,mustDropCount=%s,dropRate=%s" % (dropInfo, rate, mustDropCount, dropRate))
			curDropCount = mustDropCount
			if GameWorld.CanHappen(dropRate, maxRate=Def_NPCMaxDropRate):
			curDropCount += 1
			if not curDropCount:
			continue

			for _ in xrange(curDropCount):
			dropEquipInfoList.append(dropInfo)
			#GameWorld.DebugLog("独立概率装备掉落结果: doCnt=%s, %s" % (doCnt, dropEquipInfoList))
			return dropEquipInfoList

			def __GetDropMoneyValue(curPlayer, ipyDrop, realmNPCIpyData):
			baseMoney = FBLogic.OnGetNPCDropMoney(curPlayer)
			if baseMoney <= 0:
			# 获得掉落数量
			if realmNPCIpyData:
			baseMoney = random.randint(realmNPCIpyData.GetDropMoneyMin(), realmNPCIpyData.GetDropMoneyMax())
			else:
			baseMoney = random.randint(ipyDrop.GetDropMoneyMin(), ipyDrop.GetDropMoneyMax())

			if baseMoney <= 0:
			return 0

			moneyValue = baseMoney
			# 玩家金钱掉落加成
			if curPlayer != None:

			addRateEx = 0

			addRate = float(curPlayer.GetGoldFoundRate() + addRateEx) / ShareDefine.Def_MaxRateValue
			moneyValue = int(moneyValue + moneyValue * addRate)
			#特殊地图杀怪金币外层加成
			outerMoneyRate = FBLogic.OnGetOuterMoneyRate(curPlayer)
			if outerMoneyRate > 0:
			moneyValue = int(moneyValue * outerMoneyRate / float(ShareDefine.Def_MaxRateValue))

			if moneyValue >= 65535:
			moneyValue = random.randint(65000, 65530)
			return moneyValue

			def GetKillCountDropItemList(curPlayer, npcID, needKillCount, killDropItemList):
			## 获取击杀次数额外掉落
			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 []

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

			jobDropInfo = []
			if killCountPri >= needKillCount:
			isJobLimit = 1
			#[itemID,...]
			for dropItemID in killDropItemList:
			itemData = GameWorld.GetGameData().GetItemByTypeID(dropItemID)
			if not itemData:
			GameWorld.ErrLog("掉落物品ID不存在, dropItemID=%s" % dropItemID)
			continue
			itemJob = itemData.GetJobLimit()
			if isJobLimit and itemJob and itemJob != curPlayer.GetJob():
			# 非本职业可用，不掉落
			#GameWorld.DebugLog("非本职业可用，不掉落! dropItemID=%s" % dropItemID)
			continue
			jobDropInfo.append(dropItemID)
			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
			######################################################################
			#---------------------------------------------------------------------
			#移动相关
			@@ -1973,7 +610,7 @@
			#===============================================================================

			def GetDefaultMaxAngryNPCIDList():
			return GameLogic_FamilyInvade.GetDefaultMaxAngryNPCIDList()
			return []

			#---------------------------------------------------------------------
			##NPC进入战斗状态
			@@ -2148,115 +785,6 @@

			return

			#// B4 0F 回收私有专属木桩怪 #tagCMRecyclePriWoodPile
			#
			#struct tagCMRecyclePriWoodPile
			#{
			# tagHead Head;
			# DWORD ObjID;
			#};
			def OnRecyclePriWoodPile(index, clientData, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			objID = clientData.ObjID
			curNPC = GameWorld.FindNPCByID(objID)
			if not curNPC:
			return
			if curNPC.GetType() not in [ChConfig.ntPriWoodPilePVE, ChConfig.ntPriWoodPilePVP]:
			return
			summonPlayerID = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_PriWoodPilePlayerID)
			if curPlayer.GetPlayerID() != summonPlayerID:
			#GameWorld.DebugLog("非玩家私有木桩...")
			return
			SetDeadEx(curNPC)
			return

			#// B4 0C 召唤私有专属木桩怪 #tagCMSummonPriWoodPile
			#
			#struct tagCMSummonPriWoodPile
			#{
			# tagHead Head;
			# DWORD NPCID;
			# BYTE Count; //默认1个，最多5个
			# DWORD HP; //默认0取最大值，其中一个血量数值大于0则用指定血量
			# DWORD HPEx; //默认0取最大值，其中一个血量数值大于0则用指定血量
			#};
			def OnSummonPriWoodPile(index, clientData, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			npcID = clientData.NPCID
			count = clientData.Count
			hp = clientData.HP
			hpEx = clientData.HPEx
			SummonPriWoodPile(curPlayer, npcID, count, hp, hpEx)
			return

			def SummonPriWoodPile(curPlayer, npcID, count, hp=0, hpEx=0):
			''' 召唤私有专属木桩怪
			'''

			mapID = PlayerControl.GetCustomMapID(curPlayer)
			lineID = PlayerControl.GetCustomLineID(curPlayer)
			if mapID:
			if not FBLogic.OnCanSummonPriWoodPile(curPlayer, mapID, lineID, npcID, count):
			GameWorld.ErrLog("无法召唤木桩怪!mapID=%s,lineID=%s,npcID=%s,count=%s" % (mapID, lineID, npcID, count))
			return

			if count != 1:
			hp, hpEx = 0, 0 # 指定血量的暂仅适用于单只的

			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerPriWoodPileNPCDict:
			PyGameData.g_playerPriWoodPileNPCDict[playerID] = []
			playerPriWoodNPCList = PyGameData.g_playerPriWoodPileNPCDict[playerID]
			maxCount = 3
			nowCount = len(playerPriWoodNPCList)
			summonCount = min(count, maxCount - nowCount)
			GameWorld.DebugLog("召唤木桩: npcID=%s,count=%s,maxCount=%s,nowCount=%s,summonCount=%s,hp=%s,hpEx=%s"
			% (npcID, count, maxCount, nowCount, summonCount, hp, hpEx))
			if summonCount <= 0:
			return

			npcManager = GameWorld.GetNPCManager()
			for _ in xrange(summonCount):
			#summonNPC = curPlayer.SummonNewNPC()
			summonNPC = npcManager.AddPlayerSummonNPC()

			#设置召唤兽基础信息
			summonNPC.SetNPCTypeID(npcID)
			summonNPC.SetSightLevel(curPlayer.GetSightLevel())
			#初始化
			InitNPC(summonNPC)

			#玩家召唤兽列表添加召唤兽,召唤兽添加主人
			#summonNPC.SetOwner(curPlayer)
			summonNPC.SetDict(ChConfig.Def_NPC_Dict_PriWoodPilePlayerID, playerID)

			#将召唤兽召唤出来
			#玩家周围随机出生点
			#技能召唤坐标 ChConfig.Def_SummonAppearDist
			summonPos = GameMap.GetEmptyPlaceInArea(curPlayer.GetPosX(), curPlayer.GetPosY(), 3)
			summonNPC.Reborn(summonPos.GetPosX(), summonPos.GetPosY(), False)
			NPCControl(summonNPC).ResetNPC_Init(isReborn=True)
			if hp or hpEx:
			hpTotal = hpEx * ShareDefine.Def_PerPointValue + hp
			GameObj.SetHP(summonNPC, hpTotal)
			GameObj.SetMaxHP(summonNPC, hpTotal)
			summonNPC.NotifyAppear() # 最终统一通知NPC出现
			playerPriWoodNPCList.append(summonNPC)

			return

			def ClearPriWoodPile(curPlayer):
			## 清除私有木桩
			playerID = curPlayer.GetPlayerID()
			if playerID not in PyGameData.g_playerPriWoodPileNPCDict:
			return
			playerPriWoodNPCList = PyGameData.g_playerPriWoodPileNPCDict.pop(playerID)
			for summonNPC in playerPriWoodNPCList:
			if not summonNPC:
			continue
			SetDeadEx(summonNPC)
			return

			## 设置npc死亡及自身处理(请不要将游戏逻辑加在此函数中)
			# @param curNPC：npc实例
			# @return
			@@ -2288,15 +816,13 @@
			# 暗金boss
			if ChConfig.IsGameBoss(curNPC):
			# 通知GameServer boss状态封魔坛在副本里单独处理
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog('BOSSInfo', npcid)
			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())

			if GetDropOwnerType(curNPC) == ChConfig.DropOwnerType_Family:
			FamilyRobBoss.ClearFamilyOwnerBossHurt(curNPC)
			#ipyData = IpyGameDataPY.GetIpyGameDataNotLog('BOSSInfo', npcid)
			#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())

			ChNPC.OnNPCSetDead(curNPC)

			if npcid == IpyGameDataPY.GetFuncCfg("CrossYaomoBoss", 1):
			@@ -2304,10 +830,6 @@

			# 清除队伍成员伤血列表
			AttackCommon.ClearTeamPlayerHurtValue(curNPC)
			# 清除自定义伤血列表
			#BossHurtMng.ClearHurtValueList(curNPC)
			NPCHurtManager.DeletePlayerHurtList(curNPC)
			NPCHurtMgr.DeletePlayerHurtList(curNPC)
			if curNPC.GetType() == ChConfig.ntRobot:
			lineID = GameWorld.GetGameWorld().GetLineID()
			lineRobotJobDict = PyGameData.g_fbRobotJobDict.get(lineID, {})
			@@ -2326,19 +848,18 @@

			# C++设置npc死亡
			notifyClient = True
			tfMgr = TurnAttack.GetTurnFightMgr()
			turnFight = tfMgr.getNPCTurnFight(objID)
			if turnFight:
			notifyClient = False # 回合制战斗的由py自己通知
			# //04 07 NPC消失#tagNPCDisappear 此处通知消失，与回合制死亡区分
			clientPack = ChNetSendPack.tagNPCDisappear()
			clientPack.NPCID = [objID]
			clientPack.Count = len(clientPack.NPCID)
			turnFight.addBatPack(clientPack)
			#tfMgr = TurnAttack.GetTurnFightMgr()
			#turnFight = tfMgr.getNPCTurnFight(objID)
			#if turnFight:
			# notifyClient = False # 回合制战斗的由py自己通知
			# # //04 07 NPC消失#tagNPCDisappear 此处通知消失，与回合制死亡区分
			# clientPack = ChNetSendPack.tagNPCDisappear()
			# clientPack.NPCID = [objID]
			# clientPack.Count = len(clientPack.NPCID)
			# turnFight.addBatPack(clientPack)
			curNPC.SetDead(curNPC.GetDictByKey(ChConfig.Def_NPCDead_Reason),
			curNPC.GetDictByKey(ChConfig.Def_NPCDead_KillerType),
			curNPC.GetDictByKey(ChConfig.Def_NPCDead_KillerID), notifyClient)
			tfMgr.delNPCGUID(objID)
			return

			def GameServer_KillGameWorldBoss(bossID, killPlayerName, hurtValue, isNotify=True, killerIDList=[]):
			@@ -2376,86 +897,6 @@
			return

			def OnPlayerKillBoss(curPlayer, npcID, mapID, isCrossServer):
			npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not npcData:
			return
			killBossCntLimitDict = IpyGameDataPY.GetFuncCfg('KillBossCntLimit', 1)
			limitIndex = GameWorld.GetDictValueByKey(killBossCntLimitDict, npcID)
			if limitIndex != None:
			totalKey = ChConfig.Def_PDict_Boss_KillCntTotal % limitIndex
			totalCnt = min(curPlayer.NomalDictGetProperty(totalKey, 0) + 1, ChConfig.Def_UpperLimit_DWord)
			PlayerControl.NomalDictSetProperty(curPlayer, totalKey, totalCnt)
			#今日杀怪次数+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("更新击杀Boss次数: index=%s, todayCnt=%s, totalCnt=%s" % (limitIndex, newCnt, totalCnt), curPlayer.GetPlayerID())

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

			if isCrossServer:
			return

			if limitIndex == ShareDefine.Def_Boss_Func_World:
			# 世界BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillWorldBoss, 1)
			PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_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)
			PlayerFeastTravel.AddFeastTravelTaskValue(curPlayer, ChConfig.Def_FeastTravel_WorldBoss, 1)
			PlayerActLogin.AddLoginAwardActionCnt(curPlayer, ChConfig.Def_LoginAct_WorldBOSS, 1)
			PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_WorldBoss, 1)
			PlayerZhanling.AddZhanlingValue(curPlayer, PlayerZhanling.ZhanlingType_Huanjingge, 1)
			PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_WorldBoss, 1)

			elif limitIndex == ShareDefine.Def_Boss_Func_Home:
			#BOSS之家
			# BOSS之家BOSS击杀成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillBossHomeBoss, 1)
			PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_KillBossHome, 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)
			PlayerFeastTravel.AddFeastTravelTaskValue(curPlayer, ChConfig.Def_FeastTravel_BossHome, 1)
			PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_BossHome, 1)

			if mapID == ChConfig.Def_FBMapID_CrossPenglai:
			#跨服蓬莱仙境
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_CrossPenglai)
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillCrossPenglaiBoss, 1)
			PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_KillCrossPenglaiBoss, 1)
			PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_CrossPenglaiBoss, 1)
			elif mapID == ChConfig.Def_FBMapID_CrossDemonLand:
			#跨服魔化之地
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_CrossDemonLand)
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillCrossDemonLandBoss, 1)
			PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_KillCrossDemonLandBoss, 1)
			PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_CrossDemonLandBoss, 1)
			if mapID in [ChConfig.Def_FBMapID_CrossPenglai, ChConfig.Def_FBMapID_CrossDemonLand]:
			PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_CrossBoss)
			PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_CrossBoss, 1)

			if npcData.GetIsBoss() == ChConfig.Def_NPCType_Boss_Dark:
			PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_KillBoss)

			# 个人首杀记录
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog("BOSSFirstKill", npcID)
			if ipyData:
			GY_Query_BossFirstKill.SetPlayerFirstKillBoss(curPlayer, npcID)
			#Boss投资
			PlayerGoldInvest.OnKillBoss(curPlayer, npcID)
			return

			#################################################
			@@ -2914,8 +1355,8 @@
			addAngry += useSkill.GetSkillAngry()

			# 玩家攻击增加额外仇恨
			if objDetel.GetGameObjType() == IPY_GameWorld.gotPlayer:
			addAngry += PlayerControl.GetAddAngry(objDetel)
			#if objDetel.GetGameObjType() == IPY_GameWorld.gotPlayer:
			# addAngry += PlayerControl.GetAddAngry(objDetel)

			self.AddObjToAngryList(objDetel, addAngry)
			return
			@@ -3276,8 +1717,6 @@
			#清除所有身上buff
			self.ClearAllBuff(isClearAuraBuff)
			curNPC = self.__Instance
			NPCHurtManager.ClearPlayerHurtList(curNPC)
			NPCHurtMgr.ClearPlayerHurtList(curNPC)
			return True

			#---------------------------------------------------------------------
			@@ -3626,9 +2065,7 @@
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog('BOSSInfo', curNPCID)
			if ipyData:
			GameServe_GameWorldBossState(curNPCID, 1)
			if GetDropOwnerType(curNPC) == ChConfig.DropOwnerType_Family:
			FamilyRobBoss.FamilyOwnerBossOnReborn(curNPC)


			# 检查是否有光环, 在重生时处理，不然可能导致有些无战斗逻辑的怪物无法套上光环buff
			skillManager = curNPC.GetSkillManager()
			for index in xrange(skillManager.GetSkillCount()):
			@@ -3646,13 +2083,13 @@

			def __notifyAppear(self):
			## //04 06 NPC出现#tagNPCAppear，可能也有 04 08 玩家召唤NPC出现#tagPlayerSummonNPCAppear，卡牌先简化，只使用0406
			curNPC = self.__Instance
			objID = curNPC.GetID()
			turnFight = TurnAttack.GetTurnFightMgr().getNPCTurnFight(objID)
			if not turnFight:
			# 非回合制怪保留原通知
			curNPC.NotifyAppear()
			return
			#curNPC = self.__Instance
			#objID = curNPC.GetID()
			#turnFight = TurnAttack.GetTurnFightMgr().getNPCTurnFight(objID)
			#if not turnFight:
			# # 非回合制怪保留原通知
			# curNPC.NotifyAppear()
			# return

			# 回合制怪不通知，统一由 // B4 24 回合战斗初始化 #tagSCTurnFightInit
			return
			@@ -3780,18 +2217,18 @@
			heroAttrDict = {}
			if lineupPlayerID:
			heroAttrDict.update({
			ShareDefine.Def_Effect_Atk:500000000,
			ShareDefine.Def_Effect_Def:50000000,
			ShareDefine.Def_Effect_MaxHP:3000000000,
			ChConfig.AttrID_Atk:500000000,
			ChConfig.AttrID_Def:50000000,
			ChConfig.AttrID_MaxHP:3000000000,
			})
			else:
			npcDataEx = GetNPCDataEx(curNPC.GetNPCID())
			npcDataEx = GetNPCDataPy(curNPC.GetNPCID())
			if not npcDataEx:
			return
			heroAttrDict.update({
			ShareDefine.Def_Effect_Atk:npcDataEx.GetAtk(),
			ShareDefine.Def_Effect_Def:npcDataEx.GetDef(),
			ShareDefine.Def_Effect_MaxHP:npcDataEx.GetMaxHP(),
			ChConfig.AttrID_Atk:npcDataEx.GetAtk(),
			ChConfig.AttrID_Def:npcDataEx.GetDef(),
			ChConfig.AttrID_MaxHP:npcDataEx.GetMaxHP(),
			})

			GameWorld.DebugLog("heroAttrDict: ID:%s,NPCID:%s,%s" % (curNPC.GetID(), curNPC.GetNPCID(), heroAttrDict))
			@@ -3800,23 +2237,10 @@
			curNPC.ResetNPCBattleState()

			# 设置属性
			curNPC.SetMinAtk(heroAttrDict.get(ShareDefine.Def_Effect_Atk, 1))
			curNPC.SetMaxAtk(heroAttrDict.get(ShareDefine.Def_Effect_Atk, 1))
			curNPC.SetDef(heroAttrDict.get(ShareDefine.Def_Effect_Def, 1))
			GameObj.SetMaxHP(curNPC, heroAttrDict.get(ShareDefine.Def_Effect_MaxHP, 1))

			#GameObj.SetMissRate(curNPC, npcDataEx.GetMissRate())
			#GameObj.SetMissDefRate(curNPC, npcDataEx.GetMissDefRate())
			#GameObj.SetSuperHitRate(curNPC, npcDataEx.GetSuperHitRate())
			#GameObj.SetSuperHitRateReduce(curNPC, npcDataEx.GetSuperHitRateReduce())
			#GameObj.SetFaintRate(curNPC, npcDataEx.GetFaintRate())
			#GameObj.SetFaintDefRate(curNPC, npcDataEx.GetFaintDefRate())
			#GameObj.SetComboRate(curNPC, npcDataEx.GetComboRate())
			#GameObj.SetComboDefRate(curNPC, npcDataEx.GetComboDefRate())
			#GameObj.SetAtkBackRate(curNPC, npcDataEx.GetAtkBackRate())
			#GameObj.SetAtkBackDefRate(curNPC, npcDataEx.GetAtkBackDefRate())
			#GameObj.SetSuckHPPer(curNPC, npcDataEx.GetSuckHPPer())
			#GameObj.SetSuckHPDefPer(curNPC, npcDataEx.GetSuckHPDefPer())
			curNPC.SetMinAtk(heroAttrDict.get(ChConfig.AttrID_Atk, 1))
			curNPC.SetMaxAtk(heroAttrDict.get(ChConfig.AttrID_Atk, 1))
			curNPC.SetDef(heroAttrDict.get(ChConfig.AttrID_Def, 1))
			GameObj.SetMaxHP(curNPC, heroAttrDict.get(ChConfig.AttrID_MaxHP, 1))
			return

			## 刷新NPC属性
			@@ -3862,29 +2286,6 @@

			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_HP()
			curNPC.Notify_MaxHP()
			return

			# NPC移动速度特殊处理，只处理百分比不能处理固定值
			# 因为 ChConfig.TYPE_Calc_AttrSpeed 非服务端移动速度，偷懒处理法
			def RefreshNPCSpeed(self, allAttrList):
			@@ -3898,9 +2299,6 @@
			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


			@@ -4003,9 +2401,6 @@
			npcID = curNPC.GetNPCID()
			#######################特殊NPC的处理

			#boss伤血排行榜击杀逻辑
			#BossHurtMng.BossOnKilled(curNPC)

			#掉落需要用到摸怪，所以在处理掉落奖励之前设置
			self.__SetFeelNPCPlayerList()

			@@ -4015,27 +2410,17 @@
			#杀死NPC, 触发任务
			self.__EventKillNpc()

			mapID = GameWorld.GetMap().GetMapID()
			killerName = "" if not self.__Killer else self.__Killer.GetPlayerName()
			# 记录boss击杀信息的NPC
			bossIpyData = IpyGameDataPY.GetIpyGameDataListNotLog('BOSSInfo', npcID)
			if bossIpyData and mapID not in [ChConfig.Def_FBMapID_ZhuXianBoss, ChConfig.Def_FBMapID_SealDemon]:
			if GetDropOwnerType(curNPC) == ChConfig.DropOwnerType_Family:
			killerName = FamilyRobBoss.FamilyOwnerBossOnKilled(curNPC, self.__OwnerHurtID)
			#KillerJob = 0 if not self.__Killer else self.__Killer.GetJob()
			killerIDList = [player.GetPlayerID() for player in self.__ownerPlayerList]
			GameServer_KillGameWorldBoss(curNPC.GetNPCID(), killerName, 0, True, killerIDList)
			#mapID = GameWorld.GetMap().GetMapID()
			#killerName = "" if not self.__Killer else self.__Killer.GetPlayerName()
			## 记录boss击杀信息的NPC
			#bossIpyData = IpyGameDataPY.GetIpyGameDataListNotLog('BOSSInfo', npcID)
			#if bossIpyData and mapID not in [ChConfig.Def_FBMapID_ZhuXianBoss, ChConfig.Def_FBMapID_SealDemon]:
			# killerIDList = [player.GetPlayerID() for player in self.__ownerPlayerList]
			# GameServer_KillGameWorldBoss(curNPC.GetNPCID(), killerName, 0, True, killerIDList)

			if npcID == IpyGameDataPY.GetFuncCfg("BossRebornServerBoss", 3):
			PlayerControl.WorldNotify(0, "BossRebornBossKilled", [curNPC.GetNPCID()])

			#===========================================================================================
			# # 暗金boss
			# if curNPC.GetIsBoss() == ChConfig.Def_NPCType_Boss_Dark:
			# #PlayerControl.WorldNotify(0, "Old_andyshao_861048", [curNPC.GetNPCID()])
			# if mapID == ChConfig.Def_MapID_DouHunTan:
			# NPCCustomRefresh.DoRefreshNeutralBoss(npcID)

			#清空NPC的仇恨
			curNPC.GetNPCAngry().Clear()
			return
			@@ -4045,7 +2430,7 @@
			curNPC = self.__Instance
			self.__FeelPlayerList = []

			npcHurtList = NPCHurtManager.GetPlayerHurtList(curNPC)
			npcHurtList = [] #NPCHurtManager.GetPlayerHurtList(curNPC)
			if not npcHurtList:
			npcHurtList = curNPC.GetPlayerHurtList()
			#npcHurtList.Sort() #这里不排序，只要有伤害就算
			@@ -4094,68 +2479,6 @@
			self.__MissionOnKillNPC(eventPlayer, True)
			return


			#---------------------------------------------------------------------
			def __GetDropMoneyModelID(self, moneyValue):
			## 获取掉落金币模型ID
			if not moneyValue:
			return 0
			moneyItemList = IpyGameDataPY.GetFuncEvalCfg("GoldModel", 1) # 金币掉落数量对应模型-[(最大金币数,物品模型ID), ...]
			if not moneyItemList:
			return 0
			for count, moneyID in moneyItemList:
			if moneyValue <= count:
			return moneyID
			return moneyItemList[-1][1]

			def __NPCSpecialDropItem(self, dropPlayer, ownerPlayerList, ipyDrop):
			'''特殊掉落 (私有特殊掉落 + 击杀次数特殊掉落), 支持摸怪
			@return: None
			@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]
			curGrade = GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_Grade)
			priDropInfoList = gradePriItemIDDropDict.get(curGrade, [])
			priDropIDList = []
			for priItemID, priItemCount in priDropInfoList:
			priDropIDList += [priItemID] * priItemCount
			else:
			priDropIDList = ipyDrop.GetPriItemIDDrop()
			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

			## 物品掉落
			# @param self 类实例
			# @param dropPlayer 掉落判断相关玩家
			@@ -4163,106 +2486,6 @@
			# @param HurtID 伤血ID
			# @return 返回值无意义
			def __NPCDropItem(self, dropPlayer, hurtType, hurtID, ownerPlayerList=[], isOnlySelfSee=False):
			if not dropPlayer:
			return
			curNPC = self.__Instance
			PlayerActCollectWords.OnKillNPCDrop(dropPlayer, curNPC)
			if curNPC.GetType() in [ChConfig.ntPriWoodPilePVE, ChConfig.ntPriWoodPilePVP]:
			GameWorld.DebugLog("木桩怪，不掉落物品！")
			return
			npcID = curNPC.GetNPCID()
			mapID = GameWorld.GetMap().GetMapID()
			mapID = FBCommon.GetRecordMapID(mapID)
			isGameBoss = ChConfig.IsGameBoss(curNPC)
			if mapID in [ChConfig.Def_FBMapID_MunekadoTrial, ChConfig.Def_FBMapID_DemonKing, ChConfig.Def_FBMapID_SealDemon, ChConfig.Def_FBMapID_ZhuXianBoss,
			ChConfig.Def_FBMapID_KillDevil]:
			GameWorld.DebugLog("该地图不走直接掉落物品逻辑！mapID=%s" % mapID)
			return
			if isGameBoss:
			GameWorld.Log("NPC开始掉落: npcID=%s,dropPlayerID=%s" % (npcID, dropPlayer.GetPlayerID()), dropPlayer.GetPlayerID())
			ipyDrop = GetNPCDropIpyData(npcID)
			if not ipyDrop:
			if isGameBoss:
			curWorldLV = GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
			GameWorld.ErrLog("取不到NPC掉落信息!npcID=%s,curWorldLV=%s" % (npcID, curWorldLV))
			return

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

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

			specItemSign = "SpecItem"
			playerSpecDropList = []
			if dropInfo:
			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())

			sightLevel = PlayerControl.GetMapRealmDifficulty(dropPlayer)
			gameMap = GameWorld.GetMap()
			dropPosX, dropPosY = curNPC.GetPosX(), curNPC.GetPosY() # 以NPC为中心点开始掉落
			index = 0
			for posX, posY in ChConfig.Def_DropItemAreaMatrix:
			resultX = dropPosX + posX
			resultY = dropPosY + posY

			if not gameMap.CanMove(resultX, resultY):
			#玩家不可移动这个点
			continue

			if index > len(dropIDList) - 1:
			break

			isDropInItemPack = False
			itemID = dropIDList[index]
			index += 1
			if itemID == specItemSign:
			if not playerSpecDropList:
			continue
			itemCnt = 1
			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
			isAuctionItem = itemID in auctionIDList

			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)
			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, event=["NPCDrop", False, {"npcID":npcID}]):
			#通知客户端
			SendVirtualItemDrop(ownerPlayer, itemID, resultX, resultY, dropItemDataStr)

			else:
			self.__MapCreateItem(curItem, resultX, resultY, ownerType, ownerID, isOnlySelfSee=isOnlySelfSee, sightLevel=sightLevel)
			return
			#---------------------------------------------------------------------
			## NPC被杀死逻辑处理
			@@ -4467,12 +2690,6 @@
			return

			curNPC = self.__Instance

			# VIP杀怪加攻
			PlayerVip.DoAddVIPKillLVExp(lastHurtPlayer, GetNPCLV(curNPC))

			# SPֵ
			PlayerControl.AddZhenQiByKillNPC(lastHurtPlayer, curNPC.GetSP())
			return

			#---------------------------------------------------------------------
			@@ -4586,13 +2803,6 @@
			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

			@@ -4915,10 +3125,7 @@
			FBLogic.DoFB_DropOwner(curPlayer , curNPC)
			else:
			if GetNPCLV(curNPC) >= curPlayer.GetLV() - IpyGameDataPY.GetFuncCfg('DailyQuestKillMonster'):
			PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_KillNPC)
			PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_KillNPC)
			PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_KillNPC)
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillSpecificNPC, 1, [npcID])
			#PlayerPrestigeSys.AddRealmTaskValue(curPlayer, PlayerPrestigeSys.RealmTaskType_KillNPC, 1)

			if ChConfig.IsGameBoss(curNPC):
			@@ -4944,17 +3151,12 @@
			#不是普通NPC
			elif npcObjType != IPY_GameWorld.gnotNormal:
			return
			npcID = curNPC.GetNPCID()
			#GameWorld.DebugLog("__MissionOnKillNPC isFeel=%s" % (isFeel), curPlayer.GetPlayerID())
			#击杀特定NPC成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_KillSpecificNPC, 1, [npcID])
			return

			def __GetIsLog(self):
			## 测试查错日志，临时用
			## 相关bug：仙界秘境无经验、boss无掉落
			return ChConfig.IsGameBoss(self.__Instance)
			#return GameWorld.GetMap().GetMapID() == ChConfig.Def_FBMapID_BZZD or ChConfig.IsGameBoss(self.__Instance)

			#---------------------------------------------------------------------
			## 普通组队给经验
			@@ -4991,47 +3193,7 @@
			# @return 返回值, 获得经验
			# @remarks 获得经验, 可能是小数
			def __GetExp(self, playerLV, isTeam=False, player=None):
			curNPC = self.__Instance
			baseExp = 0
			#玩家不在副本中
			if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
			baseExp = FBLogic.OnGetNPCExp(player, curNPC)
			if baseExp > 0:
			return baseExp

			npcID = curNPC.GetNPCID()
			realmLV = PlayerControl.GetDifficultyRealmLV(curNPC.GetSightLevel())
			realmNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCRealmStrengthen", npcID, realmLV)
			if realmNPCIpyData:
			baseExp = realmNPCIpyData.GetExp()
			npcLV = realmNPCIpyData.GetLV()
			else:
			baseExp = curNPC.GetExp()
			npcLV = curNPC.GetLV()

			if baseExp == 0:
			#GameWorld.Log("杀怪经验异常,该NPC = %s,无经验"%(curNPC.GetID()))
			return 0

			playerID = 0 if not player else player.GetPlayerID()
			# 如果是队伍，则按伤害贡献度计算所获得经验比例
			if isTeam:
			if not player:
			return 0
			hurtPer = AttackCommon.GetTeamPlayerHurtPer(player, curNPC)
			if not hurtPer:
			return 0
			#GameWorld.DebugLog("队员击杀基础经验: npcID=%s,baseExp=%s,hurtPer=%s" % (curNPC.GetNPCID(), baseExp, hurtPer), playerID)
			baseExp *= hurtPer
			#else:
			# GameWorld.DebugLog("个人击杀基础经验: npcID=%s,baseExp=%s" % (curNPC.GetNPCID(), baseExp), playerID)

			#经验衰减公式 = max(杀怪经验 * max(1-max(玩家等级-怪物等级-10,0)*0.02)，0),1）
			exp = eval(FormulaControl.GetCompileFormula("ExpAttenuation", IpyGameDataPY.GetFuncCfg("ExpAttenuation", 1)))
			#exp = CalcNPCExp(baseExp, playerLV, npcLV)
			#GameWorld.DebugLog("击杀NPC最终基础经验: npcID=%s,npcLV=%s,playerLV=%s,baseExp=%s,exp=%s"
			# % (curNPC.GetNPCID(), npcLV, playerLV, baseExp, exp), playerID)
			return exp
			return 0

			#---------------------------------------------------------------------

			@@ -5097,19 +3259,14 @@
			GameWorld.Log("检查Boss死亡: lineID=%s,objID=%s,npcID=%s,dropOwnerType=%s"
			% (GameWorld.GetGameWorld().GetLineID(), curNPC.GetID(), curNPC.GetNPCID(), dropOwnerType))
			#if dropOwnerType == ChConfig.DropOwnerType_MaxHurt:
			maxHurtInfo = NPCHurtManager.RefreshHurtList(curNPC, tick, refreshInterval, isDead, checkCanDead)
			if not maxHurtInfo:
			maxHurtInfo = NPCHurtMgr.RefreshHurtList(curNPC, tick, refreshInterval, isDead)

			if maxHurtInfo:
			tagObj, ownerType, ownerID = maxHurtInfo
			#maxHurtInfo = NPCHurtManager.RefreshHurtList(curNPC, tick, refreshInterval, isDead, checkCanDead)
			#
			#if maxHurtInfo:
			# tagObj, ownerType, ownerID = maxHurtInfo

			elif dropOwnerType == ChConfig.DropOwnerType_Family:
			ownerInfo = FamilyRobBoss.RefreshFamilyOwnerNPCHurt(self, curNPC, tick, refreshInterval)
			if ownerInfo:
			tagObj, ownerFamilyID = ownerInfo
			ownerType, ownerID = ChConfig.Def_NPCHurtTypeFamily, ownerFamilyID

			pass

			elif dropOwnerType == ChConfig.DropOwnerType_Contend:
			tagObj = self.__RefreshContendOwner()
			if tagObj:
			@@ -5233,7 +3390,7 @@
			if isDead:
			GameWorld.Log("Boss归属: key=%s,ownerType=%s,ownerID=%s" % (key, ownerType, ownerID))

			hurtList = NPCHurtManager.GetPlayerHurtList(curNPC)
			hurtList = [] #NPCHurtManager.GetPlayerHurtList(curNPC)
			# 刷新归属
			if ownerType == ChConfig.Def_NPCHurtTypePlayer:
			curPlayer = GameWorld.GetObj(ownerID, IPY_GameWorld.gotPlayer)
			@@ -5453,12 +3610,7 @@
			npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
			if not npcData:
			return 0
			needRealmLV = PlayerControl.GetDifficultyRealmLV(PlayerControl.GetRealmDifficulty(curPlayer))
			realmNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("NPCRealmStrengthen", npcID, needRealmLV)
			if realmNPCIpyData:
			baseExp = realmNPCIpyData.GetExp()
			else:
			baseExp = npcData.GetExp()
			baseExp = npcData.GetExp()
			if not baseExp:
			return 0
			npcLV = npcData.GetLV()
			@@ -5555,9 +3707,6 @@

			# 采集耗时
			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)))
			prepareType = IPY_GameWorld.pstCollecting if curNPC.GetType() == IPY_GameWorld.ntCollection else IPY_GameWorld.pstMissionCollecting
			PlayerControl.Sync_PrepareBegin(curPlayer, prepareTime, prepareType, prepareID=curNPC.GetID())
			if collectNPCIpyData.GetLostHPPer():
			@@ -5660,130 +3809,8 @@
			DoGiveCollectNPCAward(curPlayer, npcID, collectNPCIpyData, crossCollectOK=True)
			return

			#// A2 34 自定义场景中获取采集奖励 #tagCMGetCustomSceneCollectAward
			#
			#struct tagCMGetCustomSceneCollectAward
			#{
			# tagHead Head;
			# DWORD NPCID; //采集的NPCID
			#};
			def OnGetCustomSceneCollectAward(index, clientData, tick):
			curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
			playerID = curPlayer.GetPlayerID()
			npcID = clientData.NPCID
			if not curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
			GameWorld.ErrLog("非自定义场景中，无法获取定义采集奖励!", playerID)
			return
			mapID = PlayerControl.GetCustomMapID(curPlayer)
			lineID = PlayerControl.GetCustomLineID(curPlayer)
			GameWorld.Log("前端场景采集: mapID=%s,lineID=%s,npcID=%s" % (mapID, lineID, npcID), playerID)
			if not mapID:
			GameWorld.ErrLog("无自定义场景地图ID，不允许采集!", playerID)
			return

			if not FBLogic.OnCustomSceneCollectOK(curPlayer, mapID, lineID, npcID):
			GameWorld.ErrLog("自定义场景地图不允许采集! mapID=%s,lineID=%s,npcID=%s" % (mapID, lineID, npcID), playerID)
			return

			collectNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("CollectNPC", npcID)
			if collectNPCIpyData:
			DoGiveCollectNPCAward(curPlayer, npcID, collectNPCIpyData)
			return

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

			if collectNPCIpyData.GetIsMissionCollectNPC():
			#GameWorld.DebugLog("任务采集物暂不处理")
			return

			isMaxTime = False # 是否达到了采集最大次数
			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已达到最大采集次数: npcID=%s,todayCollTime=%s,limitMaxTime=%s" % (npcID, todayCollTime, limitMaxTime))
			return

			curCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)
			updCollTime = curCollTime + collectCnt
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTime % npcID, updCollTime)
			SyncCollNPCTime(curPlayer, [npcID])
			GameWorld.DebugLog(" 增加采集次数: npcID=%s,todayCollTime=%s,curCollTime=%s,updCollTime=%s" % (npcID, todayCollTime, curCollTime, updCollTime))
			isMaxTime = todayCollTime + collectCnt >= limitMaxTime

			awardItemList = []
			collectAwardCfg = collectNPCIpyData.GetCollectAward()
			collectAppointAwardCfg = collectNPCIpyData.GetCollectAppointAward()
			if collectAppointAwardCfg:
			#缥缈草园的采集定制由缥缈寻访次数决定
			if collectNPCIpyData.GetCollectResetType() in [12, 14]:
			fairyDomainVisitCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FairyDomainVisitCnt)
			grasslandCollectAppointCfg = collectAppointAwardCfg.get(fairyDomainVisitCnt, {})
			curCollTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTime % npcID)
			if curCollTime in grasslandCollectAppointCfg:
			awardItemList.append(grasslandCollectAppointCfg[curCollTime])
			GameWorld.DebugLog(" 草园采集定制奖励: fairyDomainVisitCnt=%s,curCollTime=%s,awardItemList=%s" % (fairyDomainVisitCnt, curCollTime, awardItemList))
			else:
			collTotalTime = min(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CollNpcIDCollTimeTotal % npcID) + 1, ChConfig.Def_UpperLimit_DWord)
			if collTotalTime in collectAppointAwardCfg:
			awardItemList.append(collectAppointAwardCfg[collTotalTime])
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CollNpcIDCollTimeTotal % npcID, collTotalTime)
			GameWorld.DebugLog(" 采集次数定制奖励: collTotalTime=%s,awardItemList=%s" % (collTotalTime, awardItemList))

			if not awardItemList:
			alchemyDiffLV = collectNPCIpyData.GetAlchemyDiffLV()
			giveItemWeightList = ItemCommon.GetWeightItemListByAlchemyDiffLV(curPlayer, collectAwardCfg, alchemyDiffLV)
			GameWorld.DebugLog(" 常规采集物品权重列表: alchemyDiffLV=%s,collectAwardCfg=%s,giveItemWeightList=%s" % (alchemyDiffLV, collectAwardCfg, giveItemWeightList))
			giveItemInfo = GameWorld.GetResultByWeightList(giveItemWeightList)
			if giveItemInfo:
			awardItemList.append(giveItemInfo)

			GameWorld.DebugLog(" 最终采集奖励: awardItemList=%s" % awardItemList)
			jsonItemList = []
			if awardItemList:
			for itemID, itemCount, isAuctionItem in awardItemList:
			if ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem]):
			jsonItemList.append(ItemCommon.GetJsonItem([itemID, itemCount, isAuctionItem]))

			if not isSweep:
			if collectNPCIpyData.GetNotifyCollectResult():
			awardPack = ChPyNetSendPack.tagMCCollectAwardItemInfo()
			awardPack.CollectNPCID = npcID
			for itemID, itemCount, isAuctionItem in awardItemList:
			awardItem = ChPyNetSendPack.tagMCCollectAwardItem()
			awardItem.ItemID = itemID
			awardItem.Count = itemCount
			awardItem.IsAuctionItem = isAuctionItem
			awardPack.AwardItemList.append(awardItem)
			awardPack.Count = len(awardPack.AwardItemList)
			NetPackCommon.SendFakePack(curPlayer, awardPack)
			GameLogic_CrossGrassland.RecordGrasslandAward(curPlayer, awardItemList)
			else:
			GameWorld.ErrLog("采集物品没有奖励！npcID=%s" % (npcID))

			#采集成就
			PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_Collect, collectCnt, [npcID])
			if crossCollectOK:
			PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_CrossCollect)
			#SyncCollectionItemInfo(curPlayer, addExp, addMoney, addZhenQi, giveItemInfoList, npcID)

			if not isSweep:
			GameLogic_CrossGrassland.DecCustomSceneNPCCount(curPlayer, npcID)
			if isMaxTime:
			GameLogic_CrossGrassland.DoCheckUpdateGrasslandEnd(curPlayer)

			return jsonItemList

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

			def SyncCollNPCTime(curPlayer, npcIDList=None):
			## 同步采集NPC功能号采集次数
			@@ -5825,7 +3852,7 @@
			def PlayerOnDay(curPlayer):
			#采集次数重置
			CollNPCTimeOnDay(curPlayer)
			itemDropLimitDayInfo = IpyGameDataPY.GetFuncEvalCfg("ItemDropCountLimit", 2, {})
			itemDropLimitDayInfo = {} #IpyGameDataPY.GetFuncEvalCfg("ItemDropCountLimit", 2, {})
			for itemID in itemDropLimitDayInfo.keys():
			if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_DropCountToday % itemID):
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_DropCountToday % itemID, 0)
			@@ -6009,42 +4036,6 @@
			return

			def SendGameServerGoodItemRecord(curPlayer, mapID, lineID, npcID, itemID, equipInfo=[]):
			# @param equipInfo: [equipPlace, itemClassLV, itemColor, itemQuality, itemUserData]
			# GameWorld.DebugLog("检查物品是否发送GameServer: mapID=%s, npcID=%s, playerName=%s, itemID=%s"
			# % (mapID, npcID, playerName, itemID))
			recBossIDList = IpyGameDataPY.GetFuncEvalCfg('DropRecordBossID', 1)
			if npcID not in recBossIDList:
			return
			recDropEquipInfoDict = IpyGameDataPY.GetFuncEvalCfg('DropRecordEquipment', 1, {})
			recSpecialItemIDList = IpyGameDataPY.GetFuncEvalCfg('DropRecordValue', 1)
			recItemIDList = IpyGameDataPY.GetFuncEvalCfg('DropRecordNormal', 1)
			# weightValue 珍惜度数值越大越珍贵(用于排序)
			needRecord = False
			itemUserData = ""
			if itemID in recItemIDList:
			needRecord = True
			weightValue = recItemIDList.index(itemID)
			elif itemID in recSpecialItemIDList:
			needRecord = True
			weightValue = recSpecialItemIDList.index(itemID) + 10000
			else:
			equipPlace, itemClassLV, itemColor, suiteID, itemUserData = equipInfo
			isSuit = 1 if suiteID else 0
			weightValue = itemColor1000+isSuit100+itemClassLV

			recordCondition = GameWorld.GetDictValueByKey(recDropEquipInfoDict, equipPlace)
			if recordCondition:
			needClassLV, needItemColor, needItemSuite = recordCondition
			if itemClassLV >= needClassLV and itemColor >= needItemColor and isSuit >= needItemSuite:
			needRecord = True
			if not needRecord:
			return
			playerID = curPlayer.GetID()
			playerName = curPlayer.GetName()
			serverGroupID = PlayerControl.GetPlayerServerGroupID(curPlayer)
			dropEquipMsg = str([playerID, playerName, mapID, lineID, npcID, itemID, itemUserData, weightValue, serverGroupID, curPlayer.GetLV()])
			GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'BossDropGoodItem', dropEquipMsg, len(dropEquipMsg))
			GameWorld.DebugLog("发送GameServer记录拾取掉落好物品: %s" % dropEquipMsg, playerID)
			return

			#// A5 52 购买功能NPC采集次数 #tagCMBuyCollectionCnt
			@@ -6075,16 +4066,12 @@
			buyTimesVIPPriID = IpyGameDataPY.GetFuncEvalCfg("KillBossCntLimit1", 1, {}).get(killBossMark)
			if not buyTimesVIPPriID:
			return
			canBuyCnt = PlayerVip.GetPrivilegeValue(curPlayer, buyTimesVIPPriID)
			canBuyCnt = 0
			canBuyCnt += PlayerGoldInvest.GetAddBossBuyCnt(curPlayer, killBossMark)
			hasBuyCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Boss_KillCntBuyCnt%killBossMark, 0)
			playerID = curPlayer.GetPlayerID()
			if hasBuyCnt >= canBuyCnt:
			GameWorld.DebugLog('购买BOSS可击杀次数, 已达到今日最大可购买次数，hasBuyCnt=%s, canBuyCnt=%s'%(hasBuyCnt, canBuyCnt), playerID)
			return
			canKillCnt, dayTimesLimit = BossHurtMng.GetCanKillBossCnt(curPlayer, killBossMark)
			if canKillCnt >= dayTimesLimit:
			GameWorld.DebugLog('购买BOSS可击杀次数, 剩余次数已满！，canKillCnt=%s'%(canKillCnt), playerID)
			return

			costGold = IpyGameDataPY.GetFuncEvalCfg("KillBossCntLimit1", 2, {}).get(killBossMark)
			@@ -6110,7 +4097,6 @@
			return
			# 增加购买次数
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Boss_KillCntBuyCnt%killBossMark, hasBuyCnt + 1)
			BossHurtMng.NotifyAttackBossCnt(curPlayer, killBossMark)

			CrossPlayerData.SendMergePlayerDataNow(curPlayer)
			return
			@@ -6159,26 +4145,10 @@
			GameWorld.DebugLog("通知GameServer地图Boss分流信息: mapID=%s,lineID=%s,shuntPlayerDict=%s" % (mapID, lineID, shuntPlayerDict), lineID)
			return

			def NPCSpeedChangeNotify(curNPC, speed):
			##通知NPC速度
			GameObj.NotifyObjInfoRefresh(curNPC, IPY_GameWorld.CDBPlayerRefresh_Speed, speed)
			return

			def UpdateNPCAttackCount(curPlayer, npcID, attackCount, maxCount=0):
			## 更新玩家攻击NPC次数
			if not npcID:
			return
			GameWorld.DebugLog("更新玩家攻击NPC次数: npcID=%s,attackCount=%s,maxCount=%s" % (npcID, attackCount, maxCount))
			PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_NPCAttackCount % npcID, attackCount)

			if GameWorld.IsCrossServer():
			serverGroupID = PlayerControl.GetPlayerServerGroupID(curPlayer)
			msgInfo = {"PlayerID":curPlayer.GetPlayerID(), "NPCID":npcID, "AttackCount":attackCount, "MaxCount":maxCount}
			GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_NPCAttackCount, msgInfo, [serverGroupID])
			else:
			SyncNPCAttackCount(curPlayer, [npcID])
			if attackCount and attackCount >= maxCount:
			GameLogic_CrossGrassland.DoCheckUpdateGrasslandEnd(curPlayer)
			return

			def CrossServerMsg_NPCAttackCount(curPlayer, msgData):
			@@ -6216,64 +4186,6 @@
			# @param curNPC 被攻击NPC
			# @return None
			def __OnAttackedDropItem(atkObj, curNPC):
			attackPlayer, npcObjType = AttackCommon.GetAttackPlayer(atkObj)
			if npcObjType:
			return
			if not attackPlayer:
			return
			npcID = curNPC.GetNPCID()
			ipyData = IpyGameDataPY.GetIpyGameDataNotLog("TreasureNPC", npcID)
			if not ipyData:
			return
			attackCountDropWeightInfo = ipyData.GetAttackCountDropWeightInfo()
			attackDropWeightList = ipyData.GetAttackDropWeightList()
			attackDropWeightListEx = ipyData.GetAttackDropWeightListEx()
			dropCountEx = ipyData.GetDropCountEx()
			alchemyDiffLV = ipyData.GetAlchemyDiffLV()

			mainItemWeightList = []
			if attackCountDropWeightInfo:
			maxCount = max(attackCountDropWeightInfo)
			attackCount = attackPlayer.NomalDictGetProperty(ChConfig.Def_PDict_NPCAttackCount % npcID) + 1
			if attackCount <= maxCount:
			if attackCount in attackCountDropWeightInfo:
			mainItemWeightList = attackCountDropWeightInfo[attackCount]
			UpdateNPCAttackCount(attackPlayer, npcID, attackCount, maxCount)

			if mainItemWeightList:
			mainItemWeightList = ItemCommon.GetWeightItemListByAlchemyDiffLV(attackPlayer, mainItemWeightList, alchemyDiffLV)
			elif attackDropWeightList:
			mainItemWeightList = ItemCommon.GetWeightItemListByAlchemyDiffLV(attackPlayer, attackDropWeightList, alchemyDiffLV)

			mainItemInfo = GameWorld.GetResultByWeightList(mainItemWeightList)

			if not mainItemInfo:
			notDropNotify = ipyData.GetNotDropNotify()
			if notDropNotify:
			PlayerControl.NotifyCode(attackPlayer, notDropNotify)
			return

			dropItemList = []
			if mainItemInfo:
			dropItemList.append(mainItemInfo)

			if attackDropWeightListEx and dropCountEx:
			weightListEx = ItemCommon.GetWeightItemListByAlchemyDiffLV(attackPlayer, attackDropWeightListEx, alchemyDiffLV)
			for _ in xrange(dropCountEx):
			itemInfo = GameWorld.GetResultByWeightList(weightListEx)
			if itemInfo:
			dropItemList.append(itemInfo)

			if not dropItemList:
			return

			mapID = PlayerControl.GetCustomMapID(attackPlayer)
			if mapID:
			DoGiveItemByVirtualDrop(attackPlayer, dropItemList, npcID)
			GameLogic_CrossGrassland.RecordGrasslandAward(attackPlayer, dropItemList)
			else:
			dropPosX, dropPosY = curNPC.GetPosX(), curNPC.GetPosY()
			ChItem.DoMapDropItem(attackPlayer, dropItemList, npcID, dropPosX, dropPosY, isOnlySelfSee=False)
			return