4399 【后端】【1.2.0】聊天新增支持气泡框选择功能

hxp

2018-11-01 e168d76d7d1f3cb94e2e3e9f6051dc80986fdc01

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Item/ItemControler.py

@@ -33,7 +33,9 @@
import Operate_EquipStone

import Operate_EquipSuitCompose

import IpyGameDataPY

import EventShell



import math

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

## 放不下主角背包放入万能背包的逻辑, curGiveItem 要先 SetCount

#  @param curPlayer 当前玩家

@@ -893,7 +895,7 @@
            Operate_EquipStone.DoMoveEquipStone(curPlayer, packEquipIndex)

            #套装降级处理

            Operate_EquipSuitCompose.CheckEquipSuitReduce(curPlayer, packEquipIndex)

            
            EventShell.EventRespons_EquipStar(curPlayer)

        self.RefreshStartEquipCount()

        return packEquipIndex if result else -1

    

@@ -990,6 +992,7 @@
        self.RefreshStartEquipCount()

        #套装降级处理

        Operate_EquipSuitCompose.CheckEquipSuitReduce(curPlayer, equipIndex)

        EventShell.EventRespons_EquipStar(curPlayer)

#===============================================================================

#        #destItemPlace = 卸下物品的位置        

#        destItemPlace = curPack.GetAt(packIndex)

@@ -1009,7 +1012,7 @@
#    小心, 小心, 小心, 小心, 小心

#    eggxp

#===============================================================================

    def __PutItemInVPack(self, packIndex, tagItem, event):

    def PutItemInVPack(self, packIndex, tagItem, event=["", False, {}]):

        # 虚拟背包, 默认不做叠加

        curPlayer = self.__Player

        canPutInCnt = 1

@@ -1017,7 +1020,8 @@
        eventName, isForceEvent, addDict = event

        isNeedRecord = isForceEvent or ItemNeedRecord(tagItem)

        if packIndex == ShareDefine.rptRune:

            setItemKeyData = GetRuneItemKeyData(tagItem.GetItemTypeID(), tagItem.GetUserAttr(ShareDefine.Def_IudetRuneLV))

            runeSource = tagItem.GetUserAttr(ShareDefine.Def_IudetRuneSource) or 1

            setItemKeyData = GetRuneItemKeyData(tagItem.GetItemTypeID(), tagItem.GetUserAttr(ShareDefine.Def_IudetRuneLV), source=runeSource)



        refreshPlaceList = []

        for place in xrange(ItemCommon.GetVPackCnt(packIndex)):

@@ -1044,11 +1048,11 @@
            Sync_VPackItem_Refresh(curPlayer, packIndex, refreshPlaceList)



        if tagItem and not tagItem.IsEmpty():

            tagItem.Clear()

            #tagItem.Clear()

            return False

        return True

    

    def __DoTransformItem(self, curPlayer, tagItem):

    def DoTransformItem(self, curPlayer, tagItem):

        ## 将特殊物品转化为对应数值

        itemID = tagItem.GetItemTypeID()

        if itemID not in ChConfig.Def_TransformItemIDList:

@@ -1070,6 +1074,8 @@
        elif itemID == ChConfig.Def_ItemID_BossReborn:

            msgStr = str(itemCount)

            GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, 'AddBossRebornPoint', msgStr, len(msgStr))

        elif itemID == ChConfig.Def_ItemID_Ysog:

            PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_Ysog, itemCount)

        

        return True

    

@@ -1082,10 +1088,6 @@
    def PutInItem(self, packIndex, tagItem, defaultPile=True, event=["", False, {}]):

        curPlayer = self.__Player

        

        if self.__DoTransformItem(curPlayer, tagItem):

            tagItem.Clear() # 需清除，不然会导致内存泄露

            return True

        
        isEquip = ItemCommon.CheckItemIsEquip(tagItem)

        if isEquip:

            defaultPile = False # 装备默认不判断堆叠

@@ -1094,21 +1096,28 @@
        if not curItemData:

            return False

        

        vPackItemDict = ChConfig.Def_VPackItem_Dict

        packIndex = ChConfig.GetItemPackType(curItemData.GetType(), packIndex)

        

        for pack, itemTypeList in vPackItemDict.items():

            if curItemData.GetType() in itemTypeList:

                packIndex = pack

                break

  
        if not self.CanPutInItem(packIndex, tagItem.GetItemTypeID(), tagItem.GetCount(), tagItem.GetIsBind(), defaultPile):

            GameWorld.DebugLog("背包满，不能放入物品 count = %d"%tagItem.GetCount())

        if not self.CanPutInItem(packIndex, tagItem.GetItemTypeID(), GetItemCount(tagItem), tagItem.GetIsBind(), defaultPile):

            GameWorld.DebugLog("背包满，不能放入物品 count = %d"%GetItemCount(tagItem))

            tagItem.Clear()

            return False

        

        itemID = tagItem.GetItemTypeID()

        if itemID in ChConfig.Def_TransformItemIDList:

            # 直接转化为对应货币的物品仅在放入背包时直接转化，否则还是以真实物品的形式存在，但堆叠上限需要做特殊处理

            if packIndex == IPY_GameWorld.rptItem:

                self.DoTransformItem(curPlayer, tagItem)

                tagItem.Clear() # 需清除，不然会导致内存泄露

                return True

            defaultPile = True

            maxPackCount = ChConfig.Def_UpperLimit_DWord # 转化物品叠加上限不取物品表的, 暂定堆叠上限20亿

        else:

            maxPackCount = curItemData.GetPackCount()

            
        # 虚拟背包, 默认不做叠加

        if packIndex in ShareDefine.Def_VPack_TypeList:

            return self.__PutItemInVPack(packIndex, tagItem, event)

            return self.PutItemInVPack(packIndex, tagItem, event)

        

        eventName, isForceEvent, addDict = event



@@ -1141,9 +1150,9 @@
                if item.GetIsLocked() == True:

                    continue

                

                packItemCount = item.GetCount()

                curItemCount = tagItem.GetCount()

                canPutinCount = tagItem.GetPackCount() - packItemCount

                packItemCount = GetItemCount(item)

                curItemCount = GetItemCount(tagItem)

                canPutinCount = maxPackCount - packItemCount

                if canPutinCount <= 0:

                    continue    

                #可以摆放

@@ -1179,19 +1188,17 @@
            if item.IsEmpty() != True:

                continue

            

            packItemCount = item.GetCount() # Ϊ0

            curItemCount = tagItem.GetCount()

            canPutinCount = tagItem.GetPackCount() - packItemCount

            packItemCount = GetItemCount(item) # Ϊ0

            curItemCount = GetItemCount(tagItem)

            canPutinCount = maxPackCount - packItemCount

            if canPutinCount <= 0:

                continue

            #可以摆放

            if curItemCount > canPutinCount:

                #需要创建新物品放入

                curCreateItem = ItemCommon.CreateSingleItem(tagItem.GetItemTypeID())

                curCreateItem = GetOutPutItemObj(tagItem.GetItemTypeID(), canPutinCount, isBind)

                #注意: 不能在这里AssignItem, 否则会有2个物品指针指向同一个物品实例 . 巨大的错误在这一句 : curCreateItem.Assign(tagItem)

                SetItemCount(curCreateItem, canPutinCount)

                SetItemIsBind(curCreateItem, isBind)

                #此处不做装备拆解，如有需求外传for处理

                #如果是装备，那么 maxPackCount 为1 这里会循环自动创建新物品，所以直接 GetOutPutItemObj 即可, 暂不支持定制装备拆解

                

                item.AssignItem(curCreateItem)

                SetItemCount(tagItem, curItemCount - canPutinCount)

@@ -1201,6 +1208,9 @@
                    ItemCommon.DR_GetItem(curPlayer, packIndex, eventName, itemNoteDict, addDict)

            else:

                #可以放下

                if isEquip:

                    self.CheckEquipAttr(packIndex, tagItem)

                    
                if tagItem.GetGameWorldItemType() == IPY_GameWorld.gwitRoleItem:

                    item.PutIn(tagItem)

                elif tagItem.GetGameWorldItemType() == IPY_GameWorld.gwitSingleItem:

@@ -1210,13 +1220,58 @@
                putResult = True

                

                if isNeedRecord:

                    itemNoteDict = ItemCommon.GetItemNoteDict(item, curItemCount, packItemCount, item.GetCount())

                    itemNoteDict = ItemCommon.GetItemNoteDict(item, curItemCount, packItemCount, GetItemCount(item))

                    ItemCommon.DR_GetItem(curPlayer, packIndex, eventName, itemNoteDict, addDict)

                break

                                                

        #放入东西

        return putResult

    

    def CheckEquipAttr(self, packType, curItem):

        legendAttrIDCount = curItem.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrID)

        legendAttrValueCount = curItem.GetUserAttrCount(ShareDefine.Def_IudetLegendAttrValue)

        
        if legendAttrIDCount and legendAttrValueCount and legendAttrIDCount == legendAttrValueCount:

            return

        
        legendAttrInfo = GetAddEquipLegendAttr(curItem)

        if not legendAttrInfo:

            return

        
        curPlayer = self.__Player

        srcScore = ItemCommon.GetEquipGearScore(curItem)

        legendAttrIDList, legendAttrValueList = legendAttrInfo

        curItem.ClearUserAttr(ShareDefine.Def_IudetLegendAttrID)

        curItem.ClearUserAttr(ShareDefine.Def_IudetLegendAttrValue)

        for i in xrange(len(legendAttrIDList)):

            curItem.AddUserAttr(ShareDefine.Def_IudetLegendAttrID, legendAttrIDList[i])

            curItem.AddUserAttr(ShareDefine.Def_IudetLegendAttrValue, legendAttrValueList[i])

        ItemCommon.MakeEquipGS(curItem)

        updScore = ItemCommon.GetEquipGearScore(curItem)

        GameWorld.ErrLog("传奇属性异常，重新刷新一次属性: packType=%s,itemID=%s,legendAttrIDList=%s,legendAttrValueList=%s,srcScore=%s,updScore=%s" 
                         % (packType, curItem.GetItemTypeID(), legendAttrIDList, legendAttrValueList, srcScore, updScore), curPlayer.GetPlayerID())

        return

    
    def CheckRolePackEquipAttr(self):

        curPlayer = self.__Player

        key = "LoginCheckEquipAttr"

        if curPlayer.NomalDictGetProperty(key):

            return

        checkPackList = [IPY_GameWorld.rptEquip, IPY_GameWorld.rptItem, IPY_GameWorld.rptWarehouse]

        for packType in checkPackList:

            curPack = curPlayer.GetItemManager().GetPack(packType)

            for i in xrange(curPack.GetCount()):

                curItem = curPack.GetAt(i)

                #GameWorld.DebugLog("packType=%s,i=%s" % (packType, i))

                if curItem.IsEmpty():

                    continue

                isEquip = ItemCommon.CheckItemIsEquip(curItem)

                if not isEquip:

                    continue

                self.CheckEquipAttr(packType, curItem)

        PlayerControl.NomalDictSetProperty(curPlayer, key, 1)

        return



    ## 是否能放入物品 

    #  @param packIndex 背包索引

    #  @param curItemID 当前物品ID

@@ -1246,14 +1301,19 @@
            return False, 0 

        

        if curItemID in ChConfig.Def_TransformItemIDList:

            #特殊物品无需判断数量

            return True, 0

        
        maxPackCount = curItemData.GetPackCount()

        
            # 货币直接转换的物品如果是放入背包的则直接转化，无需暂用格子

            if packIndex == IPY_GameWorld.rptItem:

                return True, 0

            maxPackCount = ChConfig.Def_UpperLimit_DWord # 转化物品叠加上限不取物品表的, 暂定堆叠上限20亿

        else:

            maxPackCount = curItemData.GetPackCount()

            
        if maxPackCount == 0:

            GameWorld.Log("策划填表错误 %s -> maxPackCount = %s" % (curItemID , maxPackCount))

            return False, 0

        
        # 特殊处理不同的物品放入不同的背包，如神兽背包

        packIndex = ChConfig.GetItemPackType(curItemData.GetType(), packIndex)

        

        maxCanPutItem = 0

        curPlayer = self.__Player

@@ -1271,7 +1331,7 @@
        

        itemIndex = -1

        curPack = self.__PlayerItemManager.GetPack(packIndex)

        for i in range(0, curPack.GetCount()):

        for i in xrange(curPack.GetCount()):

            item = curPack.GetAt(i)



            if item.IsEmpty():

@@ -1285,10 +1345,10 @@
                        continue

    

                    if (CanPackItemByItemType(item.GetItemTypeID(), item.GetIsBind(), curItemID, isBind) and

                        maxPackCount > item.GetCount()):

                        maxPackCount > GetItemCount(item)):

                        #该物品锁定不执行==============================================

                        #可堆叠

                        maxCanPutItem += maxPackCount - item.GetCount()

                        maxCanPutItem += maxPackCount - GetItemCount(item)

                        if itemIndex == -1:

                            itemIndex = i

            

@@ -1300,13 +1360,14 @@
        return True, itemIndex

    

#==============================================================================

# 符印物品存储字典数值数据结构: 前5位为物品ID, 6~8位为强化等级, 第10位为是否锁定

def GetRuneItemKeyData(itemID, RuneLV, lockState=0):

# 符印物品存储字典数值数据结构: 前5位为物品ID, 6~8位为强化等级, 第9位为来源（老号0,默认1，合成2）,第10位为是否锁定

def GetRuneItemKeyData(itemID, RuneLV, lockState=0, source=1):

    lockState = 1 if lockState > 0 else 0

    return lockState * 1000000000 + min(RuneLV, 999) * 100000 + itemID

    return lockState * 1000000000 + source * 100000000 + min(RuneLV, 999) * 100000 + itemID

def GetRuneItemID(keyData): return keyData % 100000

def GetRuneItemPlusLV(keyData): return keyData % 100000000 / 100000

def GetRuneItemIsLock(keyData): return keyData / 1000000000

def GetRuneItemSource(keyData): return keyData % 1000000000 / 100000000

def IsRuneItemNeedRecord(curItem, plusLV):

    return plusLV > 0 or curItem.GetItemColor() >= ChConfig.Def_Quality_Orange



@@ -1365,7 +1426,7 @@
    DropItemToOtherPack(curPlayer, clientData.SrcBackpack, clientData.DesBackPack, clientData.SrcIndex, clientData.IsAll)

    return



def DropItemToOtherPack(curPlayer, fromPackIndex, toPackIndex, index, isAll=False):

def DropItemToOtherPack(curPlayer, fromPackIndex, desPackIndex, index, isAll=False):

    '''拖动某个背包物品到玩家物品背包

    '''

    movePack = curPlayer.GetItemManager().GetPack(fromPackIndex)

@@ -1376,26 +1437,46 @@
    

    #整个背包转移

    if isAll:

        fullPackList = []

        for itemIndex in xrange(movePack.GetCount()):

            curItem = movePack.GetAt(itemIndex)

            if not curItem or curItem.IsEmpty():

                continue

            toPackIndex = ChConfig.GetItemPackType(curItem.GetType(), desPackIndex)

            if toPackIndex in fullPackList:

                continue

            if not __DoDropItemToOtherPack(curPlayer, itemControl, fromPackIndex, toPackIndex, itemIndex, curItem):

                return

                if toPackIndex not in fullPackList:

                    fullPackList.append(toPackIndex)

                    
        for fullPackIndex in fullPackList:

            PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_676165", [fullPackIndex])

            

    #单个物品转移

    else:

        curItem = movePack.GetAt(index)

        if not curItem or curItem.IsEmpty():

            return

        toPackIndex = ChConfig.GetItemPackType(curItem.GetType(), desPackIndex)

        __DoDropItemToOtherPack(curPlayer, itemControl, fromPackIndex, toPackIndex, index, curItem)

    return



def __DoDropItemToOtherPack(curPlayer, itemControl, fromPackIndex, toPackIndex, itemIndex, curItem):

    if itemControl.DoTransformItem(curPlayer, curItem):

        curItem.Clear()

        return True

    curItemTypeID = curItem.GetItemTypeID()

    #curItemGUID = curItem.GetGUID()

    curItemCount = curItem.GetCount()

    curItemIsBind = curItem.GetIsBind()

    #toPackIndex = ChConfig.GetItemPackType(curItem.GetType(), toPackIndex)

    
    # 常规物品转移到虚拟符印背包

    if toPackIndex == ShareDefine.rptRune:

        if not ItemCommon.CheckPackHasSpace(curPlayer, toPackIndex, True):

            return False

        return itemControl.PutItemInVPack(toPackIndex, curItem)

    
    checkRet, putIndex = itemControl.CanPutInItemEx(toPackIndex, curItemTypeID, curItemCount, curItemIsBind)

    if not checkRet:

        return False

@@ -1576,6 +1657,8 @@
    itemList = []   # 非装备普通物品

    equipGSGreaterList = [] # 属于本职业的高评分装备

    equipGSLesserList = []  # 低评分装备和非本职业

    runeItemList = []   # 符印

    
    #EquipGSTypeForSort

    equipPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)

    #组合列表

@@ -1596,7 +1679,9 @@
                equipGS = 1

                cmpEquipGS = 2

                

            if equipGS == 0:

            if tmpItem.GetType() in [ChConfig.Def_ItemType_Rune, ChConfig.Def_ItemType_RuneExp]:

                runeItemList.append(tmpItem)

            elif equipGS == 0:

                itemList.append(tmpItem)

            elif equipGS > cmpEquipGS:

                equipGSGreaterList.append(tmpItem)

@@ -1606,7 +1691,8 @@
    equipGSGreaterList.sort(__CmpRolePack)

    itemList.sort(__CmpRolePack)

    equipGSLesserList.sort(__CmpRolePack)



    runeItemList.sort(__CmpRolePack)

    
    #===========================================================================

    # GameWorld.DebugLog("equipGSGreaterList")

    # for item in equipGSGreaterList:

@@ -1641,6 +1727,11 @@
    for item in equipGSLesserList:

        curPack.GetAt(putPlace).AssignItem(item, False)

        putPlace += 1

        
    for item in runeItemList:

        curPack.GetAt(putPlace).AssignItem(item, False)

        putPlace += 1

        
    return





@@ -1882,11 +1973,10 @@
        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_GetSpecialItem, 1, [itemID])

        return True

    

    vPackItemDict = ChConfig.Def_VPackItem_Dict

    for pack, itemTypeList in vPackItemDict.items():

        if curItemData.GetType() in itemTypeList:

            packIndexList = [pack]

            break

    defaultPack = IPY_GameWorld.rptItem if not packIndexList else packIndexList[0]

    packIndex = ChConfig.GetItemPackType(curItemData.GetType(), defaultPack)

    if packIndex != defaultPack or not packIndexList:

        packIndexList = [packIndex]

    

    if not __Check_CanPutItemInPack(curPlayer, itemID, itemCount, itemIsBind, packIndexList, defaultPile):

        #不可放入

@@ -2127,7 +2217,21 @@
            errorInfo = "%s %s %s -- ItemControler->SetItemCount::" % (playerID, accID, playerName)

            GameWorld.ErrLog(errorInfo + str(traceback.extract_stack()) + "\n" + traceback.format_exc())

            raise

        
def GetItemCount(item):

    if item.GetItemTypeID() in ChConfig.Def_TransformItemIDList:

        return item.GetUserAttr(ShareDefine.Def_IudetItemCount)

    return item.GetCount()



def GetItemNeedPackCount(packType, itemData, itemCount):

    if itemData.GetItemTypeID() in ChConfig.Def_TransformItemIDList:

        # 货币直接转换的物品如果是放入背包的则不需要暂用格子，放入其他的背包的则按物品叠加上限算

        if packType == IPY_GameWorld.rptItem:

            return 0

        packCount = ChConfig.Def_UpperLimit_DWord # 转化物品叠加上限不取物品表的

    else:

        packCount = itemData.GetPackCount()

    return int(math.ceil(itemCount / float(packCount)))



## 双手武器，需要两只手才拿得动

#  @param curEquip

@@ -2210,8 +2314,13 @@
    itemClassLV = ItemCommon.GetItemClassLV(curItem)

    itemQuality = curItem.GetItemQuality()

    key = (itemColor, itemQuality)

    isDogzEquip = ItemCommon.GetIsDogzEquip(curItem)

    # {(颜色,星级):[一般属性条数, 追求属性条数, 固定属性条数], ...}

    legAttrCntDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrCount")

    if isDogzEquip:

        #神兽装备条数不一样

        legAttrCntDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrCount", 2)

    else:

        legAttrCntDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrCount")

    if key not in legAttrCntDict:

        #GameWorld.DebugLog("该装备品质没有传奇属性: itemColor=%s,itemQuality=%s" % (itemColor, itemQuality))

        return

@@ -2240,7 +2349,13 @@
    curLegAttrIDList = []

    curLegAttrValueList = []

    # {属性ID:{颜色:数值, ...}, ...}

    legAttrValueColorDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByColor")

    if isDogzEquip:

        # 神兽装备数值不一样 
        legAttrValueColorDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByColor2", 1, {})

        legAttrValueClassLVColorDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByColor2", 2, {})

    else:

        legAttrValueColorDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByColor", 1, {})

        legAttrValueClassLVColorDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByColor", 2, {})

    legAttrValueClassLVDict = IpyGameDataPY.GetFuncEvalCfg("LegendAttrValueByClassLV")

    for attrID in randAttrIDList:

        if attrID in legAttrValueColorDict:

@@ -2249,6 +2364,24 @@
                GameWorld.ErrLog("没有配置传奇属性ID装备颜色对应的数值, attrID=%s,itemColor=%s" % (attrID, itemColor))

                continue

            attrValue = colorValueDict[itemColor]

        # {属性ID:{阶:{颜色:数值, ...}, ...}, ...}

        elif attrID in legAttrValueClassLVColorDict:

            classLVColorValueDict = legAttrValueClassLVColorDict[attrID]

            if itemClassLV in classLVColorValueDict:

                colorValueDict = classLVColorValueDict[itemClassLV]

            else:

                minClassLV, maxClassLV = min(classLVColorValueDict), max(classLVColorValueDict)

                if itemClassLV <= minClassLV:

                    colorValueDict = classLVColorValueDict[minClassLV]

                elif itemClassLV >= maxClassLV:

                    colorValueDict = classLVColorValueDict[maxClassLV]

                else:

                    GameWorld.ErrLog("没有配置传奇属性ID装备阶级颜色对应的数值, attrID=%s,itemClassLV=%s" % (attrID, itemClassLV))

                    continue

            if itemColor not in colorValueDict:

                GameWorld.ErrLog("没有配置传奇属性ID装备阶级颜色对应的数值, attrID=%s,itemClassLV=%s,itemColor=%s" % (attrID, itemClassLV, itemColor))

                continue

            attrValue = colorValueDict[itemColor]

        elif attrID in legAttrValueClassLVDict:

            classLVValueDict = legAttrValueClassLVDict[attrID]

            if itemClassLV in classLVValueDict: